using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.NetworkInformation;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Security.Principal;
using System.Text;
using System.Text.Json;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Awwdio;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BepInEx.NET.Common;
using BepInExResoniteShim;
using BepisResoniteWrapper;
using BepuPhysics.Collidables;
using DesktopBuddy.Shared;
using Elements.Assets;
using Elements.Core;
using FFmpeg.AutoGen;
using FrooxEngine;
using FrooxEngine.CommonAvatar;
using FrooxEngine.UIX;
using HarmonyLib;
using InterprocessLib;
using Microsoft.CodeAnalysis;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
using Renderite.Shared;
using SkyFrost.Base;
using WinRT;
using Windows.Foundation;
using Windows.Foundation.Metadata;
using Windows.Graphics;
using Windows.Graphics.Capture;
using Windows.Graphics.DirectX;
using Windows.Graphics.DirectX.Direct3D11;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(/*Could not decode attribute arguments.*/)]
[assembly: TargetFramework(".NETCoreApp,Version=v10.0", FrameworkDisplayName = ".NET 10.0")]
[assembly: AssemblyCompany("DesktopBuddy")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e5251e37dd743ac1b5ffad5e3f95aa6063a3aabc")]
[assembly: AssemblyProduct("DesktopBuddy")]
[assembly: AssemblyTitle("DesktopBuddy")]
[assembly: TargetPlatform("Windows10.0.26100.0")]
[assembly: SupportedOSPlatform("Windows10.0.19041.0")]
[assembly: SecurityPermission((SecurityAction)8, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace BepInEx
{
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class BepInAutoPluginAttribute : global::System.Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null, string? authors = null, string? link = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(/*Could not decode attribute arguments.*/)]
	[Conditional("CodeGeneration")]
	[Embedded]
	internal sealed class PatcherAutoPluginAttribute : global::System.Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[Embedded]
	internal sealed class EmbeddedAttribute : global::System.Attribute
	{
	}
}
namespace DesktopBuddy
{
	internal static class DesktopBuddyFirstRunSetup
	{
		internal enum SetupAction
		{
			SoftCamRegistration,
			VBCableInstall,
			VBCableLoopback,
			UrlAcl
		}

		internal sealed class SetupState
		{
			internal static readonly SetupState Ok = new SetupState();

			[field: CompilerGenerated]
			internal global::System.Collections.Generic.IReadOnlyList<SetupItem> Items
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			} = global::System.Array.Empty<SetupItem>();

			[field: CompilerGenerated]
			internal global::System.Collections.Generic.IReadOnlyList<SetupAction> RequiredActions
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			} = global::System.Array.Empty<SetupAction>();

			internal bool HasIssues => Enumerable.Any<SetupItem>((global::System.Collections.Generic.IEnumerable<SetupItem>)Items, (Func<SetupItem, bool>)((SetupItem item) => !item.IsOk));

			internal bool HasRequiredActions => ((global::System.Collections.Generic.IReadOnlyCollection<SetupAction>)RequiredActions).Count > 0;
		}

		internal sealed class SetupItem
		{
			[field: CompilerGenerated]
			internal string Name
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}

			[field: CompilerGenerated]
			internal string Status
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}

			[field: CompilerGenerated]
			internal string Detail
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}

			[field: CompilerGenerated]
			internal bool IsOk
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}

			[field: CompilerGenerated]
			internal bool RequiresAdminAction
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}

			[field: CompilerGenerated]
			internal SetupAction? Action
			{
				[CompilerGenerated]
				get;
				[CompilerGenerated]
				init;
			}
		}

		[CompilerGenerated]
		private sealed class <GetSoftCamInprocKeys>d__31 : global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private ValueTuple<RegistryKey, string> <>2__current;

			private int <>l__initialThreadId;

			ValueTuple<RegistryKey, string> global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>>.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			object global::System.Collections.IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSoftCamInprocKeys>d__31(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: 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_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: 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_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.ClassesRoot, "CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					return false;
				}
			}

			bool global::System.Collections.IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>> global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetSoftCamInprocKeys>d__31(0);
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetSoftCamRegisteredDlls>d__30 : global::System.Collections.Generic.IEnumerable<string>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<string>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>> <>7__wrap1;

			private RegistryKey <opened>5__3;

			string global::System.Collections.Generic.IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object global::System.Collections.IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSoftCamRegisteredDlls>d__30(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || num == 1)
				{
					try
					{
						if (num == -4 || num == 1)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<opened>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: 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)
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -4;
						goto IL_00aa;
					}
					<>1__state = -1;
					<>7__wrap1 = GetSoftCamInprocKeys().GetEnumerator();
					<>1__state = -3;
					goto IL_00b7;
					IL_00aa:
					<>m__Finally2();
					<opened>5__3 = null;
					goto IL_00b7;
					IL_00b7:
					if (((global::System.Collections.IEnumerator)<>7__wrap1).MoveNext())
					{
						ValueTuple<RegistryKey, string> current = <>7__wrap1.Current;
						<opened>5__3 = current.Item1.OpenSubKey(current.Item2);
						<>1__state = -4;
						RegistryKey obj = <opened>5__3;
						string text = ((obj != null) ? obj.GetValue("") : null) as string;
						if (!string.IsNullOrWhiteSpace(text))
						{
							<>2__current = text.Trim('"');
							<>1__state = 1;
							return true;
						}
						goto IL_00aa;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

			bool global::System.Collections.IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					((global::System.IDisposable)<>7__wrap1).Dispose();
				}
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				if (<opened>5__3 != null)
				{
					((global::System.IDisposable)<opened>5__3).Dispose();
				}
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<string> global::System.Collections.Generic.IEnumerable<string>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetSoftCamRegisteredDlls>d__30(0);
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<string>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetSoftCamRegistryTrees>d__32 : global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private ValueTuple<RegistryKey, string> <>2__current;

			private int <>l__initialThreadId;

			ValueTuple<RegistryKey, string> global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>>.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			object global::System.Collections.IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSoftCamRegistryTrees>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: 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)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
					<>1__state = 9;
					return true;
				case 9:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
					<>1__state = 10;
					return true;
				case 10:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
					<>1__state = 11;
					return true;
				case 11:
					<>1__state = -1;
					<>2__current = new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
					<>1__state = 12;
					return true;
				case 12:
					<>1__state = -1;
					return false;
				}
			}

			bool global::System.Collections.IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>> global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetSoftCamRegistryTrees>d__32(0);
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>>)this).GetEnumerator();
			}
		}

		[CompilerGenerated]
		private sealed class <GetSoftCamUnregisterCandidates>d__29 : global::System.Collections.Generic.IEnumerable<string>, global::System.Collections.IEnumerable, global::System.Collections.Generic.IEnumerator<string>, global::System.Collections.IEnumerator, global::System.IDisposable
		{
			private int <>1__state;

			private string <>2__current;

			private int <>l__initialThreadId;

			private string runtimeDir;

			public string <>3__runtimeDir;

			private global::System.Collections.Generic.IEnumerator<string> <>7__wrap1;

			string global::System.Collections.Generic.IEnumerator<string>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object global::System.Collections.IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetSoftCamUnregisterCandidates>d__29(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void global::System.IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 3)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = Path.Combine(runtimeDir, "softcam64.dll");
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						<>2__current = Path.Combine(runtimeDir, "softcam.dll");
						<>1__state = 2;
						return true;
					case 2:
						<>1__state = -1;
						<>7__wrap1 = GetSoftCamRegisteredDlls().GetEnumerator();
						<>1__state = -3;
						break;
					case 3:
						<>1__state = -3;
						break;
					}
					if (((global::System.Collections.IEnumerator)<>7__wrap1).MoveNext())
					{
						string current = <>7__wrap1.Current;
						<>2__current = current;
						<>1__state = 3;
						return true;
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					return false;
				}
				catch
				{
					//try-fault
					((global::System.IDisposable)this).Dispose();
					throw;
				}
			}

			bool global::System.Collections.IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 != null)
				{
					((global::System.IDisposable)<>7__wrap1).Dispose();
				}
			}

			[DebuggerHidden]
			void global::System.Collections.IEnumerator.Reset()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			global::System.Collections.Generic.IEnumerator<string> global::System.Collections.Generic.IEnumerable<string>.GetEnumerator()
			{
				<GetSoftCamUnregisterCandidates>d__29 <GetSoftCamUnregisterCandidates>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<GetSoftCamUnregisterCandidates>d__ = this;
				}
				else
				{
					<GetSoftCamUnregisterCandidates>d__ = new <GetSoftCamUnregisterCandidates>d__29(0);
				}
				<GetSoftCamUnregisterCandidates>d__.runtimeDir = <>3__runtimeDir;
				return <GetSoftCamUnregisterCandidates>d__;
			}

			[DebuggerHidden]
			global::System.Collections.IEnumerator global::System.Collections.IEnumerable.GetEnumerator()
			{
				return (global::System.Collections.IEnumerator)((global::System.Collections.Generic.IEnumerable<string>)this).GetEnumerator();
			}
		}

		private const string SoftCamClsid = "{AEF3B972-5FA5-4647-9571-358EB472BC9E}";

		private const string VideoInputCategoryClsid = "{860BB310-5D01-11d0-BD3B-00A0C911CE86}";

		private const string SetupHashFile = "DesktopBuddySetupHashes.txt";

		private const string PackagedSetupHashFile = "DesktopBuddySetupPayloads.md5";

		internal static SetupState Check()
		{
			try
			{
				string runtimeDir = GetRuntimeDir();
				Log.Msg("[Setup] Checking DesktopBuddy local setup");
				Log.Msg("[Setup] Runtime path: " + runtimeDir);
				global::System.Collections.Generic.IReadOnlyList<SetupItem> setupItems = GetSetupItems(runtimeDir);
				return new SetupState
				{
					Items = setupItems,
					RequiredActions = (global::System.Collections.Generic.IReadOnlyList<SetupAction>)GetRequiredActions(setupItems)
				};
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[Setup] First-run setup check failed: {ex}");
				SetupState setupState = new SetupState();
				setupState.Items = new SetupItem[1]
				{
					new SetupItem
					{
						Name = "Setup check",
						Status = "Error",
						Detail = ex.Message,
						IsOk = false
					}
				};
				return setupState;
			}
		}

		internal static Process StartElevatedSetup(global::System.Collections.Generic.IReadOnlyCollection<SetupAction> actions = null)
		{
			string runtimeDir = GetRuntimeDir();
			List<SetupAction> val = ((actions == null || actions.Count == 0) ? GetRequiredAdminActions(runtimeDir) : NormalizeSetupActions((global::System.Collections.Generic.IEnumerable<SetupAction>)actions));
			if (val.Count == 0)
			{
				Log.Msg("[Setup] No elevated setup actions are required");
				return null;
			}
			Log.Msg("[Setup] User requested admin setup: " + string.Join(", ", Enumerable.Select<SetupAction, string>((global::System.Collections.Generic.IEnumerable<SetupAction>)val, (Func<SetupAction, string>)GetActionLabel)));
			if (IsAdministrator())
			{
				RunAdminSetup((global::System.Collections.Generic.IReadOnlyCollection<SetupAction>)val, runtimeDir);
				return null;
			}
			return StartElevatedSetupHelper((global::System.Collections.Generic.IReadOnlyCollection<SetupAction>)val, runtimeDir);
		}

		private static List<SetupAction> GetRequiredAdminActions(string runtimeDir)
		{
			return GetRequiredActions(GetSetupItems(runtimeDir));
		}

		private static List<SetupAction> GetRequiredActions(global::System.Collections.Generic.IReadOnlyList<SetupItem> items)
		{
			return NormalizeSetupActions(Enumerable.Select<SetupItem, SetupAction>(Enumerable.Where<SetupItem>((global::System.Collections.Generic.IEnumerable<SetupItem>)items, (Func<SetupItem, bool>)((SetupItem item) => item.RequiresAdminAction && item.Action.HasValue)), (Func<SetupItem, SetupAction>)((SetupItem item) => item.Action.Value)));
		}

		private static List<SetupAction> NormalizeSetupActions(global::System.Collections.Generic.IEnumerable<SetupAction> actions)
		{
			List<SetupAction> val = Enumerable.ToList<SetupAction>(Enumerable.Distinct<SetupAction>(actions));
			if (val.Contains(SetupAction.VBCableInstall) && !val.Contains(SetupAction.VBCableLoopback))
			{
				int num = val.IndexOf(SetupAction.VBCableInstall);
				val.Insert(num + 1, SetupAction.VBCableLoopback);
			}
			return val;
		}

		private static string GetActionLabel(SetupAction action)
		{
			return action switch
			{
				SetupAction.SoftCamRegistration => "SoftCam registration", 
				SetupAction.VBCableInstall => "VB-Cable install", 
				SetupAction.VBCableLoopback => "VB-Cable loopback disable", 
				SetupAction.UrlAcl => "streaming access", 
				_ => ((object)action/*cast due to .constrained prefix*/).ToString(), 
			};
		}

		private static global::System.Collections.Generic.IReadOnlyList<SetupItem> GetSetupItems(string runtimeDir)
		{
			List<SetupItem> obj = new List<SetupItem>();
			obj.Add(GetSoftCamSetupItem(runtimeDir));
			obj.Add(GetVBCableInstallSetupItem(runtimeDir));
			obj.Add(GetVBCableLoopbackSetupItem());
			obj.Add(GetUrlAclSetupItem());
			return (global::System.Collections.Generic.IReadOnlyList<SetupItem>)obj;
		}

		private static SetupItem GetSoftCamSetupItem(string runtimeDir)
		{
			string text = ((File.Exists(Path.Combine(runtimeDir, "softcam64.dll")) || !File.Exists(Path.Combine(runtimeDir, "softcam.dll"))) ? "softcam64.dll" : "softcam.dll");
			string text2 = Path.Combine(runtimeDir, text);
			string text3 = ReadPackagedSetupHash(runtimeDir, text);
			string text4 = Enumerable.FirstOrDefault<string>(GetSoftCamRegisteredDlls());
			string text5 = ReadSetupHash(runtimeDir, text);
			global::System.Collections.Generic.IReadOnlyList<string> runningRestartSensitiveProcesses = GetRunningRestartSensitiveProcesses();
			bool flag = !File.Exists(text2);
			bool flag2 = string.IsNullOrWhiteSpace(text4);
			bool flag3 = !flag2 && !PathsEqual(text4, text2);
			bool flag4 = !flag && !string.IsNullOrWhiteSpace(text3) && !string.Equals(text5, text3, (StringComparison)5);
			bool flag5 = flag || flag2 || flag3 || flag4;
			return new SetupItem
			{
				Name = "SoftCam",
				Status = (flag5 ? "Not installed" : "Installed"),
				Detail = (flag5 ? GetSoftCamSetupDetail(runningRestartSensitiveProcesses) : "Virtual camera support."),
				IsOk = !flag5,
				RequiresAdminAction = (flag5 && !flag),
				Action = SetupAction.SoftCamRegistration
			};
		}

		private static string GetSoftCamSetupDetail(global::System.Collections.Generic.IReadOnlyList<string> runningApps)
		{
			if (runningApps == null || ((global::System.Collections.Generic.IReadOnlyCollection<string>)runningApps).Count == 0)
			{
				return "Virtual camera support.";
			}
			string[] array = Enumerable.ToArray<string>(Enumerable.Take<string>((global::System.Collections.Generic.IEnumerable<string>)runningApps, 3));
			string text = ((((global::System.Collections.Generic.IReadOnlyCollection<string>)runningApps).Count > array.Length) ? $" +{((global::System.Collections.Generic.IReadOnlyCollection<string>)runningApps).Count - array.Length}" : "");
			return "Restart: " + string.Join(", ", array) + text;
		}

		private static SetupItem GetVBCableInstallSetupItem(string runtimeDir)
		{
			string text = Path.Combine(runtimeDir, "VBCABLE_Setup_x64.exe");
			string text2 = ReadPackagedSetupHash(runtimeDir, "VBCABLE_Setup_x64.exe");
			string text3 = ReadSetupHash(runtimeDir, "VBCABLE_Setup_x64.exe");
			bool num = IsVBCableInstalled();
			bool flag = !File.Exists(text);
			bool flag2 = num && !string.IsNullOrWhiteSpace(text2) && !string.Equals(text3, text2, (StringComparison)5);
			bool flag3 = !num || flag2;
			string status = (flag3 ? "Not installed" : "Installed");
			string detail = "Virtual microphone audio route.";
			return new SetupItem
			{
				Name = "VB-Cable",
				Status = status,
				Detail = detail,
				IsOk = !flag3,
				RequiresAdminAction = (flag3 && !flag),
				Action = SetupAction.VBCableInstall
			};
		}

		private static SetupItem GetVBCableLoopbackSetupItem()
		{
			bool flag = IsVBCableInstalled();
			bool flag2 = IsVBCableLoopbackDisabled();
			return new SetupItem
			{
				Name = "VB-Cable loopback",
				Status = ((!flag || flag2) ? "Installed" : "Not installed"),
				Detail = "Prevents microphone echo.",
				IsOk = (!flag || flag2),
				RequiresAdminAction = (flag && !flag2),
				Action = SetupAction.VBCableLoopback
			};
		}

		private static SetupItem GetUrlAclSetupItem()
		{
			bool flag = IsUrlAclConfigured();
			return new SetupItem
			{
				Name = "Streaming access",
				Status = (flag ? "Installed" : "Not installed"),
				Detail = "Allows local stream hosting.",
				IsOk = flag,
				RequiresAdminAction = !flag,
				Action = SetupAction.UrlAcl
			};
		}

		private static void RunAdminSetup(global::System.Collections.Generic.IReadOnlyCollection<SetupAction> actions, string runtimeDir)
		{
			Log.Msg("[Setup] Running admin setup inside DesktopBuddy");
			global::System.Collections.Generic.IEnumerator<SetupAction> enumerator = ((global::System.Collections.Generic.IEnumerable<SetupAction>)actions).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					switch (enumerator.Current)
					{
					case SetupAction.SoftCamRegistration:
						RegisterSoftCam(runtimeDir);
						break;
					case SetupAction.VBCableInstall:
						InstallVBCable(runtimeDir);
						break;
					case SetupAction.VBCableLoopback:
						ConfigureVBCableLoopback();
						break;
					case SetupAction.UrlAcl:
						ConfigureUrlAcl();
						break;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			WriteSetupHashes(runtimeDir);
			Log.Msg("[Setup] Admin setup complete");
		}

		private static Process StartElevatedSetupHelper(global::System.Collections.Generic.IReadOnlyCollection<SetupAction> actions, string runtimeDir)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			string logPath = Path.Combine(runtimeDir, "DesktopBuddySetup.log");
			string text = BuildElevatedSetupScript(actions, runtimeDir, logPath);
			string text2 = Path.Combine(runtimeDir, "DesktopBuddyElevatedSetup.ps1");
			File.WriteAllText(text2, text, Encoding.UTF8);
			string arguments = "-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File \"" + text2 + "\"";
			ProcessStartInfo val = new ProcessStartInfo
			{
				FileName = "powershell.exe",
				Arguments = arguments,
				UseShellExecute = true,
				Verb = "runas",
				WindowStyle = (ProcessWindowStyle)1
			};
			try
			{
				Log.Msg("[Setup] Requesting administrator permission for user-approved setup");
				Process val2 = Process.Start(val);
				if (val2 == null)
				{
					Log.Msg("[Setup] Elevated setup helper did not start");
					return null;
				}
				return val2;
			}
			catch (object obj) when (((Func<bool>)delegate
			{
				// Could not convert BlockContainer to single expression
				object obj2 = ((obj is Win32Exception) ? obj : null);
				return obj2 != null && ((Win32Exception)obj2).NativeErrorCode == 1223;
			}).Invoke())
			{
				Log.Msg("[Setup] Administrator setup was cancelled by the user");
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[Setup] Failed to start elevated setup helper: " + ex.Message);
			}
			return null;
		}

		private static string BuildElevatedSetupScript(global::System.Collections.Generic.IReadOnlyCollection<SetupAction> actions, string runtimeDir, string logPath)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			StringBuilder val = new StringBuilder();
			val.AppendLine("$ErrorActionPreference = 'Continue'");
			StringBuilder val2 = val;
			StringBuilder obj = val2;
			AppendInterpolatedStringHandler val3 = default(AppendInterpolatedStringHandler);
			((AppendInterpolatedStringHandler)(ref val3))..ctor(11, 1, val2);
			((AppendInterpolatedStringHandler)(ref val3)).AppendLiteral("$runtime = ");
			((AppendInterpolatedStringHandler)(ref val3)).AppendFormatted(PsSingleQuote(runtimeDir));
			obj.AppendLine(ref val3);
			val2 = val;
			StringBuilder obj2 = val2;
			((AppendInterpolatedStringHandler)(ref val3))..ctor(7, 1, val2);
			((AppendInterpolatedStringHandler)(ref val3)).AppendLiteral("$log = ");
			((AppendInterpolatedStringHandler)(ref val3)).AppendFormatted(PsSingleQuote(logPath));
			obj2.AppendLine(ref val3);
			val.AppendLine("New-Item -ItemType Directory -Force -Path (Split-Path -Parent $log) | Out-Null");
			val.AppendLine("\"[{0:yyyy-MM-dd HH:mm:ss}] DesktopBuddy elevated setup started\" -f (Get-Date) | Set-Content -LiteralPath $log");
			val.AppendLine("function Write-SetupLog([string]$Message) { Add-Content -LiteralPath $log -Value (\"[{0:HH:mm:ss}] {1}\" -f (Get-Date), $Message) }");
			val.AppendLine("function Run-SetupProcess([string]$File, [string]$Arguments, [string]$WorkingDirectory = $runtime, [int]$TimeoutMs = 60000) {");
			val.AppendLine("  Write-SetupLog ($File + ' ' + $Arguments)");
			val.AppendLine("  try {");
			val.AppendLine("    $process = Start-Process -FilePath $File -ArgumentList $Arguments -WorkingDirectory $WorkingDirectory -WindowStyle Hidden -PassThru");
			val.AppendLine("    if (-not $process.WaitForExit($TimeoutMs)) { try { $process.Kill() } catch {}; Write-SetupLog ($File + ' timed out'); return }");
			val.AppendLine("    Write-SetupLog ($File + ' exit=' + $process.ExitCode)");
			val.AppendLine("  } catch { Write-SetupLog ($File + ' failed: ' + $_.Exception.Message) }");
			val.AppendLine("}");
			val2 = val;
			StringBuilder obj3 = val2;
			((AppendInterpolatedStringHandler)(ref val3))..ctor(16, 1, val2);
			((AppendInterpolatedStringHandler)(ref val3)).AppendLiteral("$softCamClsid = ");
			((AppendInterpolatedStringHandler)(ref val3)).AppendFormatted(PsSingleQuote("{AEF3B972-5FA5-4647-9571-358EB472BC9E}"));
			obj3.AppendLine(ref val3);
			val2 = val;
			StringBuilder obj4 = val2;
			((AppendInterpolatedStringHandler)(ref val3))..ctor(27, 1, val2);
			((AppendInterpolatedStringHandler)(ref val3)).AppendLiteral("$videoInputCategoryClsid = ");
			((AppendInterpolatedStringHandler)(ref val3)).AppendFormatted(PsSingleQuote("{860BB310-5D01-11d0-BD3B-00A0C911CE86}"));
			obj4.AppendLine(ref val3);
			global::System.Collections.Generic.IEnumerator<SetupAction> enumerator = ((global::System.Collections.Generic.IEnumerable<SetupAction>)actions).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					switch (enumerator.Current)
					{
					case SetupAction.SoftCamRegistration:
						AppendSoftCamRegistrationScript(val);
						break;
					case SetupAction.VBCableInstall:
						AppendVBCableInstallScript(val);
						break;
					case SetupAction.VBCableLoopback:
						AppendVBCableLoopbackScript(val);
						break;
					case SetupAction.UrlAcl:
						AppendUrlAclScript(val);
						break;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			AppendSetupHashScript(val);
			val.AppendLine("Write-SetupLog 'DesktopBuddy elevated setup finished'");
			return ((object)val).ToString();
		}

		private static void AppendSoftCamRegistrationScript(StringBuilder script)
		{
			script.AppendLine("Write-SetupLog 'Registering SoftCam'");
			script.AppendLine("$softCamCandidates = @((Join-Path $runtime 'softcam64.dll'), (Join-Path $runtime 'softcam.dll'))");
			script.AppendLine("foreach ($candidate in $softCamCandidates) { if (Test-Path -LiteralPath $candidate) { Run-SetupProcess 'regsvr32.exe' ('/s /u \"' + $candidate + '\"') $runtime 10000 } }");
			script.AppendLine("$softCamKeys = @(");
			script.AppendLine("  'HKCU:\\Software\\Classes\\CLSID\\' + $softCamClsid,");
			script.AppendLine("  'HKCU:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $softCamClsid,");
			script.AppendLine("  'HKLM:\\Software\\Classes\\CLSID\\' + $softCamClsid,");
			script.AppendLine("  'HKLM:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $softCamClsid,");
			script.AppendLine("  'HKCU:\\Software\\Classes\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DesktopBuddy - Camera',");
			script.AppendLine("  'HKCU:\\Software\\Classes\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DirectShow Softcam',");
			script.AppendLine("  'HKCU:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DesktopBuddy - Camera',");
			script.AppendLine("  'HKCU:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DirectShow Softcam',");
			script.AppendLine("  'HKLM:\\Software\\Classes\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DesktopBuddy - Camera',");
			script.AppendLine("  'HKLM:\\Software\\Classes\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DirectShow Softcam',");
			script.AppendLine("  'HKLM:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DesktopBuddy - Camera',");
			script.AppendLine("  'HKLM:\\Software\\Classes\\WOW6432Node\\CLSID\\' + $videoInputCategoryClsid + '\\Instance\\DirectShow Softcam'");
			script.AppendLine(")");
			script.AppendLine("foreach ($key in $softCamKeys) { if (Test-Path -LiteralPath $key) { Remove-Item -LiteralPath $key -Recurse -Force -ErrorAction SilentlyContinue; Write-SetupLog ('Removed registry key ' + $key) } }");
			script.AppendLine("$softCamDll = Join-Path $runtime 'softcam64.dll'");
			script.AppendLine("if (-not (Test-Path -LiteralPath $softCamDll)) { $softCamDll = Join-Path $runtime 'softcam.dll' }");
			script.AppendLine("if (Test-Path -LiteralPath $softCamDll) { Run-SetupProcess 'regsvr32.exe' ('/s \"' + $softCamDll + '\"') $runtime 10000 } else { Write-SetupLog 'SoftCam DLL missing' }");
		}

		private static void AppendVBCableInstallScript(StringBuilder script)
		{
			script.AppendLine("Write-SetupLog 'Installing VB-Cable'");
			script.AppendLine("$vbCableInstaller = Join-Path $runtime 'VBCABLE_Setup_x64.exe'");
			script.AppendLine("if (Test-Path -LiteralPath $vbCableInstaller) { Run-SetupProcess $vbCableInstaller '-i -h' $runtime 60000 } else { Write-SetupLog 'VB-Cable installer missing' }");
		}

		private static void AppendVBCableLoopbackScript(StringBuilder script)
		{
			script.AppendLine("Write-SetupLog 'Disabling VB-Cable loopback'");
			script.AppendLine("$vbCableKey = 'HKLM:\\Software\\VB-Audio\\Cable'");
			script.AppendLine("if (Test-Path -LiteralPath $vbCableKey) {");
			script.AppendLine("  Set-ItemProperty -LiteralPath $vbCableKey -Name 'VBAudioCableWDM_LoopBack' -Type DWord -Value 0");
			script.AppendLine("  Run-SetupProcess 'net.exe' 'stop \"AudioEndpointBuilder\" /yes' $runtime 15000");
			script.AppendLine("  Run-SetupProcess 'net.exe' 'start \"AudioEndpointBuilder\"' $runtime 15000");
			script.AppendLine("  Run-SetupProcess 'net.exe' 'stop \"AudioSrv\" /yes' $runtime 15000");
			script.AppendLine("  Run-SetupProcess 'net.exe' 'start \"AudioSrv\"' $runtime 15000");
			script.AppendLine("} else { Write-SetupLog 'VB-Cable registry key not present yet' }");
		}

		private static void AppendUrlAclScript(StringBuilder script)
		{
			script.AppendLine("Write-SetupLog 'Configuring HTTP URL ACL'");
			script.AppendLine("Run-SetupProcess 'netsh' 'http add urlacl url=http://+:48080/ sddl=D:(A;;GX;;;S-1-1-0)' $runtime 10000");
		}

		private static void AppendSetupHashScript(StringBuilder script)
		{
			script.AppendLine("$packagedHashFile = Join-Path $runtime 'DesktopBuddySetupPayloads.md5'");
			script.AppendLine("$hashFile = Join-Path $runtime 'DesktopBuddySetupHashes.txt'");
			script.AppendLine("if (Test-Path -LiteralPath $packagedHashFile) { Copy-Item -LiteralPath $packagedHashFile -Destination $hashFile -Force; Write-SetupLog ('Wrote setup hash marker ' + $hashFile) }");
			script.AppendLine("else { Write-SetupLog 'Packaged setup hash manifest missing' }");
		}

		private static string PsSingleQuote(string value)
		{
			return "'" + value.Replace("'", "''") + "'";
		}

		private static void RegisterSoftCam(string runtimeDir)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			Log.Msg("[Setup] Registering SoftCam");
			global::System.Collections.Generic.IEnumerator<string> enumerator = GetSoftCamUnregisterCandidates(runtimeDir).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					string current = enumerator.Current;
					if (File.Exists(current))
					{
						RunProcess("regsvr32.exe", "/s /u \"" + current + "\"", null, 10000);
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>> enumerator2 = GetSoftCamRegistryTrees().GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator2).MoveNext())
				{
					ValueTuple<RegistryKey, string> current2 = enumerator2.Current;
					DeleteRegistryTree(current2.Item1, current2.Item2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2)?.Dispose();
			}
			string text = Path.Combine(runtimeDir, "softcam64.dll");
			if (!File.Exists(text))
			{
				text = Path.Combine(runtimeDir, "softcam.dll");
			}
			if (!File.Exists(text))
			{
				Log.Msg("[Setup] SoftCam DLL missing in " + runtimeDir);
				return;
			}
			RunProcess("regsvr32.exe", "/s \"" + text + "\"", null, 10000);
			Log.Msg(IsSoftCamRegistered(runtimeDir) ? "[Setup] SoftCam registered" : "[Setup] WARNING: SoftCam registration did not resolve to expected path");
		}

		[IteratorStateMachine(typeof(<GetSoftCamUnregisterCandidates>d__29))]
		private static global::System.Collections.Generic.IEnumerable<string> GetSoftCamUnregisterCandidates(string runtimeDir)
		{
			yield return Path.Combine(runtimeDir, "softcam64.dll");
			yield return Path.Combine(runtimeDir, "softcam.dll");
			global::System.Collections.Generic.IEnumerator<string> enumerator = GetSoftCamRegisteredDlls().GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					yield return enumerator.Current;
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
		}

		[IteratorStateMachine(typeof(<GetSoftCamRegisteredDlls>d__30))]
		private static global::System.Collections.Generic.IEnumerable<string> GetSoftCamRegisteredDlls()
		{
			global::System.Collections.Generic.IEnumerator<ValueTuple<RegistryKey, string>> enumerator = GetSoftCamInprocKeys().GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					ValueTuple<RegistryKey, string> current = enumerator.Current;
					RegistryKey opened = current.Item1.OpenSubKey(current.Item2);
					try
					{
						string text = ((opened != null) ? opened.GetValue("") : null) as string;
						if (!string.IsNullOrWhiteSpace(text))
						{
							yield return text.Trim('"');
						}
					}
					finally
					{
						((global::System.IDisposable)opened)?.Dispose();
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
		}

		[IteratorStateMachine(typeof(<GetSoftCamInprocKeys>d__31))]
		private static global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>> GetSoftCamInprocKeys()
		{
			yield return new ValueTuple<RegistryKey, string>(Registry.ClassesRoot, "CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
		}

		[IteratorStateMachine(typeof(<GetSoftCamRegistryTrees>d__32))]
		private static global::System.Collections.Generic.IEnumerable<ValueTuple<RegistryKey, string>> GetSoftCamRegistryTrees()
		{
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
			yield return new ValueTuple<RegistryKey, string>(Registry.CurrentUser, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DesktopBuddy - Camera");
			yield return new ValueTuple<RegistryKey, string>(Registry.LocalMachine, "Software\\Classes\\WOW6432Node\\CLSID\\{860BB310-5D01-11d0-BD3B-00A0C911CE86}\\Instance\\DirectShow Softcam");
		}

		private static void DeleteRegistryTree(RegistryKey root, string subKey)
		{
			try
			{
				root.DeleteSubKeyTree(subKey, false);
				Log.Msg("[Setup] Removed registry key " + root.Name + "\\" + subKey);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[Setup] Unable to remove registry key {root.Name}\\{subKey}: {ex.Message}");
			}
		}

		private static bool IsSoftCamRegistered(string runtimeDir)
		{
			RegistryKey val = Registry.ClassesRoot.OpenSubKey("CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}\\InprocServer32");
			try
			{
				string text = ((val != null) ? val.GetValue("") : null) as string;
				if (string.IsNullOrWhiteSpace(text))
				{
					return false;
				}
				string text2 = Path.Combine(runtimeDir, "softcam64.dll");
				return string.Equals(text.Trim('"'), text2, (StringComparison)5);
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}

		private static void WriteSetupHashes(string runtimeDir)
		{
			try
			{
				Directory.CreateDirectory(runtimeDir);
				string text = Path.Combine(runtimeDir, "DesktopBuddySetupPayloads.md5");
				if (File.Exists(text))
				{
					File.Copy(text, Path.Combine(runtimeDir, "DesktopBuddySetupHashes.txt"), true);
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[Setup] Failed to write setup hash marker: " + ex.Message);
			}
		}

		private static string ReadSetupHash(string runtimeDir, string fileName)
		{
			return ReadHashFile(Path.Combine(runtimeDir, "DesktopBuddySetupHashes.txt"), fileName);
		}

		private static string ReadPackagedSetupHash(string runtimeDir, string fileName)
		{
			return ReadHashFile(Path.Combine(runtimeDir, "DesktopBuddySetupPayloads.md5"), fileName);
		}

		private static string ReadHashFile(string path, string fileName)
		{
			if (string.IsNullOrWhiteSpace(path) || string.IsNullOrWhiteSpace(fileName))
			{
				return null;
			}
			try
			{
				if (!File.Exists(path))
				{
					return null;
				}
				global::System.Collections.Generic.IEnumerator<string> enumerator = File.ReadLines(path).GetEnumerator();
				try
				{
					while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
					{
						string current = enumerator.Current;
						int num = current.IndexOf('=');
						if (num > 0 && string.Equals(current.Substring(0, num).Trim(), fileName, (StringComparison)5))
						{
							return current.Substring(num + 1).Trim();
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator)?.Dispose();
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[Setup] Failed to read setup hash marker: " + ex.Message);
			}
			return null;
		}

		private static bool PathsEqual(string left, string right)
		{
			if (string.IsNullOrWhiteSpace(left) || string.IsNullOrWhiteSpace(right))
			{
				return false;
			}
			try
			{
				left = Path.GetFullPath(left.Trim('"'));
				right = Path.GetFullPath(right.Trim('"'));
			}
			catch
			{
				left = left.Trim('"');
				right = right.Trim('"');
			}
			return string.Equals(left, right, (StringComparison)5);
		}

		private static global::System.Collections.Generic.IReadOnlyList<string> GetRunningRestartSensitiveProcesses()
		{
			HashSet<string> val = new HashSet<string>((global::System.Collections.Generic.IEnumerable<string>)new string[16]
			{
				"Discord", "DiscordCanary", "DiscordPTB", "obs64", "obs32", "zoom", "Teams", "ms-teams", "chrome", "msedge",
				"firefox", "brave", "slack", "Skype", "Webex", "ManyCam"
			}, (IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);
			SortedSet<string> val2 = new SortedSet<string>((IComparer<string>)(object)StringComparer.OrdinalIgnoreCase);
			try
			{
				Process[] processes = Process.GetProcesses();
				foreach (Process val3 in processes)
				{
					Process val4 = val3;
					try
					{
						string processName = val3.ProcessName;
						if (val.Contains(processName))
						{
							val2.Add(processName);
						}
					}
					finally
					{
						((global::System.IDisposable)val4)?.Dispose();
					}
				}
			}
			catch
			{
			}
			return Enumerable.ToArray<string>((global::System.Collections.Generic.IEnumerable<string>)val2);
		}

		private static void InstallVBCable(string runtimeDir)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			string text = Path.Combine(runtimeDir, "VBCABLE_Setup_x64.exe");
			if (!File.Exists(text))
			{
				Log.Msg("[Setup] VB-Cable installer missing at " + text);
				return;
			}
			RunProcess(text, "-i -h", runtimeDir);
			Log.Msg(IsVBCableInstalled() ? "[Setup] VB-Cable detected" : "[Setup] VB-Cable not detected yet; reboot may be required");
		}

		private static bool IsVBCableInstalled()
		{
			RegistryKey val = Registry.LocalMachine.OpenSubKey("Software\\VB-Audio\\Cable");
			try
			{
				return val != null;
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}

		private static void ConfigureVBCableLoopback()
		{
			//IL_008b: 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_00b9: 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)
			RegistryKey val = Registry.LocalMachine.OpenSubKey("Software\\VB-Audio\\Cable", true);
			try
			{
				if (val == null)
				{
					Log.Msg("[Setup] VB-Cable registry key not present yet");
					return;
				}
				if (val.GetValue("VBAudioCableWDM_LoopBack") as int? == 0)
				{
					Log.Msg("[Setup] VB-Cable loopback already disabled");
					return;
				}
				val.SetValue("VBAudioCableWDM_LoopBack", (object)0, (RegistryValueKind)4);
				Log.Msg("[Setup] VB-Cable loopback disabled");
				RunProcess("net.exe", "stop \"AudioEndpointBuilder\" /yes", null, 15000);
				RunProcess("net.exe", "start \"AudioEndpointBuilder\"", null, 15000);
				RunProcess("net.exe", "stop \"AudioSrv\" /yes", null, 15000);
				RunProcess("net.exe", "start \"AudioSrv\"", null, 15000);
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}

		private static bool IsVBCableLoopbackDisabled()
		{
			RegistryKey val = Registry.LocalMachine.OpenSubKey("Software\\VB-Audio\\Cable");
			try
			{
				return ((val != null) ? val.GetValue("VBAudioCableWDM_LoopBack") : null) as int? == 0;
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}

		private static void ConfigureUrlAcl()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (IsUrlAclConfigured())
			{
				Log.Msg("[Setup] HTTP URL ACL already configured");
				return;
			}
			RunProcess("netsh", "http add urlacl url=http://+:48080/ sddl=D:(A;;GX;;;S-1-1-0)", null, 10000);
			Log.Msg(IsUrlAclConfigured() ? "[Setup] HTTP URL ACL added" : "[Setup] WARNING: HTTP URL ACL was not detected after setup");
		}

		private static bool IsUrlAclConfigured()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ValueTuple<int, string> val = RunProcess("netsh", "http show urlacl url=http://+:48080/", null, 10000, captureOutput: true);
			if (val.Item1 == 0)
			{
				return val.Item2.Contains("48080", (StringComparison)5);
			}
			return false;
		}

		private static ValueTuple<int, string> RunProcess(string fileName, string arguments, string workingDirectory = null, int timeoutMs = 60000, bool captureOutput = false)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			Process val = Process.Start(new ProcessStartInfo
			{
				FileName = fileName,
				Arguments = arguments,
				WorkingDirectory = (workingDirectory ?? ResolveResoniteRoot()),
				UseShellExecute = false,
				CreateNoWindow = true,
				RedirectStandardOutput = captureOutput,
				RedirectStandardError = captureOutput,
				WindowStyle = (ProcessWindowStyle)1
			});
			try
			{
				if (val == null)
				{
					return new ValueTuple<int, string>(-1, "");
				}
				if (!val.WaitForExit(timeoutMs))
				{
					try
					{
						val.Kill();
					}
					catch
					{
					}
					Log.Msg("[Setup] " + fileName + " timed out");
					return new ValueTuple<int, string>(-1, "");
				}
				string text = "";
				if (captureOutput)
				{
					text = (((TextReader)val.StandardOutput).ReadToEnd() + "\n" + ((TextReader)val.StandardError).ReadToEnd()).Trim();
				}
				Log.Msg($"[Setup] {fileName} {arguments} exit={val.ExitCode}");
				return new ValueTuple<int, string>(val.ExitCode, text);
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}

		private static bool IsAdministrator()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			WindowsIdentity current = WindowsIdentity.GetCurrent();
			try
			{
				return new WindowsPrincipal(current).IsInRole((WindowsBuiltInRole)544);
			}
			finally
			{
				((global::System.IDisposable)current)?.Dispose();
			}
		}

		private static string GetRuntimeDir()
		{
			return DesktopBuddyRuntimePaths.GetDirectory();
		}

		private static string ResolveResoniteRoot()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			string text = Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? ".";
			for (DirectoryInfo val = new DirectoryInfo(text); val != null; val = val.Parent)
			{
				if (File.Exists(Path.Combine(((FileSystemInfo)val).FullName, "Resonite.exe")))
				{
					return ((FileSystemInfo)val).FullName;
				}
			}
			return AppDomain.CurrentDomain.BaseDirectory ?? text;
		}
	}
	[ResonitePlugin("com.devl0rd.DesktopBuddy", "DesktopBuddy", "1.1.0", "DevL0rd", "https://github.com/DevL0rd/DesktopBuddy")]
	[BepInPlugin("com.devl0rd.DesktopBuddy", "DesktopBuddy", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class DesktopBuddyMod : BasePlugin
	{
		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int UnhandledExceptionFilterDelegate(nint exceptionPointers);

		private struct JOBOBJECT_BASIC_LIMIT_INFORMATION
		{
			public long PerProcessUserTimeLimit;

			public long PerJobUserTimeLimit;

			public uint LimitFlags;

			public nuint MinimumWorkingSetSize;

			public nuint MaximumWorkingSetSize;

			public uint ActiveProcessLimit;

			public long Affinity;

			public uint PriorityClass;

			public uint SchedulingClass;
		}

		private struct IO_COUNTERS
		{
			public ulong ReadOperationCount;

			public ulong WriteOperationCount;

			public ulong OtherOperationCount;

			public ulong ReadTransferCount;

			public ulong WriteTransferCount;

			public ulong OtherTransferCount;
		}

		private struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
		{
			public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;

			public IO_COUNTERS IoInfo;

			public nuint ProcessMemoryLimit;

			public nuint JobMemoryLimit;

			public nuint PeakProcessMemoryUsed;

			public nuint PeakJobMemoryUsed;
		}

		private sealed class SetupStatusRowRefs
		{
			public Text Name;

			public Text Detail;

			public Text Status;

			public Image Badge;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static Action<string> <0>__Msg;

			public static ThreadStart <1>__WindowPollerLoop;

			public static ResolveEventHandler <2>__ResolveDesktopBuddyManagedDependency;

			public static UnhandledExceptionFilterDelegate <3>__NativeCrashFilter;

			public static Func<global::System.Exception, bool> <4>__IsGitHubReleaseNotFound;

			public static Action <5>__CloseSetupPanel;

			public static Action <6>__PollSetupInstall;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnhandledExceptionEventHandler <>9__13_0;

			public static EventHandler<UnobservedTaskExceptionEventArgs> <>9__13_1;

			public static Action <>9__14_0;

			public static Action <>9__14_1;

			public static Action <>9__14_2;

			public static EventHandler <>9__15_0;

			public static Action <>9__249_0;

			public static DataReceivedEventHandler <>9__250_1;

			public static DataReceivedEventHandler <>9__250_2;

			public static Action <>9__261_0;

			public static Predicate<Image> <>9__281_10;

			public static Predicate<Image> <>9__281_14;

			public static ButtonEventHandler <>9__282_0;

			public static Func<User, bool> <>9__312_0;

			public static Action<string> <>9__355_0;

			public static Action<bool> <>9__355_1;

			public static Action<float> <>9__355_2;

			public static Action<string> <>9__355_3;

			public static Action<string> <>9__355_4;

			public static Action<float> <>9__355_5;

			public static Action<float> <>9__355_6;

			public static Action<float> <>9__355_7;

			public static Action<float> <>9__355_8;

			public static Action<float> <>9__355_9;

			public static Action<float> <>9__355_10;

			public static Action<string> <>9__355_11;

			public static Action<bool> <>9__355_12;

			public static Action<float> <>9__355_13;

			public static Action<float> <>9__355_14;

			public static Action<int> <>9__355_15;

			public static Action<bool> <>9__375_0;

			public static Action <>9__375_1;

			public static Action<bool> <>9__379_0;

			public static Action<bool> <>9__379_1;

			public static Action<bool> <>9__379_2;

			public static Action<bool> <>9__379_3;

			public static Action<bool> <>9__379_4;

			public static Action<bool> <>9__379_5;

			public static Action<bool> <>9__379_6;

			public static Action<bool> <>9__393_1;

			public static Action<string> <>9__393_2;

			public static Action<string> <>9__393_3;

			public static Func<ValueTuple<int, string>, ValueTuple<string, string>> <>9__405_0;

			public static Func<ValueTuple<int, string>, ValueTuple<string, string>> <>9__405_2;

			public static Func<WgcCapture.GpuAdapterInfo, bool> <>9__405_6;

			public static Func<WgcCapture.GpuAdapterInfo, string> <>9__405_7;

			public static Func<IGrouping<string, WgcCapture.GpuAdapterInfo>, WgcCapture.GpuAdapterInfo> <>9__405_8;

			public static Func<WgcCapture.GpuAdapterInfo, ValueTuple<string, string>> <>9__405_9;

			public static Func<User, bool> <>9__450_0;

			public static Func<User, string> <>9__450_1;

			public static Func<DesktopSession, int> <>9__451_1;

			public static Func<DesktopSession, bool> <>9__451_3;

			public static Func<IGrouping<int, DesktopSession>, DesktopSession> <>9__451_2;

			public static Func<User, bool> <>9__461_1;

			public static Func<User, string> <>9__461_2;

			public static Action<IDestroyable> <>9__477_0;

			public static Func<DesktopBuddyFirstRunSetup.SetupItem, bool> <>9__488_0;

			internal void <InitializeCore>b__13_0(object sender, UnhandledExceptionEventArgs e)
			{
				Log.Msg($"UNHANDLED EXCEPTION (terminating={e.IsTerminating}):\n{e.ExceptionObject}");
			}

			internal void <InitializeCore>b__13_1(object? sender, UnobservedTaskExceptionEventArgs e)
			{
				Log.Msg($"UNOBSERVED TASK EXCEPTION:\n{e.Exception}");
				e.SetObserved();
			}

			internal void <EnsureDependencyRuntimeStarted>b__14_0()
			{
				StartTunnel();
			}

			internal void <EnsureDependencyRuntimeStarted>b__14_1()
			{
				try
				{
					if (SoftCam.IsFilterRegistered())
					{
						VCam = new VirtualCamera();
						VCam.StartIdle();
					}
					else
					{
						Msg("[VirtualCamera] DirectShow filter not registered, virtual camera unavailable");
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("[VirtualCamera] Setup error: " + ex.Message);
				}
				try
				{
					if (!VBCable.HasCableInputDevice())
					{
						Msg("[VirtualMic] VB-Cable not installed, virtual mic unavailable");
					}
				}
				catch (global::System.Exception ex2)
				{
					Msg("[VirtualMic] Setup error: " + ex2.Message);
				}
			}

			internal void <EnsureDependencyRuntimeStarted>b__14_2()
			{
				try
				{
					VirtualCamera virtualCamera = new VirtualCamera();
					if (virtualCamera.StartIdle())
					{
						VCam = virtualCamera;
						Msg("[VirtualCamera] Linux v4l2 virtual camera ready");
					}
					else
					{
						virtualCamera.Dispose();
						Msg("[VirtualCamera] Linux virtual camera unavailable; run setup in the Devices tab");
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("[VirtualCamera] Linux setup error: " + ex.Message);
				}
			}

			internal void <RegisterShutdownCleanup>b__15_0(object? s, EventArgs e)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				HashSet<uint> val = new HashSet<uint>();
				Enumerator<DesktopSession> enumerator = ActiveSessions.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						if (!DesktopBuddyPlatform.IsLinux && current.OwnsAudioRedirect && current.ProcessId != 0 && val.Add(current.ProcessId))
						{
							AudioRouter.ResetProcessToDefault(current.ProcessId);
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				KillTunnel();
				RemovePortForwardNatMapping();
				try
				{
					StreamServer?.Dispose();
				}
				catch
				{
				}
			}

			internal void <RestartTunnel>b__249_0()
			{
				try
				{
					Msg("[Tunnel] === RESTART ===");
					KillTunnel();
					TunnelUrl = null;
					Thread.Sleep(2000);
					StartTunnel();
				}
				catch (global::System.Exception ex)
				{
					Msg($"[Tunnel] Restart task error: {ex}");
				}
				finally
				{
					_tunnelRestarting = false;
				}
			}

			internal void <StartTunnel>b__250_1(object s, DataReceivedEventArgs e)
			{
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				if (e.Data == null)
				{
					return;
				}
				if (e.Data.Contains("https://") && e.Data.Contains(".trycloudflare.com"))
				{
					int num = e.Data.IndexOf("https://");
					string text = e.Data.Substring(num).Trim();
					int num2 = text.IndexOf(' ');
					if (num2 > 0)
					{
						text = text.Substring(0, num2);
					}
					try
					{
						text = new Uri(text).GetLeftPart((UriPartial)1);
					}
					catch (global::System.Exception ex)
					{
						Msg("[Tunnel] URL parse error: " + ex.Message);
					}
					string tunnelUrl = TunnelUrl;
					TunnelUrl = text;
					if (tunnelUrl != text)
					{
						Msg("[Tunnel] PUBLIC URL: " + TunnelUrl);
						try
						{
							UpdateSessionTunnelUrls();
						}
						catch (global::System.Exception ex2)
						{
							Msg($"[Tunnel] PUBLIC URL refresh error: {ex2}");
						}
					}
				}
				else if (ShouldLogCloudflaredLine(e.Data))
				{
					Msg("[Tunnel] " + e.Data);
				}
				OnTunnelError(e.Data);
			}

			internal void <StartTunnel>b__250_2(object s, DataReceivedEventArgs e)
			{
				if (e.Data != null && ShouldLogCloudflaredLine(e.Data))
				{
					Msg("[Tunnel] " + e.Data);
				}
			}

			internal void <ApplyStreamNetworkMode>b__261_0()
			{
				StartTunnel();
			}

			internal bool <FinishStartStreaming>b__281_10(Image image)
			{
				return ((Component)image).Slot.Name == "Background";
			}

			internal bool <FinishStartStreaming>b__281_14(Image image)
			{
				return ((Component)image).Slot.Name == "Background";
			}

			internal void <CreateVirtualDeviceControls>b__282_0(IButton b, ButtonEventData d)
			{
				if (VCam == null)
				{
					Msg("[VirtualCamera] Not available");
					return;
				}
				VCam.ManuallyDisabled = !VCam.ManuallyDisabled;
				Msg("[VirtualCamera] " + (VCam.ManuallyDisabled ? "Disabled" : "Enabled"));
			}

			internal bool <CreateViewerCullingGate>b__312_0(User u)
			{
				return u.IsPresentInWorld;
			}

			internal void <BuildAudioTab>b__355_0(string value)
			{
				SaveConfigValue(StreamAudioGlobalMode, NormalizeStreamAudioGlobalMode(value));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_1(bool value)
			{
				SaveConfigValue(StreamAudioSpatialize, value);
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_2(float value)
			{
				SaveConfigValue(StreamAudioSpatialBlend, Math.Clamp(value, 0f, 1f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_3(string value)
			{
				SaveConfigValue(StreamAudioDistanceSpace, NormalizeStreamAudioDistanceSpace(value));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_4(string value)
			{
				SaveConfigValue(StreamAudioRolloffMode, NormalizeStreamAudioRolloffMode(value));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_5(float value)
			{
				SaveConfigValue(StreamAudioMinDistance, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_6(float value)
			{
				SaveConfigValue(StreamAudioMaxDistance, Math.Clamp(value, 1f, 50f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_7(float value)
			{
				SaveConfigValue(StreamAudioSpatializationStartDistance, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_8(float value)
			{
				SaveConfigValue(StreamAudioSpatializationTransitionRange, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_9(float value)
			{
				SaveConfigValue(StreamAudioMinScale, Math.Clamp(value, 0f, 1000f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_10(float value)
			{
				SaveConfigValue(StreamAudioMaxScale, Math.Clamp(value, 0f, 1000f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_11(string value)
			{
				SaveConfigValue(StreamAudioTypeGroup, NormalizeStreamAudioTypeGroup(value));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_12(bool value)
			{
				SaveConfigValue(StreamAudioIgnoreAudioEffects, value);
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_13(float value)
			{
				SaveConfigValue(StreamAudioPitch, Math.Clamp(value, 0.5f, 2f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_14(float value)
			{
				SaveConfigValue(StreamAudioDopplerLevel, Math.Clamp(value, 0f, 1f));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildAudioTab>b__355_15(int value)
			{
				SaveConfigValue(StreamAudioPriority, Math.Clamp(value, 0, 256));
				ApplyStreamAudioSettingsToAllSessions();
			}

			internal void <BuildDevicesTab>b__375_0(bool value)
			{
				if (VCam != null)
				{
					VCam.ManuallyDisabled = !value;
				}
			}

			internal void <BuildDevicesTab>b__375_1()
			{
				LinuxVirtualCameraSetup.Run();
			}

			internal void <BuildGeneralTab>b__379_0(bool value)
			{
				SaveConfigValue(ShowContextMenuItem, value);
			}

			internal void <BuildGeneralTab>b__379_1(bool value)
			{
				SaveConfigValue(ThrowToDestroy, value);
			}

			internal void <BuildGeneralTab>b__379_2(bool value)
			{
				SaveConfigValue(DynamicLightsEnabled, value);
			}

			internal void <BuildGeneralTab>b__379_3(bool value)
			{
				SaveConfigValue(SpawnNewWindowsInGame, value);
			}

			internal void <BuildGeneralTab>b__379_4(bool value)
			{
				SaveConfigValue(SpawnNewWindowsPrivate, value);
			}

			internal void <BuildGeneralTab>b__379_5(bool value)
			{
				SaveConfigValue(NewWindowsStartPrivate, value);
			}

			internal void <BuildGeneralTab>b__379_6(bool value)
			{
				SaveConfigValue(SpatialAudioEnabled, value);
			}

			internal void <BuildNetworkTab>b__393_1(bool value)
			{
				SaveConfigValue(PortForwardUseNat, value);
				ApplyStreamNetworkMode();
			}

			internal void <BuildNetworkTab>b__393_2(string value)
			{
				SaveConfigValue(PortForwardHostMode, NormalizePortForwardHostMode(value));
				ApplyStreamNetworkMode();
			}

			internal void <BuildNetworkTab>b__393_3(string value)
			{
				SaveConfigValue(PortForwardHost, value.Trim());
				ApplyStreamNetworkMode();
			}

			internal ValueTuple<string, string> <BuildStreamTab>b__405_0(ValueTuple<int, string> option)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				return new ValueTuple<string, string>(option.Item1.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), option.Item2);
			}

			internal ValueTuple<string, string> <BuildStreamTab>b__405_2(ValueTuple<int, string> option)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				return new ValueTuple<string, string>(option.Item1.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), option.Item2);
			}

			internal bool <BuildStreamTab>b__405_6(WgcCapture.GpuAdapterInfo g)
			{
				if (!g.IsBasicRenderDriver)
				{
					return !string.IsNullOrWhiteSpace(g.Name);
				}
				return false;
			}

			internal string <BuildStreamTab>b__405_7(WgcCapture.GpuAdapterInfo g)
			{
				return NormalizeGpuDisplayName(g.Name);
			}

			internal WgcCapture.GpuAdapterInfo <BuildStreamTab>b__405_8(IGrouping<string, WgcCapture.GpuAdapterInfo> group)
			{
				return Enumerable.First<WgcCapture.GpuAdapterInfo>((global::System.Collections.Generic.IEnumerable<WgcCapture.GpuAdapterInfo>)group);
			}

			internal ValueTuple<string, string> <BuildStreamTab>b__405_9(WgcCapture.GpuAdapterInfo gpu)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				return new ValueTuple<string, string>("0x" + gpu.Luid.ToString("X16", (IFormatProvider)(object)CultureInfo.InvariantCulture), NormalizeGpuDisplayName(gpu.Name));
			}

			internal bool <BuildViewersTab>b__450_0(User u)
			{
				return u.IsPresentInWorld;
			}

			internal string <BuildViewersTab>b__450_1(User u)
			{
				return u.UserName;
			}

			internal int <RequestStreamEncoderRestart>b__451_1(DesktopSession s)
			{
				return s.StreamId;
			}

			internal DesktopSession <RequestStreamEncoderRestart>b__451_2(IGrouping<int, DesktopSession> group)
			{
				global::System.Collections.Generic.IEnumerator<DesktopSession> enumerator = ((global::System.Collections.Generic.IEnumerable<DesktopSession>)group).GetEnumerator();
				try
				{
					while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
					{
						DesktopSession current = enumerator.Current;
						DesktopSession sharedStreamDriver = GetSharedStreamDriver(current.Hwnd, current.StreamId);
						if (sharedStreamDriver != null && Enumerable.Contains<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group, sharedStreamDriver))
						{
							return sharedStreamDriver;
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator)?.Dispose();
				}
				return Enumerable.FirstOrDefault<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group, (Func<DesktopSession, bool>)((DesktopSession s) => s.Streamer != null)) ?? Enumerable.First<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group);
			}

			internal bool <RequestStreamEncoderRestart>b__451_3(DesktopSession s)
			{
				return s.Streamer != null;
			}

			internal bool <ScheduleViewerListRefresh>b__461_1(User u)
			{
				return u.IsPresentInWorld;
			}

			internal string <ScheduleViewerListRefresh>b__461_2(User u)
			{
				return u.UserName;
			}

			internal void <ShowSetupPanel>b__477_0(IDestroyable _)
			{
				bool num = _setupCompleteAwaitingClose && !_setupNoticeDismissed;
				if (_setupPanelRoot != null && ((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
				{
					_setupPanelRoot = null;
				}
				_setupPanelCanvas = null;
				_setupBodyText = null;
				_setupInstallButtonSlot = null;
				_setupStatusRows.Clear();
				if (num)
				{
					Msg("[SetupPanel] Setup panel closed after completion; continuing DesktopBuddy initialization");
					_setupNoticeDismissed = true;
					_setupCompleteAwaitingClose = false;
					EnsureDependencyRuntimeStarted();
				}
			}

			internal bool <GetSetupPanelMessage>b__488_0(DesktopBuddyFirstRunSetup.SetupItem item)
			{
				if (!item.IsOk)
				{
					return !item.RequiresAdminAction;
				}
				return false;
			}

			internal bool <.cctor>b__499_0()
			{
				return false;
			}

			internal bool <.cctor>b__499_1()
			{
				return true;
			}

			internal bool <.cctor>b__499_2()
			{
				return true;
			}

			internal bool <.cctor>b__499_3()
			{
				return true;
			}

			internal bool <.cctor>b__499_4()
			{
				return true;
			}

			internal bool <.cctor>b__499_5()
			{
				return true;
			}

			internal bool <.cctor>b__499_6()
			{
				return false;
			}

			internal bool <.cctor>b__499_7()
			{
				return false;
			}

			internal int <.cctor>b__499_8()
			{
				return 10;
			}

			internal int <.cctor>b__499_9()
			{
				return 60;
			}

			internal int <.cctor>b__499_10()
			{
				return 2560;
			}

			internal bool <.cctor>b__499_11()
			{
				return false;
			}

			internal string <.cctor>b__499_12()
			{
				return "";
			}

			internal int <.cctor>b__499_13()
			{
				return 8554;
			}

			internal string <.cctor>b__499_14()
			{
				return "";
			}

			internal string <.cctor>b__499_15()
			{
				return "cloudflare";
			}

			internal string <.cctor>b__499_16()
			{
				return "auto";
			}

			internal string <.cctor>b__499_17()
			{
				return "external";
			}

			internal string <.cctor>b__499_18()
			{
				return "";
			}

			internal bool <.cctor>b__499_19()
			{
				return false;
			}

			internal string <.cctor>b__499_20()
			{
				return "";
			}

			internal string <.cctor>b__499_21()
			{
				return "";
			}

			internal string <.cctor>b__499_22()
			{
				return "frustum";
			}

			internal bool <.cctor>b__499_23()
			{
				return false;
			}

			internal float <.cctor>b__499_24()
			{
				return 120f;
			}

			internal float <.cctor>b__499_25()
			{
				return 3f;
			}

			internal float <.cctor>b__499_26()
			{
				return 3f;
			}

			internal string <.cctor>b__499_27()
			{
				return "auto";
			}

			internal string <.cctor>b__499_28()
			{
				return "";
			}

			internal float <.cctor>b__499_29()
			{
				return 0f;
			}

			internal string <.cctor>b__499_30()
			{
				return "positional";
			}

			internal bool <.cctor>b__499_31()
			{
				return true;
			}

			internal float <.cctor>b__499_32()
			{
				return 1f;
			}

			internal string <.cctor>b__499_33()
			{
				return "global";
			}

			internal float <.cctor>b__499_34()
			{
				return 0f;
			}

			internal float <.cctor>b__499_35()
			{
				return 1f;
			}

			internal bool <.cctor>b__499_36()
			{
				return true;
			}

			internal string <.cctor>b__499_37()
			{
				return "multimedia";
			}

			internal string <.cctor>b__499_38()
			{
				return "linear";
			}

			internal float <.cctor>b__499_39()
			{
				return 1f;
			}

			internal float <.cctor>b__499_40()
			{
				return 30f;
			}

			internal float <.cctor>b__499_41()
			{
				return 0.01f;
			}

			internal float <.cctor>b__499_42()
			{
				return 0.01f;
			}

			internal int <.cctor>b__499_43()
			{
				return 128;
			}

			internal float <.cctor>b__499_44()
			{
				return 0f;
			}

			internal float <.cctor>b__499_45()
			{
				return 1000f;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass281_1
		{
			[StructLayout((LayoutKind)3)]
			private struct <<FinishStartStreaming>b__34>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass281_1 <>4__this;

				private <>c__DisplayClass281_2 <>8__1;

				private ConfiguredTaskAwaiter<Uri> <>u__1;

				private void MoveNext()
				{
					//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_004c: Expected O, but got Unknown
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_008e: Unknown result type (might be due to invalid IL or missing references)
					//IL_012a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0134: Expected O, but got Unknown
					//IL_012f: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass281_1 <>c__DisplayClass281_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<Uri> val2;
							if (num != 0)
							{
								<>8__1 = new <>c__DisplayClass281_2();
								<>8__1.CS$<>8__locals1 = <>c__DisplayClass281_;
								Bitmap2D val = new Bitmap2D(<>c__DisplayClass281_.data, <>c__DisplayClass281_.texW, <>c__DisplayClass281_.texH, (TextureFormat)18, false, (ColorProfile)0, false, (string)null);
								val2 = <>c__DisplayClass281_.engine.LocalDB.SaveAssetAsync(val, "webp", 2147483647, true).ConfigureAwait(false).GetAwaiter();
								if (!val2.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val2;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<Uri>, <<FinishStartStreaming>b__34>d>(ref val2, ref this);
									return;
								}
							}
							else
							{
								val2 = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<Uri>);
								num = (<>1__state = -1);
							}
							Uri result = val2.GetResult();
							<>8__1.uri = result;
							if (!(<>8__1.uri == (Uri)null))
							{
								World world = ((Worker)<>c__DisplayClass281_.tex).World;
								if (world != null && !((ComponentBase<Component>)(object)<>c__DisplayClass281_.tex).IsDestroyed && !((ComponentBase<Component>)(object)<>c__DisplayClass281_.blur).IsDestroyed)
								{
									world.RunInUpdates(0, (Action)delegate
									{
										//IL_0070: Unknown result type (might be due to invalid IL or missing references)
										//IL_008a: Unknown result type (might be due to invalid IL or missing references)
										if (!((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.tex).IsDestroyed && !((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.blur).IsDestroyed)
										{
											((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)<>8__1.CS$<>8__locals1.tex).URL).Value = <>8__1.uri;
											((SyncRef<IAssetProvider<ITexture2D>>)(object)<>8__1.CS$<>8__locals1.blur.SpreadMagnitudeTexture).Target = (IAssetProvider<ITexture2D>)(object)<>8__1.CS$<>8__locals1.tex;
											((SyncField<float2>)(object)<>8__1.CS$<>8__locals1.blur.SpreadTextureScale).Value = float2.One;
											((SyncField<float2>)(object)<>8__1.CS$<>8__locals1.blur.SpreadTextureOffset).Value = float2.Zero;
										}
									});
									<>8__1 = null;
								}
							}
						}
						catch (global::System.Exception ex)
						{
							Msg("[TopBar] Blur mask generation failed: " + ex.Message);
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public byte[] data;

			public int texW;

			public int texH;

			public Engine engine;

			public StaticTexture2D tex;

			public BlurMaterial blur;

			[AsyncStateMachine(typeof(<<FinishStartStreaming>b__34>d))]
			internal global::System.Threading.Tasks.Task? <FinishStartStreaming>b__34()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<FinishStartStreaming>b__34>d <<FinishStartStreaming>b__34>d = default(<<FinishStartStreaming>b__34>d);
				<<FinishStartStreaming>b__34>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<FinishStartStreaming>b__34>d.<>4__this = this;
				<<FinishStartStreaming>b__34>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<FinishStartStreaming>b__34>d.<>t__builder)).Start<<<FinishStartStreaming>b__34>d>(ref <<FinishStartStreaming>b__34>d);
				return ((AsyncTaskMethodBuilder)(ref <<FinishStartStreaming>b__34>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass281_2
		{
			public Uri uri;

			public <>c__DisplayClass281_1 CS$<>8__locals1;

			internal void <FinishStartStreaming>b__35()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				if (!((ComponentBase<Component>)(object)CS$<>8__locals1.tex).IsDestroyed && !((ComponentBase<Component>)(object)CS$<>8__locals1.blur).IsDestroyed)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)CS$<>8__locals1.tex).URL).Value = uri;
					((SyncRef<IAssetProvider<ITexture2D>>)(object)CS$<>8__locals1.blur.SpreadMagnitudeTexture).Target = (IAssetProvider<ITexture2D>)(object)CS$<>8__locals1.tex;
					((SyncField<float2>)(object)CS$<>8__locals1.blur.SpreadTextureScale).Value = float2.One;
					((SyncField<float2>)(object)CS$<>8__locals1.blur.SpreadTextureOffset).Value = float2.Zero;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass384_0
		{
			[StructLayout((LayoutKind)3)]
			private struct <<UpdateSettingsBlurMask>b__0>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass384_0 <>4__this;

				private <>c__DisplayClass384_1 <>8__1;

				private ConfiguredTaskAwaiter<Uri> <>u__1;

				private void MoveNext()
				{
					//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
					//IL_0046: Unknown result type (might be due to invalid IL or missing references)
					//IL_004c: Expected O, but got Unknown
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0072: Unknown result type (might be due to invalid IL or missing references)
					//IL_0077: Unknown result type (might be due to invalid IL or missing references)
					//IL_008c: Unknown result type (might be due to invalid IL or missing references)
					//IL_008e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0104: Unknown result type (might be due to invalid IL or missing references)
					//IL_010e: Expected O, but got Unknown
					//IL_0109: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass384_0 <>c__DisplayClass384_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<Uri> val2;
							if (num != 0)
							{
								<>8__1 = new <>c__DisplayClass384_1();
								<>8__1.CS$<>8__locals1 = <>c__DisplayClass384_;
								Bitmap2D val = new Bitmap2D(<>c__DisplayClass384_.data, <>c__DisplayClass384_.texW, <>c__DisplayClass384_.texH, (TextureFormat)18, false, (ColorProfile)0, false, (string)null);
								val2 = <>c__DisplayClass384_.engine.LocalDB.SaveAssetAsync(val, "webp", 2147483647, true).ConfigureAwait(false).GetAwaiter();
								if (!val2.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val2;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<Uri>, <<UpdateSettingsBlurMask>b__0>d>(ref val2, ref this);
									return;
								}
							}
							else
							{
								val2 = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<Uri>);
								num = (<>1__state = -1);
							}
							Uri result = val2.GetResult();
							<>8__1.uri = result;
							if (!(<>8__1.uri == (Uri)null))
							{
								((Worker)<>c__DisplayClass384_.tex).World.RunInUpdates(0, (Action)delegate
								{
									//IL_0070: Unknown result type (might be due to invalid IL or missing references)
									//IL_008a: Unknown result type (might be due to invalid IL or missing references)
									if (!((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.tex).IsDestroyed && !((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.blur).IsDestroyed)
									{
										((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)<>8__1.CS$<>8__locals1.tex).URL).Value = <>8__1.uri;
										((SyncRef<IAssetProvider<ITexture2D>>)(object)<>8__1.CS$<>8__locals1.blur.SpreadMagnitudeTexture).Target = (IAssetProvider<ITexture2D>)(object)<>8__1.CS$<>8__locals1.tex;
										((SyncField<float2>)(object)<>8__1.CS$<>8__locals1.blur.SpreadTextureScale).Value = float2.One;
										((SyncField<float2>)(object)<>8__1.CS$<>8__locals1.blur.SpreadTextureOffset).Value = float2.Zero;
									}
								});
								<>8__1 = null;
							}
						}
						catch (global::System.Exception ex)
						{
							Msg("[Settings] Blur mask generation failed: " + ex.Message);
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public byte[] data;

			public int texW;

			public int texH;

			public Engine engine;

			public StaticTexture2D tex;

			public BlurMaterial blur;

			[AsyncStateMachine(typeof(<<UpdateSettingsBlurMask>b__0>d))]
			internal global::System.Threading.Tasks.Task? <UpdateSettingsBlurMask>b__0()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<UpdateSettingsBlurMask>b__0>d <<UpdateSettingsBlurMask>b__0>d = default(<<UpdateSettingsBlurMask>b__0>d);
				<<UpdateSettingsBlurMask>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<UpdateSettingsBlurMask>b__0>d.<>4__this = this;
				<<UpdateSettingsBlurMask>b__0>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<UpdateSettingsBlurMask>b__0>d.<>t__builder)).Start<<<UpdateSettingsBlurMask>b__0>d>(ref <<UpdateSettingsBlurMask>b__0>d);
				return ((AsyncTaskMethodBuilder)(ref <<UpdateSettingsBlurMask>b__0>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass384_1
		{
			public Uri uri;

			public <>c__DisplayClass384_0 CS$<>8__locals1;

			internal void <UpdateSettingsBlurMask>b__1()
			{
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				if (!((ComponentBase<Component>)(object)CS$<>8__locals1.tex).IsDestroyed && !((ComponentBase<Component>)(object)CS$<>8__locals1.blur).IsDestroyed)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)CS$<>8__locals1.tex).URL).Value = uri;
					((SyncRef<IAssetProvider<ITexture2D>>)(object)CS$<>8__locals1.blur.SpreadMagnitudeTexture).Target = (IAssetProvider<ITexture2D>)(object)CS$<>8__locals1.tex;
					((SyncField<float2>)(object)CS$<>8__locals1.blur.SpreadTextureScale).Value = float2.One;
					((SyncField<float2>)(object)CS$<>8__locals1.blur.SpreadTextureOffset).Value = float2.Zero;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass449_0
		{
			[StructLayout((LayoutKind)3)]
			private struct <<LoadViewerAvatarIcon>b__0>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass449_0 <>4__this;

				private <>c__DisplayClass449_1 <>8__1;

				private ConfiguredTaskAwaiter<CloudResult<User>> <>u__1;

				private void MoveNext()
				{
					//IL_0083: Unknown result type (might be due to invalid IL or missing references)
					//IL_0088: Unknown result type (might be due to invalid IL or missing references)
					//IL_008f: 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_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0050: Unknown result type (might be due to invalid IL or missing references)
					//IL_0055: Unknown result type (might be due to invalid IL or missing references)
					//IL_0069: Unknown result type (might be due to invalid IL or missing references)
					//IL_006a: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
					//IL_0103: Expected O, but got Unknown
					//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass449_0 <>c__DisplayClass449_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<CloudResult<User>> val;
							if (num != 0)
							{
								<>8__1 = new <>c__DisplayClass449_1();
								<>8__1.CS$<>8__locals1 = <>c__DisplayClass449_;
								val = ((SkyFrostInterface)<>c__DisplayClass449_.engine.Cloud).Users.GetUserCached(<>c__DisplayClass449_.userId).ConfigureAwait(false).GetAwaiter();
								if (!val.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<CloudResult<User>>, <<LoadViewerAvatarIcon>b__0>d>(ref val, ref this);
									return;
								}
							}
							else
							{
								val = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<CloudResult<User>>);
								num = (<>1__state = -1);
							}
							CloudResult<User> result = val.GetResult();
							if (result != null && ((CloudResult)result).IsOK)
							{
								User entity = result.Entity;
								object obj;
								if (entity == null)
								{
									obj = null;
								}
								else
								{
									UserProfile profile = entity.Profile;
									obj = ((profile != null) ? profile.IconUrl : null);
								}
								if (Uri.TryCreate((string)obj, (UriKind)1, ref <>8__1.iconUri))
								{
									<>c__DisplayClass449_.world.RunInUpdates(0, (Action)delegate
									{
										if (<>8__1.CS$<>8__locals1.avatarRoot != null && !((ContainerWorker<Component>)(object)<>8__1.CS$<>8__locals1.avatarRoot).IsDestroyed && <>8__1.CS$<>8__locals1.avatarTex != null && !((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.avatarTex).IsDestroyed)
										{
											((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)<>8__1.CS$<>8__locals1.avatarTex).URL).Value = <>8__1.iconUri;
										}
									});
									<>8__1 = null;
								}
							}
						}
						catch
						{
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public Engine engine;

			public string userId;

			public World world;

			public Slot avatarRoot;

			public StaticTexture2D avatarTex;

			[AsyncStateMachine(typeof(<<LoadViewerAvatarIcon>b__0>d))]
			internal global::System.Threading.Tasks.Task? <LoadViewerAvatarIcon>b__0()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<LoadViewerAvatarIcon>b__0>d <<LoadViewerAvatarIcon>b__0>d = default(<<LoadViewerAvatarIcon>b__0>d);
				<<LoadViewerAvatarIcon>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<LoadViewerAvatarIcon>b__0>d.<>4__this = this;
				<<LoadViewerAvatarIcon>b__0>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<LoadViewerAvatarIcon>b__0>d.<>t__builder)).Start<<<LoadViewerAvatarIcon>b__0>d>(ref <<LoadViewerAvatarIcon>b__0>d);
				return ((AsyncTaskMethodBuilder)(ref <<LoadViewerAvatarIcon>b__0>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass449_1
		{
			public Uri iconUri;

			public <>c__DisplayClass449_0 CS$<>8__locals1;

			internal void <LoadViewerAvatarIcon>b__1()
			{
				if (CS$<>8__locals1.avatarRoot != null && !((ContainerWorker<Component>)(object)CS$<>8__locals1.avatarRoot).IsDestroyed && CS$<>8__locals1.avatarTex != null && !((ComponentBase<Component>)(object)CS$<>8__locals1.avatarTex).IsDestroyed)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)CS$<>8__locals1.avatarTex).URL).Value = iconUri;
				}
			}
		}

		internal const string PluginGuid = "com.devl0rd.DesktopBuddy";

		internal const string PluginName = "DesktopBuddy";

		internal const string PluginAuthor = "DevL0rd";

		internal const string PluginUrl = "https://github.com/DevL0rd/DesktopBuddy";

		internal const string DesktopBuddyVersion = "1.1.0";

		private static int _initialized;

		private static int _dependencyRuntimeStarted;

		private static readonly HashSet<string> DesktopBuddyManagedDependencies;

		private static bool _managedDependencyResolverInstalled;

		private static UnhandledExceptionFilterDelegate _nativeCrashDelegate;

		private static nint _previousFilter;

		private const int STREAM_PORT = 48080;

		internal static readonly PerfTimer Perf;

		private const string ReleasesUrl = "https://github.com/DevL0rd/DesktopBuddy/releases";

		private const string LatestReleaseApiUrl = "https://api.github.com/repos/DevL0rd/DesktopBuddy/releases/latest";

		private const string ChangelogUrl = "https://raw.githubusercontent.com/DevL0rd/DesktopBuddy/main/CHANGELOG.md";

		internal static DesktopBuddyConfig Config;

		private static int _runtimeBitrateMbps;

		private static int _runtimeStreamFps;

		private static int _runtimeMaxStreamResolution;

		private static string _runtimeEncoderPreference;

		internal static readonly DesktopBuddyConfigKey<bool> SpatialAudioEnabled;

		internal static readonly DesktopBuddyConfigKey<bool> CheckForUpdates;

		internal static readonly DesktopBuddyConfigKey<bool> ShowContextMenuItem;

		internal static readonly DesktopBuddyConfigKey<bool> ThrowToDestroy;

		internal static readonly DesktopBuddyConfigKey<bool> SpawnNewWindowsInGame;

		internal static readonly DesktopBuddyConfigKey<bool> SpawnNewWindowsPrivate;

		internal static readonly DesktopBuddyConfigKey<bool> NewWindowsStartPrivate;

		internal static readonly DesktopBuddyConfigKey<bool> DynamicLightsEnabled;

		internal static readonly DesktopBuddyConfigKey<int> Bitrate;

		internal static readonly DesktopBuddyConfigKey<int> StreamFps;

		internal static readonly DesktopBuddyConfigKey<int> MaxStreamResolution;

		internal static readonly DesktopBuddyConfigKey<bool> UseMediaMtx;

		internal static readonly DesktopBuddyConfigKey<string> MediaMtxHost;

		internal static readonly DesktopBuddyConfigKey<int> MediaMtxPort;

		internal static readonly DesktopBuddyConfigKey<string> MediaMtxStreamName;

		internal static readonly DesktopBuddyConfigKey<string> StreamNetworkMode;

		internal static readonly DesktopBuddyConfigKey<string> PortForwardHostMode;

		internal static readonly DesktopBuddyConfigKey<string> PortForwardAutoIpMode;

		internal static readonly DesktopBuddyConfigKey<string> PortForwardHost;

		internal static readonly DesktopBuddyConfigKey<bool> PortForwardUseNat;

		internal static readonly DesktopBuddyConfigKey<string> PanelCurvePreferences;

		internal static readonly DesktopBuddyConfigKey<string> LinuxSharedSources;

		internal static readonly DesktopBuddyConfigKey<string> ViewerCullingMode;

		internal static readonly DesktopBuddyConfigKey<bool> ViewerCullingPreview;

		internal static readonly DesktopBuddyConfigKey<float> ViewerFrustumWidth;

		internal static readonly DesktopBuddyConfigKey<float> ViewerFrustumDepth;

		internal static readonly DesktopBuddyConfigKey<float> ViewerDistance;

		internal static readonly DesktopBuddyConfigKey<string> EncoderPreference;

		internal static readonly DesktopBuddyConfigKey<string> PreferredGpuLuid;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioOutputVolume;

		internal static readonly DesktopBuddyConfigKey<string> StreamAudioGlobalMode;

		internal static readonly DesktopBuddyConfigKey<bool> StreamAudioSpatialize;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioSpatialBlend;

		internal static readonly DesktopBuddyConfigKey<string> StreamAudioDistanceSpace;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioDopplerLevel;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioPitch;

		internal static readonly DesktopBuddyConfigKey<bool> StreamAudioIgnoreAudioEffects;

		internal static readonly DesktopBuddyConfigKey<string> StreamAudioTypeGroup;

		internal static readonly DesktopBuddyConfigKey<string> StreamAudioRolloffMode;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioMinDistance;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioMaxDistance;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioSpatializationStartDistance;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioSpatializationTransitionRange;

		internal static readonly DesktopBuddyConfigKey<int> StreamAudioPriority;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioMinScale;

		internal static readonly DesktopBuddyConfigKey<float> StreamAudioMaxScale;

		private static string _mediaMtxStreamBase;

		private const uint JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE = 8192u;

		private const int JobObjectExtendedLimitInformation = 9;

		private static SafeFileHandle _tunnelJob;

		private const string LaunchClientName = "steam-runtime-launch-client";

		private static string _launchClientPath;

		private static bool _launchClientResolved;

		private static readonly object ExternalIpGate;

		private static readonly object NatMappingGate;

		private static readonly HttpClient ExternalIpClient;

		private static string _cachedExternalIPv4;

		private static global::System.DateTime _cachedExternalIPv4At;

		private static bool _natMappingActive;

		private static readonly long AdaptiveLightSampleIntervalTicks;

		private const float AdaptiveLightSurfaceZOffset = -0.02f;

		private static readonly HashSet<World> _scheduledWorlds;

		private const int VirtualCameraTargetFps = 60;

		private static int _updateCount;

		private const double VBCableInputCheckIntervalSeconds = 5.0;

		private static long _lastVBCableInputCheckTicks;

		private static bool _lastVBCableInputPresent;

		private const int WindowPollIntervalMs = 250;

		private const float DesktopPanelCurvature = 0.18f;

		private const int DesktopPanelCurveSegments = 48;

		private const int SettingsUiRenderQueue = 3004;

		private const float TopBarSurfaceZOffset = -0.006f;

		private const float TopBarBackZOffset = 0.004f;

		private const float TopBarHoverCollapseDelaySeconds = 2f;

		private static int _nextTopBarRenderHostId;

		private const float SettingsPanelZOffset = -0.018f;

		private const int SettingsPanelRenderQueue = 3004;

		private const float SettingsStickScrollDeadzone = 0.16f;

		private const float SettingsStickScrollPixelsPerTick = 36f;

		private static readonly colorX SettingsBg;

		private static readonly colorX SettingsPanel;

		private static readonly colorX SettingsPanelSoft;

		private static readonly colorX SettingsAccent;

		private static readonly colorX SettingsAccentSoft;

		private static readonly colorX SettingsGradientPurple;

		private static readonly colorX SettingsGradientBlue;

		private static readonly colorX SettingsGradientMid;

		private static readonly UiGradientPalette SettingsGradientPalette;

		private static readonly UiScrollbarStyle SettingsScrollbarStyle;

		private static readonly colorX SettingsExperimentalOrange;

		private static readonly colorX SettingsStatusGood;

		private static readonly colorX SettingsStatusWarn;

		private static readonly colorX SettingsStatusBad;

		private static readonly colorX SettingsStatusNeutral;

		private static readonly colorX SettingsText;

		private static readonly colorX SettingsSubtext;

		private static readonly Uri DefaultViewerAvatar;

		private static readonly ValueTuple<SettingsPanelTab, string, string>[] SettingsTabs;

		private static readonly ValueTuple<int, string>[] StreamResolutionOptions;

		private static readonly ValueTuple<int, string>[] StreamFpsOptions;

		private const int SetupPanelWidth = 920;

		private const int SetupPanelHeight = 600;

		private const float SetupPanelScale = 0.00055f;

		private static Slot _setupPanelRoot;

		private static Canvas _setupPanelCanvas;

		private static Text _setupBodyText;

		private static Slot _setupInstallButtonSlot;

		private static readonly List<SetupStatusRowRefs> _setupStatusRows;

		private static bool _setupNoticeDismissed;

		private static bool _setupInstallInProgress;

		private static bool _setupCompleteAwaitingClose;

		private static global::System.DateTime _setupInstallStartedUtc;

		[field: CompilerGenerated]
		internal static ManualLogSource PluginLog
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		internal static List<DesktopSession> ActiveSessions => RuntimeStore.ActiveSessions;

		internal static HashSet<RefID> DesktopCanvasIds => RuntimeStore.DesktopCanvasIds;

		private static object TopBarRaycastGate => RuntimeStore.TopBarRaycastGate;

		private static Dictionary<RefID, Slot> TopBarRaycastTargets => RuntimeStore.TopBarRaycastTargets;

		private static Dictionary<nint, SharedStream> _sharedStreams => SharedStreamRegistry.Streams;

		internal static BuiltInStreamServer StreamServer
		{
			get
			{
				return RuntimeStore.StreamServer;
			}
			set
			{
				RuntimeStore.StreamServer = value;
			}
		}

		internal static VirtualCamera VCam
		{
			get
			{
				return RuntimeStore.VCam;
			}
			set
			{
				RuntimeStore.VCam = value;
			}
		}

		internal static VirtualMic VMic
		{
			get
			{
				return RuntimeStore.VMic;
			}
			set
			{
				RuntimeStore.VMic = value;
			}
		}

		internal static string TunnelUrl
		{
			get
			{
				return RuntimeStore.TunnelUrl;
			}
			set
			{
				RuntimeStore.TunnelUrl = value;
			}
		}

		private static Process _tunnelProcess
		{
			get
			{
				return RuntimeStore.TunnelProcess;
			}
			set
			{
				RuntimeStore.TunnelProcess = value;
			}
		}

		private static string _cfPath
		{
			get
			{
				return RuntimeStore.CloudflaredPath;
			}
			set
			{
				RuntimeStore.CloudflaredPath = value;
			}
		}

		private static bool _tunnelRestarting
		{
			get
			{
				return RuntimeStore.TunnelRestarting;
			}
			set
			{
				RuntimeStore.TunnelRestarting = value;
			}
		}

		internal static SharedTextureBridgeChannel TextureBridgeChannel
		{
			get
			{
				return RuntimeStore.TextureBridgeChannel;
			}
			set
			{
				RuntimeStore.TextureBridgeChannel = value;
			}
		}

		private static bool _textureBridgeOpened
		{
			get
			{
				return RuntimeStore.TextureBridgeOpened;
			}
			set
			{
				RuntimeStore.TextureBridgeOpened = value;
			}
		}

		internal static HashSet<DesktopTextureProvider> OurProviders => RuntimeStore.OurProviders;

		private static Thread _windowPollerThread
		{
			get
			{
				return RuntimeStore.WindowPollerThread;
			}
			set
			{
				RuntimeStore.WindowPollerThread = value;
			}
		}

		private static bool _windowPollerRunning
		{
			get
			{
				return RuntimeStore.WindowPollerRunning;
			}
			set
			{
				RuntimeStore.WindowPollerRunning = value;
			}
		}

		internal static ConcurrentQueue<WindowEvent> _windowEvents => RuntimeStore.WindowEvents;

		private static HashSet<nint> AutoSpawnSeenWindows => RuntimeStore.AutoSpawnSeenWindows;

		private static bool AutoSpawnWindowBaselineInitialized
		{
			get
			{
				return RuntimeStore.AutoSpawnWindowBaselineInitialized;
			}
			set
			{
				RuntimeStore.AutoSpawnWindowBaselineInitialized = value;
			}
		}

		private static string _latestVersion
		{
			get
			{
				return RuntimeStore.LatestVersion;
			}
			set
			{
				RuntimeStore.LatestVersion = value;
			}
		}

		private static string _remoteVersion
		{
			get
			{
				return RuntimeStore.RemoteVersion;
			}
			set
			{
				RuntimeStore.RemoteVersion = value;
			}
		}

		private static string _remoteSha
		{
			get
			{
				return RuntimeStore.RemoteSha;
			}
			set
			{
				RuntimeStore.RemoteSha = value;
			}
		}

		private static string _remoteChangelog
		{
			get
			{
				return RuntimeStore.RemoteChangelog;
			}
			set
			{
				RuntimeStore.RemoteChangelog = value;
			}
		}

		private static string _updateCheckError
		{
			get
			{
				return RuntimeStore.UpdateCheckError;
			}
			set
			{
				RuntimeStore.UpdateCheckError = value;
			}
		}

		private static global::System.DateTime _lastUpdateCheckUtc
		{
			get
			{
				return RuntimeStore.LastUpdateCheckUtc;
			}
			set
			{
				RuntimeStore.LastUpdateCheckUtc = value;
			}
		}

		private static bool _updateCheckInProgress
		{
			get
			{
				return RuntimeStore.UpdateCheckInProgress;
			}
			set
			{
				RuntimeStore.UpdateCheckInProgress = value;
			}
		}

		private static bool _updateShown
		{
			get
			{
				return RuntimeStore.UpdateShown;
			}
			set
			{
				RuntimeStore.UpdateShown = value;
			}
		}

		private static bool _settingsConfigDirty
		{
			get
			{
				return RuntimeStore.SettingsConfigDirty;
			}
			set
			{
				RuntimeStore.SettingsConfigDirty = value;
			}
		}

		internal static bool IsMediaMtxEnabled
		{
			get
			{
				DesktopBuddyConfig config = Config;
				if (config != null && config.GetValue(UseMediaMtx))
				{
					return !string.IsNullOrWhiteSpace(Config?.GetValue(MediaMtxHost));
				}
				return false;
			}
		}

		internal static int RuntimeBitrateMbps => Math.Clamp(Volatile.Read(ref _runtimeBitrateMbps), 1, 200);

		internal static int RuntimeStreamFps => Math.Clamp(Volatile.Read(ref _runtimeStreamFps), 1, 240);

		internal static int RuntimeMaxStreamResolution => Math.Clamp(Volatile.Read(ref _runtimeMaxStreamResolution), 128, 8192);

		internal static string RuntimeEncoderPreference => NormalizeEncoderPreference(_runtimeEncoderPreference);

		internal static bool UseCloudflareTunnel
		{
			get
			{
				if (Config != null)
				{
					return NormalizeStreamNetworkMode(Config.GetValue(StreamNetworkMode)) == "cloudflare";
				}
				return true;
			}
		}

		private static string CloudflaredFileName => "cloudflared.exe";

		public override void Load()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			PluginLog = ((BasePlugin)this).Log;
			Log.SetLogger(PluginLog);
			InstallManagedDependencyResolver();
			ResoniteHooks.OnEngineReady += new Action(OnEngineReady);
			Msg("Plugin com.devl0rd.DesktopBuddy loaded; waiting for Resonite engine");
		}

		private void OnEngineReady()
		{
			Log.StartSession();
			Msg("[Startup] Runtime platform: " + DesktopBuddyPlatform.RuntimeLabel);
			DesktopBuddyFirstRunSetup.SetupState setupState;
			if (DesktopBuddyPlatform.IsLinux)
			{
				setupState = DesktopBuddyFirstRunSetup.SetupState.Ok;
				Msg("[Setup] Linux detected; skipping Windows-only first-run setup");
			}
			else
			{
				setupState = DesktopBuddyFirstRunSetup.Check();
				if (setupState.HasIssues)
				{
					Msg("[Setup] Local setup has missing or outdated items; dependency runtime deferred until setup notice is dismissed");
				}
			}
			InitializeCore();
			if (!setupState.HasIssues)
			{
				EnsureDependencyRuntimeStarted();
			}
		}

		private void InitializeCore()
		{
			//IL_0042: 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_004d: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			if (Interlocked.Exchange(ref _initialized, 1) == 1)
			{
				return;
			}
			Config = new DesktopBuddyConfig(((BasePlugin)this).Config);
			BindConfigKeys();
			SaveCurrentConfigDefaults();
			AppDomain currentDomain = AppDomain.CurrentDomain;
			object obj = <>c.<>9__13_0;
			if (obj == null)
			{
				UnhandledExceptionEventHandler val = delegate(object sender, UnhandledExceptionEventArgs e)
				{
					Log.Msg($"UNHANDLED EXCEPTION (terminating={e.IsTerminating}):\n{e.ExceptionObject}");
				};
				<>c.<>9__13_0 = val;
				obj = (object)val;
			}
			currentDomain.UnhandledException += (UnhandledExceptionEventHandler)obj;
			TaskScheduler.UnobservedTaskException += delegate(object? sender, UnobservedTaskExceptionEventArgs e)
			{
				Log.Msg($"UNOBSERVED TASK EXCEPTION:\n{e.Exception}");
				e.SetObserved();
			};
			if (!DesktopBuddyPlatform.IsLinux)
			{
				InstallNativeCrashHandler();
			}
			else
			{
				Msg("[NativeCrash] Linux runtime detected; skipping Windows native crash handler");
			}
			Harmony val2 = new Harmony("com.desktopbuddy.mod");
			val2.PatchAll();
			TopBarRaycastPortalPatch.Install(val2);
			AudioCapture.LogHandler = Msg;
			RegisterShutdownCleanup();
			Msg("DesktopBuddy core initialized!");
		}

		internal static void EnsureDependencyRuntimeStarted()
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Expected O, but got Unknown
			if (Interlocked.Exchange(ref _dependencyRuntimeStarted, 1) == 1)
			{
				return;
			}
			Msg("[Startup] Starting DesktopBuddy dependency runtime");
			PrewarmSharedResources();
			if (IsMediaMtxEnabled)
			{
				Msg("[MediaMTX] Explicit RTSP mode enabled; built-in Cloudflare HTTP stream will not start");
			}
			else
			{
				try
				{
					StreamServer = new BuiltInStreamServer();
					StreamServer.Start();
					Msg($"Stream server started on port {48080}");
					if (UseCloudflareTunnel)
					{
						object obj = <>c.<>9__14_0;
						if (obj == null)
						{
							Action val = delegate
							{
								StartTunnel();
							};
							<>c.<>9__14_0 = val;
							obj = (object)val;
						}
						global::System.Threading.Tasks.Task.Run((Action)obj);
					}
					else
					{
						Msg("[PortForward] Built-in stream available at " + (GetBuiltInStreamBaseUrl() ?? "(no host configured)"));
						ApplyPortForwardNatMapping();
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("Stream server failed to start: " + ex.Message);
					StreamServer = null;
				}
			}
			if (!DesktopBuddyPlatform.IsLinux)
			{
				object obj2 = <>c.<>9__14_1;
				if (obj2 == null)
				{
					Action val2 = delegate
					{
						try
						{
							if (SoftCam.IsFilterRegistered())
							{
								VCam = new VirtualCamera();
								VCam.StartIdle();
							}
							else
							{
								Msg("[VirtualCamera] DirectShow filter not registered, virtual camera unavailable");
							}
						}
						catch (global::System.Exception ex2)
						{
							Msg("[VirtualCamera] Setup error: " + ex2.Message);
						}
						try
						{
							if (!VBCable.HasCableInputDevice())
							{
								Msg("[VirtualMic] VB-Cable not installed, virtual mic unavailable");
							}
						}
						catch (global::System.Exception ex3)
						{
							Msg("[VirtualMic] Setup error: " + ex3.Message);
						}
					};
					<>c.<>9__14_1 = val2;
					obj2 = (object)val2;
				}
				global::System.Threading.Tasks.Task.Run((Action)obj2);
			}
			else
			{
				Msg("[Startup] Linux detected; skipping Windows VB-Cable and audio-routing setup");
				object obj3 = <>c.<>9__14_2;
				if (obj3 == null)
				{
					Action val3 = delegate
					{
						try
						{
							VirtualCamera virtualCamera = new VirtualCamera();
							if (virtualCamera.StartIdle())
							{
								VCam = virtualCamera;
								Msg("[VirtualCamera] Linux v4l2 virtual camera ready");
							}
							else
							{
								virtualCamera.Dispose();
								Msg("[VirtualCamera] Linux virtual camera unavailable; run setup in the Devices tab");
							}
						}
						catch (global::System.Exception ex2)
						{
							Msg("[VirtualCamera] Linux setup error: " + ex2.Message);
						}
					};
					<>c.<>9__14_2 = val3;
					obj3 = (object)val3;
				}
				global::System.Threading.Tasks.Task.Run((Action)obj3);
			}
			if (!DesktopBuddyPlatform.IsLinux)
			{
				_windowPollerRunning = true;
				object obj4 = <>O.<1>__WindowPollerLoop;
				if (obj4 == null)
				{
					ThreadStart val4 = WindowPollerLoop;
					<>O.<1>__WindowPollerLoop = val4;
					obj4 = (object)val4;
				}
				_windowPollerThread = new Thread((ThreadStart)obj4)
				{
					Name = "DesktopBuddy:WindowPoller",
					IsBackground = true
				};
				_windowPollerThread.Start();
			}
			else
			{
				Msg("[Startup] Linux detected; skipping Win32 window poller");
			}
			Msg("DesktopBuddy dependency runtime initialized!");
			OpenSharedTextureBridge();
		}

		private static void RegisterShutdownCleanup()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			AppDomain currentDomain = AppDomain.CurrentDomain;
			object obj = <>c.<>9__15_0;
			if (obj == null)
			{
				EventHandler val = delegate
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					HashSet<uint> val2 = new HashSet<uint>();
					Enumerator<DesktopSession> enumerator = ActiveSessions.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							DesktopSession current = enumerator.Current;
							if (!DesktopBuddyPlatform.IsLinux && current.OwnsAudioRedirect && current.ProcessId != 0 && val2.Add(current.ProcessId))
							{
								AudioRouter.ResetProcessToDefault(current.ProcessId);
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
					KillTunnel();
					RemovePortForwardNatMapping();
					try
					{
						StreamServer?.Dispose();
					}
					catch
					{
					}
				};
				<>c.<>9__15_0 = val;
				obj = (object)val;
			}
			currentDomain.ProcessExit += (EventHandler)obj;
		}

		private static void InstallManagedDependencyResolver()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			if (!_managedDependencyResolverInstalled)
			{
				AppDomain currentDomain = AppDomain.CurrentDomain;
				object obj = <>O.<2>__ResolveDesktopBuddyManagedDependency;
				if (obj == null)
				{
					ResolveEventHandler val = ResolveDesktopBuddyManagedDependency;
					<>O.<2>__ResolveDesktopBuddyManagedDependency = val;
					obj = (object)val;
				}
				currentDomain.AssemblyResolve += (ResolveEventHandler)obj;
				_managedDependencyResolverInstalled = true;
			}
		}

		private static Assembly ResolveDesktopBuddyManagedDependency(object sender, ResolveEventArgs args)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			string name = new AssemblyName(args.Name).Name;
			if (!DesktopBuddyManagedDependencies.Contains(name))
			{
				return null;
			}
			string desktopBuddyManagedDependencyPath = GetDesktopBuddyManagedDependencyPath(name);
			try
			{
				if (File.Exists(desktopBuddyManagedDependencyPath))
				{
					return Assembly.LoadFrom(desktopBuddyManagedDependencyPath);
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[Dependencies] Failed to load {name} from {desktopBuddyManagedDependencyPath}: {ex.Message}");
			}
			Log.Msg("[Dependencies] Missing " + name + " at " + desktopBuddyManagedDependencyPath);
			return null;
		}

		private static string GetDesktopBuddyManagedDependencyPath(string assemblyName)
		{
			return DesktopBuddyRuntimePaths.FindFile(assemblyName + ".dll");
		}

		[DllImport("kernel32.dll")]
		private static extern nint SetUnhandledExceptionFilter(nint lpTopLevelExceptionFilter);

		private static void InstallNativeCrashHandler()
		{
			try
			{
				_nativeCrashDelegate = NativeCrashFilter;
				_previousFilter = SetUnhandledExceptionFilter(Marshal.GetFunctionPointerForDelegate<UnhandledExceptionFilterDelegate>(_nativeCrashDelegate));
				Log.Msg("[NativeCrash] Handler installed");
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[NativeCrash] Failed to install handler: " + ex.Message);
			}
		}

		private static int NativeCrashFilter(nint exceptionPointersPtr)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			try
			{
				global::System.IntPtr intPtr = Marshal.ReadIntPtr((global::System.IntPtr)exceptionPointersPtr, 0);
				uint num = (uint)Marshal.ReadInt32(intPtr, 0);
				nint num2 = Marshal.ReadIntPtr(intPtr, (global::System.IntPtr.Size == 8) ? 24 : 12);
				string text = $"[NativeCrash] FATAL: code=0x{num:X8} addr=0x{num2:X}\n";
				try
				{
					foreach (ProcessModule item in (ReadOnlyCollectionBase)Process.GetCurrentProcess().Modules)
					{
						ProcessModule val = item;
						long num3 = ((global::System.IntPtr)(nint)val.BaseAddress).ToInt64();
						long num4 = num3 + val.ModuleMemorySize;
						if (((global::System.IntPtr)num2).ToInt64() >= num3 && ((global::System.IntPtr)num2).ToInt64() < num4)
						{
							long num5 = ((global::System.IntPtr)num2).ToInt64() - num3;
							text += $"[NativeCrash] Faulting module: {val.ModuleName}+0x{num5:X} ({val.FileName})\n";
							break;
						}
					}
				}
				catch
				{
				}
				try
				{
					text = text + "[NativeCrash] Managed stack:\n" + Environment.StackTrace + "\n";
				}
				catch
				{
				}
				Log.Msg(text);
			}
			catch
			{
				try
				{
					Log.Msg("[NativeCrash] FATAL: crash handler failed to log details");
				}
				catch
				{
				}
			}
			return 0;
		}

		internal static void Msg(string msg)
		{
			Log.Msg(msg);
		}

		internal static void Error(string msg)
		{
			Log.Error(msg);
		}

		internal static void RegisterTopBarRaycastPortal(Slot portalSlot, Slot targetRoot)
		{
			//IL_000f: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (portalSlot != null && targetRoot != null)
			{
				RefID portalId = ((Worker)portalSlot).ReferenceID;
				lock (TopBarRaycastGate)
				{
					TopBarRaycastTargets[portalId] = targetRoot;
				}
				portalSlot.Destroyed += delegate
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					UnregisterTopBarRaycastPortal(portalId);
				};
				targetRoot.Destroyed += delegate
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					UnregisterTopBarRaycastPortal(portalId);
				};
				Msg($"[TopBarRaycast] Registered portal={portalId} target={((Worker)targetRoot).ReferenceID}");
			}
		}

		internal static Slot GetTopBarRaycastTarget(Slot portalSlot)
		{
			//IL_0006: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (portalSlot == null)
			{
				return null;
			}
			RefID referenceID = ((Worker)portalSlot).ReferenceID;
			lock (TopBarRaycastGate)
			{
				Slot val = default(Slot);
				if (!TopBarRaycastTargets.TryGetValue(referenceID, ref val) || val == null || ((ContainerWorker<Component>)(object)val).IsDestroyed)
				{
					TopBarRaycastTargets.Remove(referenceID);
					return null;
				}
				return val;
			}
		}

		private static void UnregisterTopBarRaycastPortal(RefID portalId)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			lock (TopBarRaycastGate)
			{
				TopBarRaycastTargets.Remove(portalId);
			}
		}

		internal static bool IsDesktopMode(World world)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			try
			{
				int result;
				if (world == null)
				{
					result = 0;
				}
				else
				{
					User localUser = world.LocalUser;
					result = (((int)((localUser != null) ? new HeadOutputDevice?(localUser.HeadDevice) : ((HeadOutputDevice?)null)).GetValueOrDefault() == 2) ? 1 : 0);
				}
				return (byte)result != 0;
			}
			catch
			{
				return false;
			}
		}

		private static int NextStreamId()
		{
			return SharedStreamRegistry.NextStreamId();
		}

		private static void PrewarmSharedResources()
		{
			if (!DesktopBuddyPlatform.IsLinux)
			{
				try
				{
					WgcCapture.PrewarmSharedDevice();
				}
				catch (global::System.Exception ex)
				{
					Msg("[Startup] WGC adapter prewarm failed: " + ex.Message);
				}
				try
				{
					WgcCapture.PrewarmCaptureFactory();
				}
				catch (global::System.Exception ex2)
				{
					Msg("[Startup] WGC capture factory prewarm failed: " + ex2.Message);
				}
			}
			else
			{
				Msg("[Startup] Linux runtime detected; skipping WGC prewarm");
			}
			if (!DesktopBuddyPlatform.IsLinux)
			{
				try
				{
					FfmpegEncoder.SetFfmpegPath();
				}
				catch (global::System.Exception ex3)
				{
					Msg("[Startup] FFmpeg prewarm failed: " + ex3.Message);
				}
			}
			if (!DesktopBuddyPlatform.IsLinux)
			{
				try
				{
					WindowInput.PrewarmTouchInjection();
				}
				catch (global::System.Exception ex4)
				{
					Msg("[Startup] Touch injection prewarm failed: " + ex4.Message);
				}
			}
			try
			{
				DesktopTextureProviderPatch.PrewarmReflection();
			}
			catch (global::System.Exception ex5)
			{
				Msg("[Startup] DesktopTexture reflection prewarm failed: " + ex5.Message);
			}
			if (!DesktopBuddyPlatform.IsLinux)
			{
				try
				{
					AudioRouter.PrewarmFactory();
				}
				catch (global::System.Exception ex6)
				{
					Msg("[Startup] Audio router prewarm failed: " + ex6.Message);
				}
			}
		}

		private static void OpenSharedTextureBridge()
		{
			if (_textureBridgeOpened)
			{
				return;
			}
			try
			{
				TextureBridgeChannel = new SharedTextureBridgeChannel();
				TextureBridgeChannel.Open();
				_textureBridgeOpened = true;
				Msg("[SharedTextureBridge] Opened successfully");
			}
			catch (global::System.Exception ex)
			{
				Msg($"[SharedTextureBridge] Error: {ex}");
			}
		}

		private static void CheckForUpdate()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_updateCheckError = null;
				string text = "e5251e3";
				string text2 = "1.1.0";
				Msg($"[Update] Current version: {text2} ({text})");
				HttpClient val = new HttpClient();
				try
				{
					val.Timeout = TimeSpan.FromSeconds(8L);
					((HttpHeaders)val.DefaultRequestHeaders).Add("User-Agent", "DesktopBuddy");
					JsonDocument val2 = JsonDocument.Parse(val.GetStringAsync("https://api.github.com/repos/DevL0rd/DesktopBuddy/releases/latest").Result, default(JsonDocumentOptions));
					try
					{
						JsonElement rootElement = val2.RootElement;
						JsonElement val3 = default(JsonElement);
						if (((JsonElement)(ref rootElement)).TryGetProperty("tag_name", ref val3))
						{
							string text3 = (((JsonElement)(ref val3)).GetString() ?? "").Trim();
							if (text3.StartsWith("v", (StringComparison)5))
							{
								text3 = text3.Substring(1);
							}
							_remoteVersion = text3;
							JsonElement val4 = default(JsonElement);
							_remoteSha = (((JsonElement)(ref rootElement)).TryGetProperty("target_commitish", ref val4) ? (((JsonElement)(ref val4)).GetString() ?? ("v" + text3)) : ("v" + text3));
							_remoteChangelog = FetchChangelog(val);
							_lastUpdateCheckUtc = global::System.DateTime.UtcNow;
							Msg("[Update] Latest GitHub release version: " + text3);
							_latestVersion = (IsRemoteVersionNewer(text3, text2) ? text3 : null);
						}
					}
					finally
					{
						((global::System.IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((global::System.IDisposable)val)?.Dispose();
				}
			}
			catch (global::System.Exception ex) when (IsGitHubReleaseNotFound(ex))
			{
				_updateCheckError = "No GitHub release is published yet.";
				_lastUpdateCheckUtc = global::System.DateTime.UtcNow;
				Msg("[Update] No GitHub release is published yet");
			}
			catch (global::System.Exception ex2)
			{
				_updateCheckError = ex2.Message;
				_lastUpdateCheckUtc = global::System.DateTime.UtcNow;
				Msg("[Update] Check failed: " + ex2.Message);
			}
		}

		private static bool IsGitHubReleaseNotFound(global::System.Exception ex)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			HttpRequestException ex2 = (HttpRequestException)(object)((ex is HttpRequestException) ? ex : null);
			if (ex2 != null && (int)ex2.StatusCode.GetValueOrDefault() == 404)
			{
				return true;
			}
			AggregateException ex3 = (AggregateException)(object)((ex is AggregateException) ? ex : null);
			if (ex3 != null)
			{
				return Enumerable.Any<global::System.Exception>((global::System.Collections.Generic.IEnumerable<global::System.Exception>)ex3.Flatten().InnerExceptions, (Func<global::System.Exception, bool>)IsGitHubReleaseNotFound);
			}
			if (ex.InnerException != null)
			{
				return IsGitHubReleaseNotFound(ex.InnerException);
			}
			return false;
		}

		private static string FetchChangelog(HttpClient http)
		{
			try
			{
				string result = http.GetStringAsync("https://raw.githubusercontent.com/DevL0rd/DesktopBuddy/main/CHANGELOG.md").Result;
				if (!string.IsNullOrWhiteSpace(result))
				{
					return TrimChangelog(result);
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Update] Changelog fetch failed: " + ex.Message);
			}
			return "";
		}

		private static bool IsRemoteVersionNewer(string remoteVersion, string currentVersion)
		{
			if (TryParseSemanticVersion(remoteVersion, out var parsed) && TryParseSemanticVersion(currentVersion, out var parsed2))
			{
				return parsed.CompareTo(parsed2) > 0;
			}
			return !string.Equals(remoteVersion, currentVersion, (StringComparison)5);
		}

		private static bool TryParseSemanticVersion(string version, out Version parsed)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			parsed = null;
			if (string.IsNullOrWhiteSpace(version))
			{
				return false;
			}
			Match val = Regex.Match(version.Trim(), "^v?(\\d+)\\.(\\d+)\\.(\\d+)$", (RegexOptions)1);
			if (!((Group)val).Success)
			{
				return false;
			}
			parsed = new Version(int.Parse(((Capture)val.Groups[1]).Value), int.Parse(((Capture)val.Groups[2]).Value), int.Parse(((Capture)val.Groups[3]).Value));
			return true;
		}

		private static string TrimChangelog(string text)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				return "";
			}
			string[] array = Enumerable.ToArray<string>(Enumerable.Take<string>((global::System.Collections.Generic.IEnumerable<string>)text.Replace("\r\n", "\n").Replace('\r', '\n').Split('\n', (StringSplitOptions)0), 80));
			string text2 = string.Join("\n", array).Trim();
			if (text2.Length > 5000)
			{
				return text2.Substring(0, 5000).TrimEnd() + "\n...";
			}
			return text2;
		}

		private static void QueueUpdateInfoCheck(SettingsPanelState state)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (_updateCheckInProgress || (_lastUpdateCheckUtc != default(global::System.DateTime) && global::System.DateTime.UtcNow - _lastUpdateCheckUtc < TimeSpan.FromMinutes(5L)))
			{
				return;
			}
			_updateCheckInProgress = true;
			Action val2 = default(Action);
			ThreadPool.QueueUserWorkItem((WaitCallback)delegate
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_004f: Expected O, but got Unknown
				try
				{
					CheckForUpdate();
				}
				finally
				{
					_updateCheckInProgress = false;
					SettingsPanelState settingsPanelState = state;
					object obj;
					if (settingsPanelState == null)
					{
						obj = null;
					}
					else
					{
						Slot ownerRoot = settingsPanelState.OwnerRoot;
						obj = ((ownerRoot != null) ? ((Worker)ownerRoot).World : null);
					}
					World val = (World)obj;
					if (val != null)
					{
						Action obj2 = val2;
						if (obj2 == null)
						{
							Action val3 = delegate
							{
								if (state.SurfaceSlot != null && !((ContainerWorker<Component>)(object)state.SurfaceSlot).IsDestroyed && state.SurfaceSlot.ActiveSelf && state.ActiveTab == SettingsPanelTab.UpdateInfo)
								{
									RebuildSettingsPanel(state, state.Session);
								}
							};
							Action val4 = val3;
							val2 = val3;
							obj2 = val4;
						}
						val.RunInUpdates(1, obj2);
					}
				}
			});
		}

		private static void ShowUpdatePopup(Slot root, float w, float canvasScale)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Expected O, but got Unknown
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Expected O, but got Unknown
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			Msg("[Update] Showing update popup: " + _latestVersion);
			Slot updateSlot = root.AddSlot("UpdateNotice", true);
			updateSlot.LocalPosition = new float3(0f, 0f, -0.002f);
			Slot obj = updateSlot;
			float3 one = float3.One;
			obj.LocalScale = (ref one) * canvasScale;
			Canvas obj2 = ((ContainerWorker<Component>)(object)updateSlot).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			float num = Math.Min(w * 0.6f, 400f);
			((SyncField<float2>)(object)obj2.Size).Value = new float2(num, 160f);
			UIBuilder val = new UIBuilder(obj2);
			colorX val2 = new colorX(0.12f, 0.12f, 0.15f, 0.95f, (ColorProfile)1);
			Image val3 = val.Image(ref val2, false);
			val.NestInto(((UIComponent)val3).RectTransform);
			val.VerticalLayout(8f, 0f, (Alignment?)(Alignment)4, (bool?)null, (bool?)null);
			val.Style.FlexibleWidth = 1f;
			val.Style.MinHeight = 32f;
			LocaleString val4 = LocaleString.op_Implicit("Update available!");
			Text obj3 = val.Text(ref val4, false, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)obj3.Size).Value = 22f;
			((SyncField<colorX>)(object)obj3.Color).Value = new colorX(0.95f, 0.85f, 0.3f, 1f, (ColorProfile)1);
			val.Style.MinHeight = 36f;
			val4 = LocaleString.op_Implicit("Download");
			Button val5 = val.Button(ref val4);
			TextRenderer componentInChildren = ((Component)val5).Slot.GetComponentInChildren<TextRenderer>((Predicate<TextRenderer>)null, false, false);
			if (componentInChildren != null)
			{
				((SyncField<colorX>)(object)componentInChildren.Color).Value = new colorX(0.9f, 0.9f, 0.9f, 1f, (ColorProfile)1);
				((SyncField<float>)(object)componentInChildren.Size).Value = 18f;
			}
			if (((SyncElementList<ColorDriver>)(object)((InteractionElement)val5).ColorDrivers).Count > 0)
			{
				ColorDriver obj4 = ((SyncElementList<ColorDriver>)(object)((InteractionElement)val5).ColorDrivers)[0];
				((SyncField<colorX>)(object)obj4.NormalColor).Value = new colorX(0.2f, 0.4f, 0.6f, 1f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj4.HighlightColor).Value = new colorX(0.25f, 0.5f, 0.75f, 1f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj4.PressColor).Value = new colorX(0.15f, 0.3f, 0.45f, 1f, (ColorProfile)1);
			}
			val5.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_000f: 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_0020: Expected O, but got Unknown
				try
				{
					Msg("[Update] Opening releases page");
					try
					{
						Process.Start(new ProcessStartInfo("https://github.com/DevL0rd/DesktopBuddy/releases")
						{
							UseShellExecute = true
						});
					}
					catch (global::System.Exception ex)
					{
						Msg("[Update] Failed: " + ex.Message);
					}
					if (!((ContainerWorker<Component>)(object)updateSlot).IsDestroyed)
					{
						updateSlot.Destroy();
					}
				}
				catch (global::System.Exception ex2)
				{
					Msg($"[Update] Download button error: {ex2}");
				}
			};
			val.Style.MinHeight = 30f;
			val4 = LocaleString.op_Implicit("Dismiss");
			Button val6 = val.Button(ref val4);
			TextRenderer componentInChildren2 = ((Component)val6).Slot.GetComponentInChildren<TextRenderer>((Predicate<TextRenderer>)null, false, false);
			if (componentInChildren2 != null)
			{
				((SyncField<colorX>)(object)componentInChildren2.Color).Value = new colorX(0.7f, 0.7f, 0.7f, 1f, (ColorProfile)1);
				((SyncField<float>)(object)componentInChildren2.Size).Value = 14f;
			}
			if (((SyncElementList<ColorDriver>)(object)((InteractionElement)val6).ColorDrivers).Count > 0)
			{
				ColorDriver obj5 = ((SyncElementList<ColorDriver>)(object)((InteractionElement)val6).ColorDrivers)[0];
				((SyncField<colorX>)(object)obj5.NormalColor).Value = new colorX(0.2f, 0.2f, 0.25f, 1f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj5.HighlightColor).Value = new colorX(0.3f, 0.3f, 0.35f, 1f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj5.PressColor).Value = new colorX(0.15f, 0.15f, 0.18f, 1f, (ColorProfile)1);
			}
			val6.LocalPressed += (ButtonEventHandler)delegate
			{
				try
				{
					if (!((ContainerWorker<Component>)(object)updateSlot).IsDestroyed)
					{
						updateSlot.Destroy();
					}
				}
				catch (global::System.Exception ex)
				{
					Msg($"[Update] Dismiss button error: {ex}");
				}
			};
			((Worker)root).World.RunInUpdates(900, (Action)delegate
			{
				try
				{
					if (!((ContainerWorker<Component>)(object)updateSlot).IsDestroyed)
					{
						updateSlot.Destroy();
					}
				}
				catch (global::System.Exception ex)
				{
					Msg($"[Update] Auto-dismiss error: {ex}");
				}
			});
		}

		private static void SaveCurrentConfigDefaults()
		{
			try
			{
				if (Config != null)
				{
					Config.Set(SpatialAudioEnabled, Config.GetValue(SpatialAudioEnabled));
					Config.Set(Bitrate, Config.GetValue(Bitrate));
					Config.Set(StreamFps, Math.Clamp(Config.GetValue(StreamFps), 1, 240));
					Config.Set(MaxStreamResolution, Math.Clamp(Config.GetValue(MaxStreamResolution), 128, 8192));
					Config.Set(CheckForUpdates, Config.GetValue(CheckForUpdates));
					Config.Set(ShowContextMenuItem, Config.GetValue(ShowContextMenuItem));
					Config.Set(ThrowToDestroy, Config.GetValue(ThrowToDestroy));
					Config.Set(SpawnNewWindowsInGame, Config.GetValue(SpawnNewWindowsInGame));
					Config.Set(SpawnNewWindowsPrivate, Config.GetValue(SpawnNewWindowsPrivate));
					Config.Set(NewWindowsStartPrivate, Config.GetValue(NewWindowsStartPrivate));
					Config.Set(DynamicLightsEnabled, Config.GetValue(DynamicLightsEnabled));
					Config.Set(UseMediaMtx, Config.GetValue(UseMediaMtx));
					Config.Set(MediaMtxHost, Config.GetValue(MediaMtxHost));
					Config.Set(MediaMtxPort, Config.GetValue(MediaMtxPort));
					Config.Set(MediaMtxStreamName, Config.GetValue(MediaMtxStreamName));
					Config.Set(StreamNetworkMode, NormalizeStreamNetworkMode(Config.GetValue(StreamNetworkMode)));
					Config.Set(PortForwardHostMode, NormalizePortForwardHostMode(Config.GetValue(PortForwardHostMode)));
					Config.Set(PortForwardAutoIpMode, NormalizePortForwardAutoIpMode(Config.GetValue(PortForwardAutoIpMode)));
					Config.Set(PortForwardHost, Config.GetValue(PortForwardHost)?.Trim() ?? "");
					Config.Set(PortForwardUseNat, Config.GetValue(PortForwardUseNat));
					Config.Set(PanelCurvePreferences, Config.GetValue(PanelCurvePreferences) ?? "");
					Config.Set(LinuxSharedSources, Config.GetValue(LinuxSharedSources) ?? "");
					Config.Set(ViewerCullingMode, NormalizeViewerCullingMode(Config.GetValue(ViewerCullingMode)));
					Config.Set(ViewerCullingPreview, Config.GetValue(ViewerCullingPreview));
					float value = Config.GetValue(ViewerFrustumWidth);
					Config.Set(ViewerFrustumWidth, (value < 5f) ? 120f : Math.Clamp(value, 30f, 170f));
					Config.Set(ViewerFrustumDepth, Math.Clamp(Config.GetValue(ViewerFrustumDepth), 1f, 10f));
					Config.Set(ViewerDistance, Math.Clamp(Config.GetValue(ViewerDistance), 1f, 10f));
					Config.Set(EncoderPreference, NormalizeEncoderPreference(Config.GetValue(EncoderPreference)));
					Config.Set(PreferredGpuLuid, Config.GetValue(PreferredGpuLuid)?.Trim() ?? "");
					Config.Set(StreamAudioOutputVolume, NormalizeStreamAudioOutputVolume(Config.GetValue(StreamAudioOutputVolume)));
					Config.Set(StreamAudioGlobalMode, NormalizeStreamAudioGlobalMode(Config.GetValue(StreamAudioGlobalMode)));
					Config.Set(StreamAudioSpatialize, Config.GetValue(StreamAudioSpatialize));
					Config.Set(StreamAudioSpatialBlend, Math.Clamp(Config.GetValue(StreamAudioSpatialBlend), 0f, 1f));
					Config.Set(StreamAudioDistanceSpace, NormalizeStreamAudioDistanceSpace(Config.GetValue(StreamAudioDistanceSpace)));
					Config.Set(StreamAudioDopplerLevel, Math.Clamp(Config.GetValue(StreamAudioDopplerLevel), 0f, 1f));
					Config.Set(StreamAudioPitch, Math.Clamp(Config.GetValue(StreamAudioPitch), 0.5f, 2f));
					Config.Set(StreamAudioIgnoreAudioEffects, Config.GetValue(StreamAudioIgnoreAudioEffects));
					Config.Set(StreamAudioTypeGroup, NormalizeStreamAudioTypeGroup(Config.GetValue(StreamAudioTypeGroup)));
					Config.Set(StreamAudioRolloffMode, NormalizeStreamAudioRolloffMode(Config.GetValue(StreamAudioRolloffMode)));
					Config.Set(StreamAudioMinDistance, Math.Clamp(Config.GetValue(StreamAudioMinDistance), 0f, 10f));
					Config.Set(StreamAudioMaxDistance, Math.Clamp(Config.GetValue(StreamAudioMaxDistance), 1f, 50f));
					Config.Set(StreamAudioSpatializationStartDistance, Math.Clamp(Config.GetValue(StreamAudioSpatializationStartDistance), 0f, 10f));
					Config.Set(StreamAudioSpatializationTransitionRange, Math.Clamp(Config.GetValue(StreamAudioSpatializationTransitionRange), 0f, 10f));
					Config.Set(StreamAudioPriority, Math.Clamp(Config.GetValue(StreamAudioPriority), 0, 256));
					Config.Set(StreamAudioMinScale, Math.Clamp(Config.GetValue(StreamAudioMinScale), 0f, 1000f));
					Config.Set(StreamAudioMaxScale, Math.Clamp(Config.GetValue(StreamAudioMaxScale), 0f, 1000f));
					Config.Save();
					RefreshRuntimeStreamSettingsFromConfig();
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Config] Failed to save current defaults: " + ex.Message);
			}
		}

		private static void RefreshRuntimeStreamSettingsFromConfig()
		{
			try
			{
				if (Config != null)
				{
					Volatile.Write(ref _runtimeBitrateMbps, Math.Clamp(Config.GetValue(Bitrate), 1, 200));
					Volatile.Write(ref _runtimeStreamFps, Math.Clamp(Config.GetValue(StreamFps), 1, 240));
					Volatile.Write(ref _runtimeMaxStreamResolution, Math.Clamp(Config.GetValue(MaxStreamResolution), 128, 8192));
					_runtimeEncoderPreference = NormalizeEncoderPreference(Config.GetValue(EncoderPreference));
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Config] Failed to refresh runtime stream settings: " + ex.Message);
			}
		}

		private static void ApplyFreshConfigDefaults()
		{
			Config.Set(SpatialAudioEnabled, SpatialAudioEnabled.DefaultValue);
			Config.Set(CheckForUpdates, CheckForUpdates.DefaultValue);
			Config.Set(ShowContextMenuItem, ShowContextMenuItem.DefaultValue);
			Config.Set(ThrowToDestroy, ThrowToDestroy.DefaultValue);
			Config.Set(SpawnNewWindowsInGame, SpawnNewWindowsInGame.DefaultValue);
			Config.Set(SpawnNewWindowsPrivate, SpawnNewWindowsPrivate.DefaultValue);
			Config.Set(NewWindowsStartPrivate, NewWindowsStartPrivate.DefaultValue);
			Config.Set(DynamicLightsEnabled, DynamicLightsEnabled.DefaultValue);
			Config.Set(Bitrate, Bitrate.DefaultValue);
			Config.Set(StreamFps, StreamFps.DefaultValue);
			Config.Set(MaxStreamResolution, MaxStreamResolution.DefaultValue);
			Config.Set(UseMediaMtx, UseMediaMtx.DefaultValue);
			Config.Set(MediaMtxHost, MediaMtxHost.DefaultValue);
			Config.Set(MediaMtxPort, MediaMtxPort.DefaultValue);
			Config.Set(MediaMtxStreamName, MediaMtxStreamName.DefaultValue);
			Config.Set(StreamNetworkMode, StreamNetworkMode.DefaultValue);
			Config.Set(PortForwardHostMode, PortForwardHostMode.DefaultValue);
			Config.Set(PortForwardAutoIpMode, PortForwardAutoIpMode.DefaultValue);
			Config.Set(PortForwardHost, PortForwardHost.DefaultValue);
			Config.Set(PortForwardUseNat, PortForwardUseNat.DefaultValue);
			Config.Set(PanelCurvePreferences, PanelCurvePreferences.DefaultValue);
			Config.Set(LinuxSharedSources, LinuxSharedSources.DefaultValue);
			Config.Set(ViewerCullingMode, ViewerCullingMode.DefaultValue);
			Config.Set(ViewerCullingPreview, ViewerCullingPreview.DefaultValue);
			Config.Set(ViewerFrustumWidth, ViewerFrustumWidth.DefaultValue);
			Config.Set(ViewerFrustumDepth, ViewerFrustumDepth.DefaultValue);
			Config.Set(ViewerDistance, ViewerDistance.DefaultValue);
			Config.Set(EncoderPreference, EncoderPreference.DefaultValue);
			Config.Set(PreferredGpuLuid, PreferredGpuLuid.DefaultValue);
			Config.Set(StreamAudioOutputVolume, StreamAudioOutputVolume.DefaultValue);
			Config.Set(StreamAudioGlobalMode, StreamAudioGlobalMode.DefaultValue);
			Config.Set(StreamAudioSpatialize, StreamAudioSpatialize.DefaultValue);
			Config.Set(StreamAudioSpatialBlend, StreamAudioSpatialBlend.DefaultValue);
			Config.Set(StreamAudioDistanceSpace, StreamAudioDistanceSpace.DefaultValue);
			Config.Set(StreamAudioDopplerLevel, StreamAudioDopplerLevel.DefaultValue);
			Config.Set(StreamAudioPitch, StreamAudioPitch.DefaultValue);
			Config.Set(StreamAudioIgnoreAudioEffects, StreamAudioIgnoreAudioEffects.DefaultValue);
			Config.Set(StreamAudioTypeGroup, StreamAudioTypeGroup.DefaultValue);
			Config.Set(StreamAudioRolloffMode, StreamAudioRolloffMode.DefaultValue);
			Config.Set(StreamAudioMinDistance, StreamAudioMinDistance.DefaultValue);
			Config.Set(StreamAudioMaxDistance, StreamAudioMaxDistance.DefaultValue);
			Config.Set(StreamAudioSpatializationStartDistance, StreamAudioSpatializationStartDistance.DefaultValue);
			Config.Set(StreamAudioSpatializationTransitionRange, StreamAudioSpatializationTransitionRange.DefaultValue);
			Config.Set(StreamAudioPriority, StreamAudioPriority.DefaultValue);
			Config.Set(StreamAudioMinScale, StreamAudioMinScale.DefaultValue);
			Config.Set(StreamAudioMaxScale, StreamAudioMaxScale.DefaultValue);
		}

		private static void ApplyRuntimeSetting<T>(DesktopBuddyConfigKey<T> key, T value)
		{
			if ((object)key == Bitrate && value is int num)
			{
				Volatile.Write(ref _runtimeBitrateMbps, Math.Clamp(num, 1, 200));
			}
			else if ((object)key == StreamFps && value is int num2)
			{
				Volatile.Write(ref _runtimeStreamFps, Math.Clamp(num2, 1, 240));
			}
			else if ((object)key == MaxStreamResolution && value is int num3)
			{
				Volatile.Write(ref _runtimeMaxStreamResolution, Math.Clamp(num3, 128, 8192));
			}
			else if ((object)key == EncoderPreference && value is string value2)
			{
				_runtimeEncoderPreference = NormalizeEncoderPreference(value2);
			}
		}

		internal static void SaveConfigValue<T>(DesktopBuddyConfigKey<T> key, T value)
		{
			try
			{
				if (Config != null)
				{
					ApplyRuntimeSetting(key, value);
					Config.Set(key, value);
					_settingsConfigDirty = true;
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Config] Failed to set " + key?.Name + ": " + ex.Message);
			}
		}

		internal static void FlushSettingsConfig()
		{
			try
			{
				if (Config != null && _settingsConfigDirty)
				{
					_settingsConfigDirty = false;
					Config.Save();
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Config] Failed to save settings: " + ex.Message);
				_settingsConfigDirty = true;
			}
		}

		private static void BindConfigKeys()
		{
			Config.Bind(SpatialAudioEnabled);
			Config.Bind(CheckForUpdates);
			Config.Bind(ShowContextMenuItem);
			Config.Bind(ThrowToDestroy);
			Config.Bind(SpawnNewWindowsInGame);
			Config.Bind(SpawnNewWindowsPrivate);
			Config.Bind(NewWindowsStartPrivate);
			Config.Bind(DynamicLightsEnabled);
			Config.Bind(Bitrate);
			Config.Bind(StreamFps);
			Config.Bind(MaxStreamResolution);
			Config.Bind(UseMediaMtx);
			Config.Bind(MediaMtxHost);
			Config.Bind(MediaMtxPort);
			Config.Bind(MediaMtxStreamName);
			Config.Bind(StreamNetworkMode);
			Config.Bind(PortForwardHostMode);
			Config.Bind(PortForwardAutoIpMode);
			Config.Bind(PortForwardHost);
			Config.Bind(PortForwardUseNat);
			Config.Bind(PanelCurvePreferences);
			Config.Bind(LinuxSharedSources);
			Config.Bind(ViewerCullingMode);
			Config.Bind(ViewerCullingPreview);
			Config.Bind(ViewerFrustumWidth);
			Config.Bind(ViewerFrustumDepth);
			Config.Bind(ViewerDistance);
			Config.Bind(EncoderPreference);
			Config.Bind(PreferredGpuLuid);
			Config.Bind(StreamAudioOutputVolume);
			Config.Bind(StreamAudioGlobalMode);
			Config.Bind(StreamAudioSpatialize);
			Config.Bind(StreamAudioSpatialBlend);
			Config.Bind(StreamAudioDistanceSpace);
			Config.Bind(StreamAudioDopplerLevel);
			Config.Bind(StreamAudioPitch);
			Config.Bind(StreamAudioIgnoreAudioEffects);
			Config.Bind(StreamAudioTypeGroup);
			Config.Bind(StreamAudioRolloffMode);
			Config.Bind(StreamAudioMinDistance);
			Config.Bind(StreamAudioMaxDistance);
			Config.Bind(StreamAudioSpatializationStartDistance);
			Config.Bind(StreamAudioSpatializationTransitionRange);
			Config.Bind(StreamAudioPriority);
			Config.Bind(StreamAudioMinScale);
			Config.Bind(StreamAudioMaxScale);
		}

		internal static string GetMediaMtxRtspUrl(int streamId)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			string text = Config.GetValue(MediaMtxHost).Trim();
			int value = Config.GetValue(MediaMtxPort);
			string text2 = Config.GetValue(MediaMtxStreamName)?.Trim();
			if (string.IsNullOrEmpty(text2))
			{
				if (_mediaMtxStreamBase == null)
				{
					Guid val = Guid.NewGuid();
					_mediaMtxStreamBase = "desktopbuddy-" + ((Guid)(ref val)).ToString("N").Substring(0, 8);
				}
				text2 = _mediaMtxStreamBase;
			}
			return $"rtsp://{text}:{value}/{text2}_{streamId}";
		}

		internal static string GetPanelCurvePreferenceKey(nint hwnd)
		{
			if (hwnd == (nint)global::System.IntPtr.Zero)
			{
				return "desktop";
			}
			string executablePath = WindowIconExtractor.GetExecutablePath(hwnd);
			if (!string.IsNullOrWhiteSpace(executablePath))
			{
				return "app:" + executablePath.ToLowerInvariant();
			}
			WindowEnumerator.GetWindowThreadProcessId(hwnd, out var lpdwProcessId);
			if (lpdwProcessId != 0)
			{
				return $"pid:{lpdwProcessId}";
			}
			return $"hwnd:{((global::System.IntPtr)hwnd).ToInt64():X}";
		}

		internal static float GetPanelCurvePreference(string key, float fallback)
		{
			try
			{
				float num = default(float);
				return ParsePanelCurvePreferences(Config?.GetValue(PanelCurvePreferences)).TryGetValue(key, ref num) ? Math.Clamp(num, 0f, 1f) : fallback;
			}
			catch (global::System.Exception ex)
			{
				Msg("[Curve] Failed to load preference: " + ex.Message);
				return fallback;
			}
		}

		internal static void SetPanelCurvePreference(string key, float value)
		{
			try
			{
				if (Config != null && !string.IsNullOrWhiteSpace(key))
				{
					Dictionary<string, float> val = ParsePanelCurvePreferences(Config.GetValue(PanelCurvePreferences));
					val[key] = Math.Clamp(value, 0f, 1f);
					Config.Set(PanelCurvePreferences, SerializePanelCurvePreferences(val));
					Config.Save();
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Curve] Failed to save preference: " + ex.Message);
			}
		}

		private static Dictionary<string, float> ParsePanelCurvePreferences(string serialized)
		{
			Dictionary<string, float> val = new Dictionary<string, float>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);
			if (string.IsNullOrWhiteSpace(serialized))
			{
				return val;
			}
			string[] array = serialized.Split(new char[2] { '\n', '\r' }, (StringSplitOptions)1);
			float num2 = default(float);
			foreach (string text in array)
			{
				int num = text.IndexOf('=');
				if (num > 0)
				{
					string text2 = Uri.UnescapeDataString(text.Substring(0, num));
					if (float.TryParse(text.Substring(num + 1), (NumberStyles)167, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref num2))
					{
						val[text2] = Math.Clamp(num2, 0f, 1f);
					}
				}
			}
			return val;
		}

		private static string SerializePanelCurvePreferences(Dictionary<string, float> prefs)
		{
			//IL_0007: 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_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			List<string> val = new List<string>();
			Enumerator<string, float> enumerator = prefs.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<string, float> current = enumerator.Current;
					string text = Uri.EscapeDataString(current.Key);
					string text2 = Math.Clamp(current.Value, 0f, 1f).ToString("R", (IFormatProvider)(object)CultureInfo.InvariantCulture);
					val.Add(text + "=" + text2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			return string.Join("\n", (global::System.Collections.Generic.IEnumerable<string>)val);
		}

		internal static string NormalizeViewerCullingMode(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant();
			if (!(value == "distance"))
			{
				return "frustum";
			}
			return "distance";
		}

		internal static string NormalizeEncoderPreference(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant().Replace("-", "_")
				.Replace(" ", "_");
			if (value != null)
			{
				switch (value.Length)
				{
				case 10:
				{
					char c = value[1];
					if (c != '2')
					{
						if (c != 'e' || !(value == "hevc_nvenc"))
						{
							break;
						}
					}
					else if (!(value == "h264_nvenc"))
					{
						break;
					}
					goto IL_0112;
				}
				case 8:
				{
					char c = value[1];
					if (c != '2')
					{
						if (c != 'e' || (!(value == "hevc_amf") && !(value == "hevc_qsv")))
						{
							break;
						}
					}
					else if (!(value == "h264_amf") && !(value == "h264_qsv"))
					{
						break;
					}
					goto IL_0112;
				}
				case 7:
					{
						char c = value[6];
						if (c != '4')
						{
							if (c != '5' || !(value == "libx265"))
							{
								break;
							}
						}
						else if (!(value == "libx264"))
						{
							break;
						}
						goto IL_0112;
					}
					IL_0112:
					return value;
				}
			}
			return "auto";
		}

		internal static float NormalizeStreamAudioOutputVolume(float value)
		{
			return Math.Clamp(value, 0f, 1f);
		}

		internal static string NormalizeStreamAudioGlobalMode(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant();
			if (!(value == "auto") && !(value == "global"))
			{
				return "positional";
			}
			return value;
		}

		internal static string NormalizeStreamAudioDistanceSpace(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant();
			if (!(value == "local"))
			{
				return "global";
			}
			return "local";
		}

		internal static string NormalizeStreamAudioTypeGroup(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant().Replace("-", "_")
				.Replace(" ", "_");
			if (!(value == "soundeffect") && !(value == "sound_effect"))
			{
				if (!(value == "voice"))
				{
					if (value == "ui" || value == "user_interface")
					{
						return "ui";
					}
					return "multimedia";
				}
				return "voice";
			}
			return "sound_effect";
		}

		internal static string NormalizeStreamAudioRolloffMode(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant().Replace("-", "_")
				.Replace(" ", "_");
			if (!(value == "logarithmic_fade_off") && !(value == "logarithmicfadeoff"))
			{
				return "linear";
			}
			return "logarithmic_fade_off";
		}

		private static bool? ParseStreamAudioGlobalMode(string value)
		{
			string text = NormalizeStreamAudioGlobalMode(value);
			if (!(text == "auto"))
			{
				if (text == "positional")
				{
					return false;
				}
				return true;
			}
			return null;
		}

		private static AudioDistanceSpace ParseStreamAudioDistanceSpace(string value)
		{
			if (NormalizeStreamAudioDistanceSpace(value) == "local")
			{
				return (AudioDistanceSpace)0;
			}
			return (AudioDistanceSpace)1;
		}

		private static AudioTypeGroup ParseStreamAudioTypeGroup(string value)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			string text = NormalizeStreamAudioTypeGroup(value);
			if (!(text == "sound_effect"))
			{
				if (!(text == "voice"))
				{
					if (text == "ui")
					{
						return (AudioTypeGroup)3;
					}
					return (AudioTypeGroup)1;
				}
				return (AudioTypeGroup)2;
			}
			return (AudioTypeGroup)0;
		}

		private static AudioRolloffCurve ParseStreamAudioRolloffMode(string value)
		{
			if (NormalizeStreamAudioRolloffMode(value) == "linear")
			{
				return (AudioRolloffCurve)3;
			}
			return (AudioRolloffCurve)2;
		}

		internal static void ApplyStreamAudioSettings(DesktopSession session)
		{
			//IL_00c4: 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_016e: Unknown result type (might be due to invalid IL or missing references)
			if (session == null || Config == null)
			{
				return;
			}
			try
			{
				if (session.VideoTexture != null && !((ComponentBase<Component>)(object)session.VideoTexture).IsDestroyed)
				{
					((SyncField<float>)(object)session.VideoTexture.Volume).Value = 1f;
				}
				AudioOutput streamAudioOutput = session.StreamAudioOutput;
				if (streamAudioOutput != null && !((ComponentBase<Component>)(object)streamAudioOutput).IsDestroyed)
				{
					((SyncField<bool?>)(object)streamAudioOutput.Global).Value = ParseStreamAudioGlobalMode(Config.GetValue(StreamAudioGlobalMode));
					((SyncField<bool>)(object)streamAudioOutput.Spatialize).Value = Config.GetValue(StreamAudioSpatialize);
					((SyncField<float>)(object)streamAudioOutput.SpatialBlend).Value = Math.Clamp(Config.GetValue(StreamAudioSpatialBlend), 0f, 1f);
					((SyncField<AudioDistanceSpace>)(object)streamAudioOutput.DistanceSpace).Value = ParseStreamAudioDistanceSpace(Config.GetValue(StreamAudioDistanceSpace));
					((SyncField<float>)(object)streamAudioOutput.DopplerLevel).Value = Math.Clamp(Config.GetValue(StreamAudioDopplerLevel), 0f, 1f);
					((SyncField<float>)(object)streamAudioOutput.Pitch).Value = Math.Clamp(Config.GetValue(StreamAudioPitch), 0.5f, 2f);
					((SyncField<bool>)(object)streamAudioOutput.IgnoreAudioEffects).Value = Config.GetValue(StreamAudioIgnoreAudioEffects);
					((SyncField<AudioTypeGroup>)(object)streamAudioOutput.AudioTypeGroup).Value = ParseStreamAudioTypeGroup(Config.GetValue(StreamAudioTypeGroup));
					((SyncField<AudioRolloffCurve>)(object)streamAudioOutput.RolloffMode).Value = ParseStreamAudioRolloffMode(Config.GetValue(StreamAudioRolloffMode));
					((SyncField<float>)(object)streamAudioOutput.MinDistance).Value = Math.Clamp(Config.GetValue(StreamAudioMinDistance), 0f, 10f);
					((SyncField<float>)(object)streamAudioOutput.MaxDistance).Value = Math.Clamp(Config.GetValue(StreamAudioMaxDistance), 1f, 50f);
					((SyncField<float>)(object)streamAudioOutput.SpatializationStartDistance).Value = Math.Clamp(Config.GetValue(StreamAudioSpatializationStartDistance), 0f, 10f);
					((SyncField<float>)(object)streamAudioOutput.SpatializationTransitionRange).Value = Math.Clamp(Config.GetValue(StreamAudioSpatializationTransitionRange), 0f, 10f);
					((SyncField<int>)(object)streamAudioOutput.Priority).Value = Math.Clamp(Config.GetValue(StreamAudioPriority), 0, 256);
					((SyncField<float>)(object)streamAudioOutput.MinScale).Value = Math.Clamp(Config.GetValue(StreamAudioMinScale), 0f, 1000f);
					((SyncField<float>)(object)streamAudioOutput.MaxScale).Value = Math.Clamp(Config.GetValue(StreamAudioMaxScale), 0f, 1000f);
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[StreamAudio] Failed to apply settings: " + ex.Message);
			}
		}

		internal static void ApplyStreamAudioSettingsToAllSessions()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Enumerator<DesktopSession> enumerator = Enumerable.ToList<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)ActiveSessions).GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					DesktopSession current = enumerator.Current;
					if (current != null && !current.Cleaned)
					{
						ApplyStreamAudioSettings(current);
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}

		internal static string NormalizeStreamNetworkMode(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant().Replace("-", "_")
				.Replace(" ", "_");
			if (!(value == "port_forward"))
			{
				return "cloudflare";
			}
			return "port_forward";
		}

		internal static string NormalizePortForwardHostMode(string value)
		{
			value = (value ?? "").Trim().ToLowerInvariant();
			if (!(value == "manual"))
			{
				return "auto";
			}
			return "manual";
		}

		internal static string NormalizePortForwardAutoIpMode(string value)
		{
			return "external";
		}

		internal static Uri GetBuiltInStreamUrl(int streamId)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			string builtInStreamBaseUrl = GetBuiltInStreamBaseUrl();
			if (!string.IsNullOrWhiteSpace(builtInStreamBaseUrl))
			{
				return new Uri($"{builtInStreamBaseUrl}/stream/{streamId}");
			}
			return null;
		}

		internal static string GetBuiltInStreamBaseUrl()
		{
			if (NormalizeStreamNetworkMode(Config?.GetValue(StreamNetworkMode)) == "cloudflare")
			{
				return TunnelUrl;
			}
			string text = ResolvePortForwardHost();
			if (!string.IsNullOrWhiteSpace(text))
			{
				return $"http://{text}:{48080}";
			}
			return null;
		}

		internal static string ResolvePortForwardHost()
		{
			if (Config != null && NormalizePortForwardHostMode(Config.GetValue(PortForwardHostMode)) == "manual")
			{
				return Config.GetValue(PortForwardHost)?.Trim();
			}
			return GetAutoExternalIPv4Address();
		}

		internal static string GetBestLocalIPv4Address()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			try
			{
				NetworkInterface[] allNetworkInterfaces = NetworkInterface.GetAllNetworkInterfaces();
				foreach (NetworkInterface val in allNetworkInterfaces)
				{
					if ((int)val.OperationalStatus != 1 || (int)val.NetworkInterfaceType == 24)
					{
						continue;
					}
					global::System.Collections.Generic.IEnumerator<UnicastIPAddressInformation> enumerator = val.GetIPProperties().UnicastAddresses.GetEnumerator();
					try
					{
						while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
						{
							UnicastIPAddressInformation current = enumerator.Current;
							if ((int)((IPAddressInformation)current).Address.AddressFamily == 2 && !IPAddress.IsLoopback(((IPAddressInformation)current).Address))
							{
								return ((object)((IPAddressInformation)current).Address).ToString();
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator)?.Dispose();
					}
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Network] Failed to auto-detect local IP: " + ex.Message);
			}
			return "";
		}

		[DllImport("kernel32.dll", CharSet = (CharSet)3, SetLastError = true)]
		private static extern SafeFileHandle CreateJobObject(nint lpJobAttributes, string lpName);

		[DllImport("kernel32.dll", SetLastError = true)]
		private static extern bool SetInformationJobObject(SafeFileHandle hJob, int jobObjectInfoClass, nint lpJobObjectInfo, uint cbJobObjectInfoLength);

		[DllImport("kernel32.dll", SetLastError = true)]
		private static extern bool AssignProcessToJobObject(SafeFileHandle hJob, nint hProcess);

		private static string LaunchClientPath()
		{
			if (_launchClientResolved)
			{
				return _launchClientPath;
			}
			_launchClientResolved = true;
			_launchClientPath = (DesktopBuddyPlatform.IsLinux ? ResolveLaunchClient() : null);
			if (_launchClientPath != null)
			{
				Msg("[Tunnel] In Steam container; cloudflared will run on the host via " + _launchClientPath);
			}
			return _launchClientPath;
		}

		private static string ResolveLaunchClient()
		{
			try
			{
				if (!File.Exists("/run/host/container-manager") && !Directory.Exists("/run/pressure-vessel"))
				{
					return null;
				}
				string[] array = new string[2] { "/usr/bin/steam-runtime-launch-client", "/usr/lib/pressure-vessel/from-host/bin/steam-runtime-launch-client" };
				foreach (string text in array)
				{
					if (File.Exists(text))
					{
						return text;
					}
				}
				return "steam-runtime-launch-client";
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] Launch-client probe failed: " + ex.Message);
				return null;
			}
		}

		internal static string RunOnHostCapture(string exe, string args, int timeoutMs)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: 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_0022: Expected O, but got Unknown
			try
			{
				ProcessStartInfo val = new ProcessStartInfo
				{
					RedirectStandardOutput = true,
					RedirectStandardError = true,
					UseShellExecute = false,
					CreateNoWindow = true
				};
				string text = LaunchClientPath();
				if (text != null)
				{
					val.FileName = text;
					val.Arguments = "--alongside-steam -- " + exe + " " + args;
				}
				else
				{
					val.FileName = exe;
					val.Arguments = args;
				}
				Process val2 = Process.Start(val);
				if (val2 == null)
				{
					return null;
				}
				string text2 = ((TextReader)val2.StandardOutput).ReadToEnd();
				if (!val2.WaitForExit(timeoutMs))
				{
					try
					{
						val2.Kill();
					}
					catch
					{
					}
					return null;
				}
				return text2?.Trim();
			}
			catch (global::System.Exception ex)
			{
				Msg("[HostCmd] " + exe + " failed: " + ex.Message);
				return null;
			}
		}

		private static ProcessStartInfo MakeCloudflaredPsi(string exe, string args)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0013: 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_0022: Expected O, but got Unknown
			ProcessStartInfo val = new ProcessStartInfo
			{
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				UseShellExecute = false,
				CreateNoWindow = true
			};
			string text = LaunchClientPath();
			if (text != null)
			{
				val.FileName = text;
				val.Arguments = "--alongside-steam -- \"" + exe + "\" " + args;
			}
			else
			{
				val.FileName = exe;
				val.Arguments = args;
			}
			return val;
		}

		private static void EnsureExecutable(string path)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: 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)
			if (!DesktopBuddyPlatform.IsLinux)
			{
				return;
			}
			try
			{
				UnixFileMode unixFileMode = File.GetUnixFileMode(path);
				UnixFileMode val = (UnixFileMode)(unixFileMode | 0x40 | 8 | 1);
				if (unixFileMode != val)
				{
					File.SetUnixFileMode(path, val);
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] Could not set exec bit on " + path + ": " + ex.Message);
			}
		}

		private static string FindCloudflared()
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				if (ProbeCloudflared("cloudflared", isPath: false))
				{
					return "cloudflared";
				}
				Msg("[Tunnel] cloudflared not found on host PATH (install it: sudo pacman -S cloudflared)");
				return null;
			}
			string text = DesktopBuddyRuntimePaths.FindFile(CloudflaredFileName);
			if (ProbeCloudflared(text, isPath: true))
			{
				return text;
			}
			Msg("[Tunnel] cloudflared not usable (bundled='" + text + "')");
			return null;
		}

		private static bool ProbeCloudflared(string fileName, bool isPath)
		{
			try
			{
				if (isPath && !File.Exists(fileName))
				{
					Msg("[Tunnel] cloudflared not present at " + fileName);
					return false;
				}
				if (isPath)
				{
					EnsureExecutable(fileName);
				}
				Process val = Process.Start(MakeCloudflaredPsi(fileName, "version"));
				if (val == null)
				{
					Msg("[Tunnel] cloudflared probe: Process.Start returned null for " + fileName);
					return false;
				}
				string text = ((TextReader)val.StandardOutput).ReadToEnd();
				string text2 = ((TextReader)val.StandardError).ReadToEnd();
				val.WaitForExit(5000);
				if (val.HasExited && val.ExitCode == 0)
				{
					Msg($"[Tunnel] Found cloudflared: {fileName} ({text.Trim()})");
					return true;
				}
				string text3 = (val.HasExited ? $"exit={val.ExitCode}" : "did not exit in 5s");
				Msg($"[Tunnel] cloudflared probe {text3} for {fileName}{(string.IsNullOrWhiteSpace(text2) ? "" : (" err=" + text2.Trim()))}");
				return false;
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] cloudflared probe failed for " + fileName + ": " + ex.Message);
				return false;
			}
		}

		private static void KillTunnel()
		{
			try
			{
				if (_tunnelProcess != null && !_tunnelProcess.HasExited)
				{
					_tunnelProcess.Kill();
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] Kill failed: " + ex.Message);
			}
			_tunnelProcess = null;
			try
			{
				SafeFileHandle tunnelJob = _tunnelJob;
				if (tunnelJob != null)
				{
					((SafeHandle)tunnelJob).Dispose();
				}
			}
			catch (global::System.Exception ex2)
			{
				Msg("[Tunnel] Job dispose failed: " + ex2.Message);
			}
			_tunnelJob = null;
		}

		private static void OnTunnelError(string data)
		{
		}

		private static void UpdateSessionTunnelUrls()
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (TunnelUrl == null || !UseCloudflareTunnel)
				{
					return;
				}
				DesktopSession[] array;
				try
				{
					array = ActiveSessions.ToArray();
				}
				catch (global::System.Exception ex)
				{
					Msg($"[Tunnel] Active session snapshot failed: {ex}");
					return;
				}
				DesktopSession[] array2 = array;
				foreach (DesktopSession desktopSession in array2)
				{
					try
					{
						if (desktopSession == null || desktopSession.Cleaned || desktopSession.StreamId <= 0)
						{
							continue;
						}
						VideoTextureProvider videoTexture = desktopSession.VideoTexture;
						if (videoTexture == null || ((ComponentBase<Component>)(object)videoTexture).IsDestroyed)
						{
							continue;
						}
						Slot root = desktopSession.Root;
						World val = ((root != null) ? ((Worker)root).World : null) ?? ((Worker)videoTexture).World;
						if (val == null)
						{
							continue;
						}
						Uri newUrl = GetBuiltInStreamUrl(desktopSession.StreamId);
						if (newUrl == (Uri)null)
						{
							continue;
						}
						DesktopSession capturedSession = desktopSession;
						int capturedStreamId = desktopSession.StreamId;
						val.RunInUpdates(0, (Action)delegate
						{
							try
							{
								if (capturedSession != null && !capturedSession.Cleaned)
								{
									VideoTextureProvider videoTexture2 = capturedSession.VideoTexture;
									if (videoTexture2 != null && !((ComponentBase<Component>)(object)videoTexture2).IsDestroyed)
									{
										Msg($"[Tunnel] Updating session VTP -> {newUrl}");
										SetRemoteStreamUrl(capturedSession, newUrl, $"tunnel refresh streamId={capturedStreamId}");
									}
								}
							}
							catch (global::System.Exception ex4)
							{
								Msg($"[Tunnel] VTP update callback error: {ex4}");
							}
						});
					}
					catch (global::System.Exception ex2)
					{
						Msg($"[Tunnel] Session URL refresh skipped: {ex2}");
					}
				}
			}
			catch (global::System.Exception ex3)
			{
				Msg($"[Tunnel] URL refresh error: {ex3}");
			}
		}

		private static void RestartTunnel()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (_tunnelRestarting)
			{
				return;
			}
			_tunnelRestarting = true;
			object obj = <>c.<>9__249_0;
			if (obj == null)
			{
				Action val = delegate
				{
					try
					{
						Msg("[Tunnel] === RESTART ===");
						KillTunnel();
						TunnelUrl = null;
						Thread.Sleep(2000);
						StartTunnel();
					}
					catch (global::System.Exception ex)
					{
						Msg($"[Tunnel] Restart task error: {ex}");
					}
					finally
					{
						_tunnelRestarting = false;
					}
				};
				<>c.<>9__249_0 = val;
				obj = (object)val;
			}
			global::System.Threading.Tasks.Task.Run((Action)obj);
		}

		private static void StartTunnel()
		{
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			try
			{
				if (!UseCloudflareTunnel)
				{
					Msg("[Tunnel] Cloudflare disabled by network mode");
					return;
				}
				if (_cfPath == null)
				{
					_cfPath = FindCloudflared();
					if (_cfPath == null)
					{
						Msg("[Tunnel] cloudflared not found - tunnel unavailable");
						return;
					}
				}
				Msg("[Tunnel] Starting cloudflared tunnel: " + _cfPath);
				string text = (DesktopBuddyPlatform.IsLinux ? "/dev/null" : "NUL");
				string args = $"tunnel --config {text} --url http://localhost:{48080} --proxy-keepalive-timeout 5m --proxy-keepalive-connections 100 --proxy-tcp-keepalive 15s --proxy-connect-timeout 30s --compression-quality 0 --grace-period 30s --no-autoupdate --edge-ip-version 4";
				_tunnelProcess = Process.Start(MakeCloudflaredPsi(_cfPath, args));
				if (_tunnelProcess == null)
				{
					Msg("[Tunnel] Failed to start cloudflared");
					return;
				}
				Process proc = _tunnelProcess;
				if (!DesktopBuddyPlatform.IsLinux)
				{
					AttachTunnelToKillJob(proc);
				}
				proc.EnableRaisingEvents = true;
				proc.Exited += (EventHandler)delegate
				{
					Msg($"[Tunnel] cloudflared exited (code={proc.ExitCode}), restarting");
					try
					{
						SafeFileHandle tunnelJob = _tunnelJob;
						if (tunnelJob != null)
						{
							((SafeHandle)tunnelJob).Dispose();
						}
					}
					catch
					{
					}
					_tunnelJob = null;
					RestartTunnel();
				};
				Process obj = proc;
				object obj2 = <>c.<>9__250_1;
				if (obj2 == null)
				{
					DataReceivedEventHandler val = delegate(object s, DataReceivedEventArgs e)
					{
						//IL_006e: Unknown result type (might be due to invalid IL or missing references)
						if (e.Data != null)
						{
							if (e.Data.Contains("https://") && e.Data.Contains(".trycloudflare.com"))
							{
								int num = e.Data.IndexOf("https://");
								string text2 = e.Data.Substring(num).Trim();
								int num2 = text2.IndexOf(' ');
								if (num2 > 0)
								{
									text2 = text2.Substring(0, num2);
								}
								try
								{
									text2 = new Uri(text2).GetLeftPart((UriPartial)1);
								}
								catch (global::System.Exception ex2)
								{
									Msg("[Tunnel] URL parse error: " + ex2.Message);
								}
								string tunnelUrl = TunnelUrl;
								TunnelUrl = text2;
								if (tunnelUrl != text2)
								{
									Msg("[Tunnel] PUBLIC URL: " + TunnelUrl);
									try
									{
										UpdateSessionTunnelUrls();
									}
									catch (global::System.Exception ex3)
									{
										Msg($"[Tunnel] PUBLIC URL refresh error: {ex3}");
									}
								}
							}
							else if (ShouldLogCloudflaredLine(e.Data))
							{
								Msg("[Tunnel] " + e.Data);
							}
							OnTunnelError(e.Data);
						}
					};
					<>c.<>9__250_1 = val;
					obj2 = (object)val;
				}
				obj.ErrorDataReceived += (DataReceivedEventHandler)obj2;
				Process obj3 = proc;
				object obj4 = <>c.<>9__250_2;
				if (obj4 == null)
				{
					DataReceivedEventHandler val2 = delegate(object s, DataReceivedEventArgs e)
					{
						if (e.Data != null && ShouldLogCloudflaredLine(e.Data))
						{
							Msg("[Tunnel] " + e.Data);
						}
					};
					<>c.<>9__250_2 = val2;
					obj4 = (object)val2;
				}
				obj3.OutputDataReceived += (DataReceivedEventHandler)obj4;
				proc.BeginErrorReadLine();
				proc.BeginOutputReadLine();
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] Error: " + ex.Message);
			}
		}

		private static bool ShouldLogCloudflaredLine(string line)
		{
			if (string.IsNullOrWhiteSpace(line))
			{
				return false;
			}
			if (line.Contains(" INF ", (StringComparison)4))
			{
				return false;
			}
			if (line.Contains("Configuration file NUL was empty", (StringComparison)5))
			{
				return false;
			}
			if (line.Contains("Cannot determine default configuration path", (StringComparison)5))
			{
				return false;
			}
			if (line.Contains("stream ", (StringComparison)5) && line.Contains("canceled by remote", (StringComparison)5))
			{
				return false;
			}
			if (line.Contains("Request failed", (StringComparison)5) && line.Contains("canceled by remote", (StringComparison)5))
			{
				return false;
			}
			if (!line.Contains(" ERR ", (StringComparison)4) && !line.Contains(" WRN ", (StringComparison)4) && !line.Contains("error", (StringComparison)5))
			{
				return line.Contains("failed", (StringComparison)5);
			}
			return true;
		}

		private static void AttachTunnelToKillJob(Process proc)
		{
			try
			{
				SafeFileHandle tunnelJob = _tunnelJob;
				if (tunnelJob != null)
				{
					((SafeHandle)tunnelJob).Dispose();
				}
				_tunnelJob = CreateJobObject(global::System.IntPtr.Zero, null);
				if (_tunnelJob == null || ((SafeHandle)_tunnelJob).IsInvalid)
				{
					Msg($"[Tunnel] CreateJobObject failed: {Marshal.GetLastWin32Error()}");
					return;
				}
				JOBOBJECT_EXTENDED_LIMIT_INFORMATION jOBOBJECT_EXTENDED_LIMIT_INFORMATION = new JOBOBJECT_EXTENDED_LIMIT_INFORMATION
				{
					BasicLimitInformation = 
					{
						LimitFlags = 8192u
					}
				};
				int num = Marshal.SizeOf<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>();
				nint num2 = Marshal.AllocHGlobal(num);
				try
				{
					Marshal.StructureToPtr<JOBOBJECT_EXTENDED_LIMIT_INFORMATION>(jOBOBJECT_EXTENDED_LIMIT_INFORMATION, (global::System.IntPtr)num2, false);
					if (!SetInformationJobObject(_tunnelJob, 9, num2, (uint)num))
					{
						Msg($"[Tunnel] SetInformationJobObject failed: {Marshal.GetLastWin32Error()}");
						return;
					}
				}
				finally
				{
					Marshal.FreeHGlobal((global::System.IntPtr)num2);
				}
				if (!AssignProcessToJobObject(_tunnelJob, proc.Handle))
				{
					Msg($"[Tunnel] AssignProcessToJobObject failed: {Marshal.GetLastWin32Error()}");
				}
				else
				{
					Msg($"[Tunnel] cloudflared attached to kill-on-close job pid={proc.Id}");
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Tunnel] Job attach failed: " + ex.Message);
			}
		}

		internal static void ClearExternalIpCache()
		{
			lock (ExternalIpGate)
			{
				_cachedExternalIPv4 = null;
				_cachedExternalIPv4At = global::System.DateTime.MinValue;
			}
		}

		internal static string GetAutoExternalIPv4Address()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Invalid comparison between Unknown and I4
			lock (ExternalIpGate)
			{
				if (!string.IsNullOrWhiteSpace(_cachedExternalIPv4) && global::System.DateTime.UtcNow - _cachedExternalIPv4At < TimeSpan.FromMinutes(10L))
				{
					return _cachedExternalIPv4;
				}
			}
			string[] array = new string[2] { "https://api.ipify.org", "https://checkip.amazonaws.com" };
			IPAddress val = default(IPAddress);
			foreach (string text in array)
			{
				try
				{
					if (IPAddress.TryParse(ExternalIpClient.GetStringAsync(text).GetAwaiter().GetResult()?.Trim(), ref val) && (int)val.AddressFamily == 2)
					{
						string text2 = ((object)val).ToString();
						lock (ExternalIpGate)
						{
							_cachedExternalIPv4 = text2;
							_cachedExternalIPv4At = global::System.DateTime.UtcNow;
						}
						return text2;
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("[PortForward] External IP lookup failed at " + text + ": " + ex.Message);
				}
			}
			return "";
		}

		internal static void ApplyStreamNetworkMode()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (IsMediaMtxEnabled)
			{
				RemovePortForwardNatMapping();
				KillTunnel();
				TunnelUrl = null;
				RefreshBuiltInStreamUrls();
				return;
			}
			if (StreamServer == null)
			{
				RemovePortForwardNatMapping();
				RefreshBuiltInStreamUrls();
				return;
			}
			if (UseCloudflareTunnel)
			{
				RemovePortForwardNatMapping();
				bool flag = false;
				try
				{
					flag = _tunnelProcess != null && !_tunnelProcess.HasExited;
				}
				catch
				{
				}
				if (!flag)
				{
					object obj2 = <>c.<>9__261_0;
					if (obj2 == null)
					{
						Action val = delegate
						{
							StartTunnel();
						};
						<>c.<>9__261_0 = val;
						obj2 = (object)val;
					}
					global::System.Threading.Tasks.Task.Run((Action)obj2);
				}
			}
			else
			{
				KillTunnel();
				TunnelUrl = null;
				ApplyPortForwardNatMapping();
			}
			RefreshBuiltInStreamUrls();
		}

		internal static bool ApplyPortForwardNatMapping()
		{
			DesktopBuddyConfig config = Config;
			if (config == null || !config.GetValue(PortForwardUseNat) || UseCloudflareTunnel || IsMediaMtxEnabled)
			{
				RemovePortForwardNatMapping();
				return false;
			}
			string bestLocalIPv4Address = GetBestLocalIPv4Address();
			if (string.IsNullOrWhiteSpace(bestLocalIPv4Address))
			{
				Msg("[PortForward] UPnP/NAT mapping skipped: no local IPv4 address found");
				return false;
			}
			lock (NatMappingGate)
			{
				try
				{
					object upnpMappings = GetUpnpMappings();
					if (upnpMappings == null)
					{
						Msg("[PortForward] UPnP/NAT is not available on this system or router");
						return false;
					}
					TryRemoveUpnpMapping(upnpMappings);
					upnpMappings.GetType().InvokeMember("Add", (BindingFlags)256, (Binder)null, upnpMappings, new object[6] { 48080, "TCP", 48080, bestLocalIPv4Address, true, "DesktopBuddy" });
					_natMappingActive = true;
					Msg($"[PortForward] UPnP/NAT TCP {48080} -> {bestLocalIPv4Address}:{48080}");
					return true;
				}
				catch (global::System.Exception ex)
				{
					Msg("[PortForward] UPnP/NAT mapping failed: " + ex.GetBaseException().Message);
					return false;
				}
			}
		}

		internal static void RemovePortForwardNatMapping()
		{
			lock (NatMappingGate)
			{
				bool natMappingActive = _natMappingActive;
				try
				{
					object upnpMappings = GetUpnpMappings();
					if (upnpMappings != null)
					{
						TryRemoveUpnpMapping(upnpMappings);
					}
					if (natMappingActive)
					{
						Msg($"[PortForward] Removed UPnP/NAT TCP {48080}");
					}
				}
				catch (global::System.Exception ex)
				{
					if (natMappingActive)
					{
						Msg("[PortForward] UPnP/NAT removal failed: " + ex.GetBaseException().Message);
					}
				}
				finally
				{
					_natMappingActive = false;
				}
			}
		}

		internal static void RefreshBuiltInStreamUrls()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Expected O, but got Unknown
			Uri val = null;
			try
			{
				string builtInStreamBaseUrl = GetBuiltInStreamBaseUrl();
				if (!string.IsNullOrWhiteSpace(builtInStreamBaseUrl))
				{
					val = new Uri(builtInStreamBaseUrl);
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[PortForward] Stream base URL refresh failed: " + ex.Message);
			}
			Enumerator<DesktopSession> enumerator = ActiveSessions.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					DesktopSession current = enumerator.Current;
					if (current?.VideoTexture == null || ((ComponentBase<Component>)(object)current.VideoTexture).IsDestroyed || current.StreamId <= 0 || val == (Uri)null)
					{
						continue;
					}
					VideoTextureProvider vtp = current.VideoTexture;
					DesktopSession capturedSession = current;
					Uri newUrl = new Uri(val, $"/stream/{current.StreamId}");
					((Worker)vtp).World.RunInUpdates(0, (Action)delegate
					{
						if (vtp != null && !((ComponentBase<Component>)(object)vtp).IsDestroyed)
						{
							SetRemoteStreamUrl(capturedSession, newUrl, $"network base refresh streamId={capturedSession.StreamId}");
						}
					});
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			lock (_sharedStreams)
			{
				Enumerator<nint, SharedStream> enumerator2 = _sharedStreams.Values.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						SharedStream current2 = enumerator2.Current;
						if (current2 != null && current2.StreamId > 0 && !(val == (Uri)null))
						{
							current2.StreamUrl = new Uri(val, $"/stream/{current2.StreamId}");
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
		}

		private static object GetUpnpMappings()
		{
			global::System.Type typeFromProgID = global::System.Type.GetTypeFromProgID("HNetCfg.NATUPnP");
			if (typeFromProgID == (global::System.Type)null)
			{
				return null;
			}
			object obj = Activator.CreateInstance(typeFromProgID);
			return typeFromProgID.InvokeMember("StaticPortMappingCollection", (BindingFlags)4096, (Binder)null, obj, (object[])null);
		}

		private static void TryRemoveUpnpMapping(object mappings)
		{
			try
			{
				mappings.GetType().InvokeMember("Remove", (BindingFlags)256, (Binder)null, mappings, new object[2] { 48080, "TCP" });
			}
			catch
			{
			}
		}

		private static void CreateAdaptiveScreenLight(Slot root, DesktopSession session, nint hwnd, nint monitorHandle)
		{
			//IL_0033: 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)
			if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && session != null)
			{
				Slot obj = root.AddSlot("DesktopBuddyAdaptiveLight", true);
				obj.PersistentSelf = false;
				obj.LocalPosition = new float3(0f, 0f, GetAdaptiveLightZOffset(session));
				Light val = ((ContainerWorker<Component>)(object)obj).AttachComponent<Light>(true, (Action<Light>)null);
				((SyncField<LightType>)(object)val.LightType).Value = (LightType)0;
				((SyncField<float>)(object)val.Intensity).Value = 1f;
				((SyncField<float>)(object)val.Range).Value = 15f;
				((SyncField<ShadowType>)(object)val.ShadowType).Value = (ShadowType)2;
				((SyncField<float>)(object)val.ShadowStrength).Value = 1f;
				((SyncField<colorX>)(object)val.Color).Value = new colorX(1f, 1f, 1f, 1f, (ColorProfile)1);
				session.AdaptiveLight = val;
				session.AdaptiveLightSampler = new D3D11AverageColorSampler();
			}
		}

		private static void UpdateAdaptiveScreenLightPosition(DesktopSession session)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (session?.AdaptiveLight != null && !((ComponentBase<Component>)(object)session.AdaptiveLight).IsDestroyed)
			{
				((Component)session.AdaptiveLight).Slot.LocalPosition = new float3(0f, 0f, GetAdaptiveLightZOffset(session));
			}
		}

		private static float GetAdaptiveLightZOffset(DesktopSession session)
		{
			float scale = ((session != null && session.PanelCanvasScale > 0f) ? session.PanelCanvasScale : 1f);
			return GetCurvedPanelDepth(session?.PanelMesh, scale) + -0.02f;
		}

		private static void TryUpdateAdaptiveScreenLightFromGpuFrame(DesktopSession session, nint device, nint context, nint texture, int width, int height)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			if (session?.AdaptiveLight == null || ((ComponentBase<Component>)(object)session.AdaptiveLight).IsDestroyed || session.AdaptiveLightSampler == null || device == (nint)global::System.IntPtr.Zero || context == (nint)global::System.IntPtr.Zero || texture == (nint)global::System.IntPtr.Zero || width <= 0 || height <= 0)
			{
				return;
			}
			long timestamp = Stopwatch.GetTimestamp();
			long num = Interlocked.Read(ref session.AdaptiveLightLastSampleTicks);
			if (num != 0L && timestamp - num < AdaptiveLightSampleIntervalTicks)
			{
				return;
			}
			Interlocked.Exchange(ref session.AdaptiveLightLastSampleTicks, timestamp);
			colorX color;
			try
			{
				if (!session.AdaptiveLightSampler.TrySample(device, context, texture, width, height, out color))
				{
					return;
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[AdaptiveLight] GPU average sample failed: " + ex.Message);
				return;
			}
			Slot root = session.Root;
			if (root == null || ((ContainerWorker<Component>)(object)root).IsDestroyed)
			{
				return;
			}
			((Worker)root).World.RunInUpdates(0, (Action)delegate
			{
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				if (!session.Cleaned && !((ContainerWorker<Component>)(object)root).IsDestroyed && session.AdaptiveLight != null && !((ComponentBase<Component>)(object)session.AdaptiveLight).IsDestroyed)
				{
					((SyncField<colorX>)(object)session.AdaptiveLight.Color).Value = color;
				}
			});
		}

		private static void StartThrowDismissalTracker(Slot root, Grabbable grabbable, User localUser)
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			DesktopBuddyConfig config = Config;
			float3[] posHistory;
			floatQ[] rotHistory;
			double[] timeHistory;
			int histIdx;
			bool wasGrabbed;
			bool thrown;
			if (config == null || config.GetValue(ThrowToDestroy))
			{
				posHistory = (float3[])(object)new float3[5];
				rotHistory = (floatQ[])(object)new floatQ[5];
				timeHistory = new double[5];
				histIdx = 0;
				wasGrabbed = false;
				thrown = false;
				((Worker)root).World.RunInUpdates(1, new Action(ThrowTrackLoop));
			}
			void ThrowTrackLoop()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//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_0235: Unknown result type (might be due to invalid IL or missing references)
				//IL_023f: Expected O, but got Unknown
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0205: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				if (!(((ContainerWorker<Component>)(object)root).IsDestroyed || thrown))
				{
					bool isGrabbed = grabbable.IsGrabbed;
					if (isGrabbed)
					{
						int num = histIdx % 5;
						posHistory[num] = root.GlobalPosition;
						rotHistory[num] = root.GlobalRotation;
						timeHistory[num] = ((Worker)root).World.Time.WorldTime;
						histIdx++;
					}
					else if (wasGrabbed && histIdx >= 2)
					{
						int num2 = (histIdx - 1) % 5;
						int num3 = ((histIdx >= 5) ? (histIdx % 5) : 0);
						double num4 = timeHistory[num2] - timeHistory[num3];
						if (num4 > 0.001)
						{
							float3 val = (ref posHistory[num2]) - (ref posHistory[num3]);
							float3 linearVelocity = (ref val) / (float)num4;
							if (((float3)(ref linearVelocity)).Magnitude > 3f)
							{
								thrown = true;
								CharacterController obj = ((ContainerWorker<Component>)(object)root).AttachComponent<CharacterController>(true, (Action<CharacterController>)null);
								obj.SimulatingUser.Target = localUser;
								((SyncField<float3>)(object)obj.Gravity).Value = new float3(0f, -9.81f, 0f);
								((SyncField<float>)(object)obj.LinearDamping).Value = 0.3f;
								obj.LinearVelocity = linearVelocity;
								int num5 = (histIdx - 2 + 5) % 5;
								double num6 = timeHistory[num2] - timeHistory[num5];
								floatQ perFrameRot = floatQ.Identity;
								if (num6 > 0.001)
								{
									ref floatQ reference = ref rotHistory[num2];
									floatQ conjugated = ((floatQ)(ref rotHistory[num5])).Conjugated;
									floatQ val2 = (ref reference) * (ref conjugated);
									float num7 = 1f / 60f / (float)num6;
									floatQ identity = floatQ.Identity;
									perFrameRot = MathX.Slerp(ref identity, val2, num7);
								}
								StartThrowFade(root, perFrameRot);
								return;
							}
						}
						histIdx = 0;
					}
					wasGrabbed = isGrabbed;
					((Worker)root).World.RunInUpdates(isGrabbed ? 1 : 10, new Action(ThrowTrackLoop));
				}
			}
		}

		private static void StartThrowFade(Slot root, floatQ perFrameRot)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			double startTime = ((Worker)root).World.Time.WorldTime;
			float3 lastPos = root.GlobalPosition;
			int frameCount = 0;
			((Worker)root).World.RunInUpdates(1, new Action(FadeAndCollisionLoop));
			void FadeAndCollisionLoop()
			{
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: 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)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				if (!((ContainerWorker<Component>)(object)root).IsDestroyed)
				{
					frameCount++;
					float num = MathX.Clamp01((float)((((Worker)root).World.Time.WorldTime - startTime) / 1.0));
					float num2 = MathX.Lerp(1f, 0f, num * num);
					Slot obj = root;
					float3 val = float3.One;
					obj.LocalScale = (ref val) * MathX.Max(0.01f, num2);
					Slot obj2 = root;
					floatQ localRotation = root.LocalRotation;
					obj2.LocalRotation = (ref localRotation) * (ref perFrameRot);
					float3 globalPosition = root.GlobalPosition;
					if (frameCount > 5)
					{
						val = (ref globalPosition) - (ref lastPos);
						if (((float3)(ref val)).Magnitude < 0.001f)
						{
							root.Destroy();
							return;
						}
					}
					lastPos = globalPosition;
					if (num >= 1f)
					{
						root.Destroy();
					}
					else
					{
						((Worker)root).World.RunInUpdates(1, new Action(FadeAndCollisionLoop));
					}
				}
			}
		}

		private static RemoteStreamVisual BuildRemoteStream(RemoteStreamBuildContext context)
		{
			//IL_037e: 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_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			Slot root = context.Root;
			DesktopSession session = context.Session;
			if (!context.UseMediaMtx && StreamServer == null)
			{
				Msg($"[RemoteStream] Skipped: MediaMtx={IsMediaMtxEnabled} StreamServer={StreamServer != null} StreamBase={GetBuiltInStreamBaseUrl() ?? "null"}");
				return null;
			}
			try
			{
				SharedStream sharedStream = AcquireSharedStream(context.Hwnd, context.UseMediaMtx, context.LinuxPipeWireNodeId, context.Width, context.Height);
				session.StreamId = sharedStream.StreamId;
				session.Encoder = sharedStream.Encoder;
				session.StreamSource = sharedStream.Source;
				session.StreamUsesMediaMtx = sharedStream.UsesMediaMtx;
				session.StreamAudioCapture = sharedStream.Audio;
				session.StartStreamAudioCapture = sharedStream.StartAudio;
				FfmpegEncoder encoder = sharedStream.Encoder;
				ILiveStreamSource source = sharedStream.Source;
				if (session.SpatialAudioSource != null && sharedStream.Audio != null)
				{
					session.SpatialAudioSource.SetAudioCapture(sharedStream.Audio);
				}
				if (encoder != null && TryClaimSharedStreamDriver(context.Hwnd, sharedStream.StreamId, session))
				{
					ConnectEncoder(session, encoder, sharedStream.Audio, sharedStream.StartAudio);
					Msg($"[RemoteStream] This panel drives the encoder for stream {sharedStream.StreamId}");
				}
				else if (DesktopBuddyPlatform.IsLinux)
				{
					Msg($"[RemoteStream] Linux native stream owns capture for stream {sharedStream.StreamId}");
				}
				else
				{
					Msg($"[RemoteStream] This panel shares encoder from stream {sharedStream.StreamId}, no encoding hook");
				}
				Slot obj = root.AddSlot("StreamProvider", true);
				VideoTextureProvider val = TextureProviderSettings.ClampWrap<VideoTextureProvider>(((ContainerWorker<Component>)(object)obj).AttachComponent<VideoTextureProvider>(true, (Action<VideoTextureProvider>)null));
				((SyncField<bool>)(object)val.Stream).Value = true;
				((SyncField<Uri>)(object)val.URL).Value = null;
				((SyncField<float>)(object)val.Volume).Value = 1f;
				session.VideoTexture = val;
				Uri streamUrl = sharedStream.StreamUrl;
				AudioOutput val2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<AudioOutput>(true, (Action<AudioOutput>)null);
				((SyncRef<IWorldAudioDataSource>)(object)val2.Source).Target = (IWorldAudioDataSource)(object)val;
				((SyncField<float>)(object)val2.Volume).Value = context.StreamOutputVolume;
				((SyncField<bool?>)(object)val2.Global).Value = true;
				((SyncField<bool>)(object)val2.Spatialize).Value = false;
				((SyncField<float>)(object)val2.SpatialBlend).Value = 0f;
				((SyncField<AudioDistanceSpace>)(object)val2.DistanceSpace).Value = (AudioDistanceSpace)1;
				((SyncField<float>)(object)val2.DopplerLevel).Value = 0f;
				((SyncField<float>)(object)val2.Pitch).Value = 1f;
				((SyncField<bool>)(object)val2.IgnoreAudioEffects).Value = true;
				((SyncField<AudioTypeGroup>)(object)val2.AudioTypeGroup).Value = (AudioTypeGroup)1;
				session.StreamAudioOutput = val2;
				ApplyStreamAudioSettings(session);
				ValueDriver<float> obj2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueDriver<float>>(true, (Action<ValueDriver<float>>)null);
				((SyncRef<IField<float>>)(object)obj2.DriveTarget).Target = (IField<float>)(object)val2.Volume;
				obj2.ValueSource.Target = (IValue<float>)(object)context.VolumeSlider.Value;
				if (session.SpatialAudioOutput != null)
				{
					AudioOutput spatialOut = session.SpatialAudioOutput;
					((SyncField<float>)(object)context.VolumeSlider.Value).OnValueChange += delegate(SyncField<float> field)
					{
						if (spatialOut != null && !((ComponentBase<Component>)(object)spatialOut).IsDestroyed)
						{
							((SyncField<float>)(object)spatialOut.Volume).Value = field.Value;
						}
					};
				}
				Slot val3 = root.AddSlot("RemoteStreamVisual", true);
				float3 one = float3.One;
				val3.LocalScale = (ref one) * context.CanvasScale;
				ValueUserOverride<bool> val4 = ((ContainerWorker<Component>)(object)val3).AttachComponent<ValueUserOverride<bool>>(true, (Action<ValueUserOverride<bool>>)null);
				((SyncRef<IField<bool>>)(object)val4.Target).Target = (IField<bool>)(object)val3.ActiveSelf_Field;
				((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).Default).Value = true;
				((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).CreateOverrideOnWrite).Value = false;
				((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).ClearOnUserLeave).Value = true;
				((ValueOverrideBase<bool>)(object)val4).SetOverride(((Worker)root).World.LocalUser, false);
				session.StreamVisualAllowed = val4;
				Msg("[RemoteStream] Per-user culling gate controls stream visibility and playback");
				CreateViewerCullingGate(session, val3, val, ((Worker)root).World.LocalUser);
				CurvedPlaneMesh val5 = AddCurvedTexturePlane(val3, "VideoTextureCurvedPlane", context.Width, context.Height, 1f, (IAssetProvider<ITexture2D>)(object)val, 0f, flipY: false, -100f);
				((SyncField<float>)(object)val5.Curvature).Value = MathX.Clamp(context.CurrentPanelCurvature.Invoke(), 0f, 1f);
				Canvas val6 = ((ContainerWorker<Component>)(object)val3).AttachComponent<Canvas>(true, (Action<Canvas>)null);
				((ComponentBase<Component>)(object)val6.Collider.RawTarget).Enabled = false;
				((SyncField<float2>)(object)val6.Size).Value = new float2((float)context.Width, (float)context.Height);
				UIBuilder val7 = new UIBuilder(val6);
				colorX val8 = new colorX(0f, 0f, 0f, 1f, (ColorProfile)1);
				Image val9 = val7.Image(ref val8, false);
				((SyncField<colorX>)(object)val9.Tint).Value = colorX.Clear;
				((SyncField<bool>)(object)((ImageBase)val9).InteractionTarget).Value = false;
				val7.NestInto(((UIComponent)val9).RectTransform);
				RawImage obj3 = val7.RawImage((IAssetProvider<ITexture2D>)(object)val, false);
				((SyncField<colorX>)(object)obj3.Tint).Value = new colorX(1f, 1f, 1f, 0f, (ColorProfile)1);
				UI_UnlitMaterial val10 = ((ContainerWorker<Component>)(object)val3).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
				((SyncField<BlendMode>)(object)val10.BlendMode).Value = (BlendMode)2;
				((SyncField<ZWrite>)(object)val10.ZWrite).Value = (ZWrite)2;
				((SyncField<float>)(object)val10.OffsetUnits).Value = -100f;
				((SyncRef<IAssetProvider<Material>>)(object)obj3.Material).Target = (IAssetProvider<Material>)(object)val10;
				Msg($"[RemoteStream] Created, URL={streamUrl}, streamId={sharedStream.StreamId}, refs={sharedStream.RefCount}");
				ScheduleRemoteStreamBinding(root, session, val, source, streamUrl, sharedStream.StreamId, context.IsPrivate);
				ScheduleRemoteStreamPlaybackWatch(root, session, val, sharedStream.StreamId);
				return new RemoteStreamVisual
				{
					VideoTexture = val,
					StreamPlane = val5,
					StreamCanvas = val6
				};
			}
			catch (global::System.Exception ex)
			{
				Msg($"[RemoteStream] ERROR: {ex}");
				return null;
			}
		}

		private static void ScheduleRemoteStreamBinding(Slot root, DesktopSession session, VideoTextureProvider videoTex, ILiveStreamSource streamSource, Uri streamUrl, int streamId, Func<bool> isPrivate)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			((Worker)root).World.RunInUpdates(1, (Action)delegate
			{
				BindStreamUrlWhenReady(0);
			});
			void BindStreamUrlWhenReady(int attempt)
			{
				//IL_0299: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a3: Expected O, but got Unknown
				//IL_029e: Unknown result type (might be due to invalid IL or missing references)
				if (videoTex != null && !((ComponentBase<Component>)(object)videoTex).IsDestroyed && !((ContainerWorker<Component>)(object)root).IsDestroyed)
				{
					bool flag = streamSource?.IsRunning ?? false;
					bool flag2 = isPrivate.Invoke();
					Uri val = streamUrl ?? GetBuiltInStreamUrl(streamId);
					if (flag && !flag2 && val != (Uri)null)
					{
						SetRemoteStreamUrl(session, val, $"initial bind streamId={streamId}");
						Msg($"[RemoteStream] URL bound after stream readiness: attempt={attempt} streamId={streamId} {streamSource.ReadableStreamState}");
					}
					else if (attempt >= 300)
					{
						Msg($"[RemoteStream] URL not bound: ready={flag}, urlReady={val != (Uri)null}, private={flag2}, streamId={streamId}, {streamSource?.ReadableStreamState ?? "no source"}");
					}
					else
					{
						if (attempt == 0 || attempt % 30 == 0)
						{
							Msg($"[RemoteStream] Waiting before URL bind: attempt={attempt}, ready={flag}, urlReady={val != (Uri)null}, private={flag2}, {streamSource?.ReadableStreamState ?? "no source"}");
						}
						((Worker)root).World.RunInUpdates(6, (Action)delegate
						{
							BindStreamUrlWhenReady(attempt + 1);
						});
					}
				}
			}
		}

		private static void ScheduleRemoteStreamPlaybackWatch(Slot root, DesktopSession session, VideoTextureProvider videoTex, int streamId)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			int checkCount = 0;
			bool loggedPlaybackReady = false;
			bool streamUrlBound = false;
			((Worker)root).World.RunInUpdates(30, (Action)delegate
			{
				CheckVideoState();
			});
			void CheckVideoState()
			{
				//IL_0188: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Expected O, but got Unknown
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Expected O, but got Unknown
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				if (videoTex != null && !((ComponentBase<Component>)(object)videoTex).IsDestroyed && !((ContainerWorker<Component>)(object)root).IsDestroyed)
				{
					checkCount++;
					bool isAssetAvailable = ((AssetProvider<VideoTexture>)(object)videoTex).IsAssetAvailable;
					string text = videoTex.CurrentPlaybackEngine?.Value ?? "null";
					bool isPlaying = videoTex.IsPlaying;
					float num = videoTex.CurrentClockError?.Value ?? (-1f);
					streamUrlBound = session.StreamUrl != (Uri)null || streamUrlBound;
					if (isAssetAvailable && !loggedPlaybackReady)
					{
						loggedPlaybackReady = true;
						Msg($"[RemoteStream] Playback ready: streamId={streamId} engine={text}");
					}
					if (streamUrlBound && isAssetAvailable && !isPlaying && IsLocalStreamPlaybackAllowedNow(session))
					{
						videoTex.Play();
						Msg($"[RemoteStream] Restarted VideoTextureProvider playback streamId={streamId} clockErr={num:F2}");
					}
					if (checkCount < 10)
					{
						((Worker)root).World.RunInUpdates(60, (Action)delegate
						{
							CheckVideoState();
						});
					}
					else if (checkCount < 30)
					{
						((Worker)root).World.RunInUpdates(1800, (Action)delegate
						{
							CheckVideoState();
						});
					}
				}
			}
		}

		internal static void SpawnStreaming(World world, nint hwnd, string title, nint monitorHandle = 0, int monitorIndex = -1, bool startPrivate = false)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Msg($"[SpawnStreaming] Starting for '{title}' hwnd={hwnd} monitorIndex={monitorIndex} startPrivate={startPrivate}");
				if (hwnd != (nint)global::System.IntPtr.Zero)
				{
					WindowEnumerator.GetWindowThreadProcessId(hwnd, out var lpdwProcessId);
					if (!WindowEnumerator.TryValidateStandaloneProcessWindow(hwnd, lpdwProcessId, out var title2, out var reason))
					{
						Msg($"[SpawnStreaming] Ignored hwnd={hwnd}: {reason}");
						return;
					}
					if (!string.IsNullOrWhiteSpace(title2))
					{
						title = title2;
					}
				}
				User localUser = world.LocalUser;
				if (localUser == null)
				{
					Msg("[SpawnStreaming] LocalUser is null, aborting");
					return;
				}
				UserRoot root = localUser.Root;
				if (root == null)
				{
					Msg("[SpawnStreaming] UserRoot is null, aborting");
					return;
				}
				Slot val = (((Component)localUser.Root).Slot.Parent ?? world.RootSlot).AddSlot("Desktop Buddy", true);
				float3 headPosition = root.HeadPosition;
				floatQ headRotation = root.HeadRotation;
				float3 forward = float3.Forward;
				float3 val2 = (ref headRotation) * (ref forward);
				float userSpawnScale = GetUserSpawnScale(root);
				forward = float3.One;
				val.LocalScale = (ref forward) * userSpawnScale;
				forward = (ref val2) * (0.8f * userSpawnScale);
				val.GlobalPosition = (ref headPosition) + (ref forward);
				forward = float3.Up;
				val.GlobalRotation = floatQ.LookRotation(ref val2, ref forward);
				((ContainerWorker<Component>)(object)val).AttachComponent<DestroyOnUserLeave>(true, (Action<DestroyOnUserLeave>)null).TargetUser.Target = localUser;
				Msg($"[SpawnStreaming] Slot created at pos={val.GlobalPosition} userScale={userSpawnScale}");
				StartStreaming(val, hwnd, title, monitorHandle, monitorIndex, startPrivate);
			}
			catch (global::System.Exception ex)
			{
				Msg($"ERROR in SpawnStreaming: {ex}");
			}
		}

		private static float GetUserSpawnScale(UserRoot userRoot)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0046: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				float3? obj;
				if (userRoot == null)
				{
					obj = null;
				}
				else
				{
					Slot slot = ((Component)userRoot).Slot;
					obj = ((slot != null) ? new float3?(slot.GlobalScale) : ((float3?)null));
				}
				float3 val = (float3)(((??)obj) ?? float3.One);
				float num = MathF.Max(val.x, MathF.Max(val.y, val.z));
				return (float.IsFinite(num) && num > 0.001f) ? num : 1f;
			}
			catch (global::System.Exception ex)
			{
				Msg("[SpawnStreaming] Failed to read user scale, using 1: " + ex.Message);
				return 1f;
			}
		}

		private static void StartStreaming(Slot root, nint hwnd, string title, nint monitorHandle = 0, int monitorIndex = -1, bool startPrivate = false)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			Msg($"[StartStreaming] Window: {title} (hwnd={hwnd} monitorIndex={monitorIndex})");
			if (!DesktopBuddyPlatform.IsLinux)
			{
				WindowInput.RestoreIfMinimized(hwnd);
			}
			DesktopStreamer streamer = new DesktopStreamer(hwnd, monitorHandle);
			World world = ((Worker)root).World;
			Action val = default(Action);
			Action val4 = default(Action);
			Action val6 = default(Action);
			global::System.Threading.Tasks.Task.Run((Action)delegate
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Expected O, but got Unknown
				//IL_0083: Expected O, but got Unknown
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				//IL_0052: Expected O, but got Unknown
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0115: Expected O, but got Unknown
				//IL_011a: Expected O, but got Unknown
				try
				{
					if (!streamer.TryInitialCapture())
					{
						Msg("[StartStreaming] Failed initial capture for: " + title);
						streamer.Dispose();
						World obj = world;
						Action obj2 = val;
						if (obj2 == null)
						{
							Action val2 = delegate
							{
								try
								{
									if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed)
									{
										root.Destroy();
									}
								}
								catch (global::System.Exception ex4)
								{
									Msg($"[StartStreaming] Failed-capture destroy error: {ex4}");
								}
							};
							Action val3 = val2;
							val = val2;
							obj2 = val3;
						}
						obj.RunInUpdates(0, obj2);
					}
					else
					{
						World obj3 = world;
						Action obj4 = val4;
						if (obj4 == null)
						{
							Action val5 = delegate
							{
								try
								{
									FinishStartStreaming(root, hwnd, title, streamer, monitorIndex, startPrivate);
								}
								catch (global::System.Exception ex4)
								{
									Msg($"[StartStreaming] FinishStartStreaming callback error: {ex4}");
									try
									{
										streamer.Dispose();
									}
									catch (global::System.Exception ex5)
									{
										Msg($"[StartStreaming] Streamer dispose after finish error: {ex5}");
									}
									try
									{
										if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed)
										{
											root.Destroy();
										}
									}
									catch (global::System.Exception ex6)
									{
										Msg($"[StartStreaming] Root destroy after finish error: {ex6}");
									}
								}
							};
							Action val3 = val5;
							val4 = val5;
							obj4 = val3;
						}
						obj3.RunInUpdates(0, obj4);
					}
				}
				catch (global::System.Exception ex)
				{
					Msg($"[StartStreaming] Background capture task error: {ex}");
					try
					{
						streamer.Dispose();
					}
					catch (global::System.Exception ex2)
					{
						Msg($"[StartStreaming] Streamer dispose after task error: {ex2}");
					}
					try
					{
						World obj5 = world;
						Action obj6 = val6;
						if (obj6 == null)
						{
							Action val7 = delegate
							{
								try
								{
									if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed)
									{
										root.Destroy();
									}
								}
								catch (global::System.Exception ex4)
								{
									Msg($"[StartStreaming] Root destroy after task error: {ex4}");
								}
							};
							Action val3 = val7;
							val6 = val7;
							obj6 = val3;
						}
						obj5.RunInUpdates(0, obj6);
					}
					catch (global::System.Exception ex3)
					{
						Msg($"[StartStreaming] Failed to schedule cleanup after task error: {ex3}");
					}
				}
			});
		}

		private static void FinishStartStreaming(Slot root, nint hwnd, string title, DesktopStreamer streamer, int monitorIndex = -1, bool startPrivate = false)
		{
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			//IL_0832: Unknown result type (might be due to invalid IL or missing references)
			//IL_08af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0946: Unknown result type (might be due to invalid IL or missing references)
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c98: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cc5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d7a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d81: Expected O, but got Unknown
			//IL_0e16: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e7b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e82: Expected O, but got Unknown
			//IL_0e9a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e9f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f07: Unknown result type (might be due to invalid IL or missing references)
			//IL_106e: Unknown result type (might be due to invalid IL or missing references)
			//IL_10f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_10ff: Expected O, but got Unknown
			//IL_115a: Unknown result type (might be due to invalid IL or missing references)
			//IL_1164: Expected O, but got Unknown
			//IL_115f: Unknown result type (might be due to invalid IL or missing references)
			//IL_123a: Unknown result type (might be due to invalid IL or missing references)
			//IL_123f: Unknown result type (might be due to invalid IL or missing references)
			//IL_12d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_12df: Expected O, but got Unknown
			//IL_1391: Unknown result type (might be due to invalid IL or missing references)
			//IL_1396: Unknown result type (might be due to invalid IL or missing references)
			//IL_13bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_13c7: Expected O, but got Unknown
			//IL_1435: Unknown result type (might be due to invalid IL or missing references)
			//IL_143a: Unknown result type (might be due to invalid IL or missing references)
			//IL_14d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_14d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_155e: Unknown result type (might be due to invalid IL or missing references)
			//IL_1563: Unknown result type (might be due to invalid IL or missing references)
			//IL_1585: Unknown result type (might be due to invalid IL or missing references)
			//IL_158a: Unknown result type (might be due to invalid IL or missing references)
			//IL_15ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_15b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1626: Unknown result type (might be due to invalid IL or missing references)
			//IL_162b: Unknown result type (might be due to invalid IL or missing references)
			//IL_16b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_16b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_172d: Unknown result type (might be due to invalid IL or missing references)
			//IL_1732: Unknown result type (might be due to invalid IL or missing references)
			//IL_17a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_17ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_1867: Unknown result type (might be due to invalid IL or missing references)
			//IL_186e: Expected O, but got Unknown
			//IL_18c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_18d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_18e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a64: Unknown result type (might be due to invalid IL or missing references)
			//IL_1a69: Unknown result type (might be due to invalid IL or missing references)
			//IL_1aa6: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b23: Unknown result type (might be due to invalid IL or missing references)
			//IL_1b2a: Expected O, but got Unknown
			//IL_1c04: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c15: Unknown result type (might be due to invalid IL or missing references)
			//IL_1c26: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f21: Unknown result type (might be due to invalid IL or missing references)
			//IL_1f2b: Expected O, but got Unknown
			//IL_1f26: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e7f: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e8c: Unknown result type (might be due to invalid IL or missing references)
			//IL_1e99: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ea5: Unknown result type (might be due to invalid IL or missing references)
			//IL_1ff4: Unknown result type (might be due to invalid IL or missing references)
			//IL_2008: Unknown result type (might be due to invalid IL or missing references)
			//IL_2054: Unknown result type (might be due to invalid IL or missing references)
			//IL_205e: Expected O, but got Unknown
			//IL_2059: Unknown result type (might be due to invalid IL or missing references)
			//IL_2084: Unknown result type (might be due to invalid IL or missing references)
			//IL_208e: Expected O, but got Unknown
			//IL_20a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_20ac: Expected O, but got Unknown
			//IL_20b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_20c3: Expected O, but got Unknown
			//IL_20e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_20e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_20f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_2101: Expected O, but got Unknown
			//IL_21d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_21dd: Expected O, but got Unknown
			//IL_22f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_2303: Expected O, but got Unknown
			//IL_22fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_23ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_23d8: Expected O, but got Unknown
			//IL_22d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_22da: Expected O, but got Unknown
			//IL_2411: Unknown result type (might be due to invalid IL or missing references)
			//IL_241b: Expected O, but got Unknown
			if (root == null || ((ContainerWorker<Component>)(object)root).IsDestroyed)
			{
				Msg("[StartStreaming] Root slot destroyed before capture completed: " + title);
				streamer.Dispose();
				return;
			}
			int w = streamer.Width;
			int h = streamer.Height;
			Grabbable grabbable = null;
			Msg($"[StartStreaming] Capture size: {w}x{h}");
			float canvasScale = 0.0005f;
			float worldHalfH = (float)h / 2f * canvasScale;
			float worldHalfW = (float)w / 2f * canvasScale;
			BoxCollider collider = null;
			Msg("[StartStreaming] Panel grab/click colliders are curved mesh colliders");
			CurvedPlaneMesh frontPlaneRef = null;
			CurvedPlaneMesh backPlaneRef = null;
			CurvedPlaneMesh streamPlaneRef = null;
			CurvedPlaneMesh topBarStripRef = null;
			CurvedPlaneMesh topBarBackStripRef = null;
			DesktopUVRayExit displayRayExitRef = null;
			TextRenderer titleText = null;
			Slot deviceIndicatorsSlot = null;
			string panelCurvePreferenceKey = GetPanelCurvePreferenceKey(hwnd);
			float currentPanelCurvature = GetPanelCurvePreference(panelCurvePreferenceKey, 0.18f);
			DesktopSession session = null;
			Slot displaySlot = root.AddLocalSlot("Display", false);
			Slot obj = displaySlot;
			float3 one = float3.One;
			obj.LocalScale = (ref one) * canvasScale;
			Msg("[StartStreaming] Display slot (local) created");
			DesktopTextureProvider val = TextureProviderSettings.ClampWrap<DesktopTextureProvider>(((ContainerWorker<Component>)(object)displaySlot.AddSlot("Texture", true)).AttachComponent<DesktopTextureProvider>(true, (Action<DesktopTextureProvider>)null));
			((SyncField<int>)(object)val.DisplayIndex).Value = -2147483648;
			OurProviders.Add(val);
			int sharedTextureSlot = -1;
			int num = -1;
			bool flag = TextureBridgeChannel != null && TextureBridgeChannel.IsOpen && (DesktopBuddyPlatform.IsLinux || hwnd != (nint)global::System.IntPtr.Zero || streamer.MonitorHandle != (nint)global::System.IntPtr.Zero || monitorIndex >= 0);
			if (flag)
			{
				Msg("[StartStreaming] Shared texture bridge registration deferred until first current-size frame");
			}
			else if (hwnd == (nint)global::System.IntPtr.Zero && monitorIndex >= 0)
			{
				((SyncField<int>)(object)val.DisplayIndex).Value = monitorIndex;
				Msg($"[StartStreaming] WARNING: Shared texture bridge unavailable; falling back to built-in monitor DisplayIndex={monitorIndex}");
			}
			else
			{
				Msg($"[StartStreaming] WARNING: Cannot set up texture (hwnd={hwnd}, monitorIndex={monitorIndex}, bridge={TextureBridgeChannel?.IsOpen ?? false})");
			}
			Msg("[StartStreaming] Texture component created");
			Slot obj2 = displaySlot.AddSlot("InteractionCanvas", true);
			obj2.LocalScale = float3.One;
			Canvas val2 = ((ContainerWorker<Component>)(object)obj2).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			((SyncField<float2>)(object)val2.Size).Value = new float2((float)w, (float)h);
			UIBuilder ui = new UIBuilder(val2);
			((ComponentBase<Component>)(object)ui.Canvas.Collider.RawTarget).Enabled = false;
			UIBuilder obj3 = ui;
			colorX val3 = new colorX(0f, 0f, 0f, 1f, (ColorProfile)1);
			Image val4 = obj3.Image(ref val3, false);
			((SyncField<colorX>)(object)val4.Tint).Value = colorX.Clear;
			((SyncField<bool>)(object)((ImageBase)val4).InteractionTarget).Value = false;
			ui.NestInto(((UIComponent)val4).RectTransform);
			Msg("[StartStreaming] Interaction canvas created");
			Slot val5 = obj2.AddSlot("InteractionCamera", true);
			val5.LocalPosition = float3.Zero;
			val5.LocalRotation = floatQ.Identity;
			displayRayExitRef = ((ContainerWorker<Component>)(object)val5).AttachComponent<DesktopUVRayExit>(true, (Action<DesktopUVRayExit>)null);
			displayRayExitRef.Size = new float2((float)w, (float)h);
			frontPlaneRef = AddCurvedTexturePlane(displaySlot, "FrontCurvedPlane", w, h, 1f, (IAssetProvider<ITexture2D>)(object)val, 0f, flipY: true, 100f);
			ApplyPanelCurvature(currentPanelCurvature);
			uint processId = 0u;
			if (!DesktopBuddyPlatform.IsLinux)
			{
				WindowEnumerator.GetWindowThreadProcessId(hwnd, out processId);
			}
			Msg($"[StartStreaming] Process ID: {processId}");
			HashSet<nint> seenRelatedHwnds = new HashSet<nint>();
			DesktopSession obj4 = new DesktopSession
			{
				Streamer = streamer,
				LinuxInputSessionId = streamer.LinuxInputSessionId,
				Texture = val,
				Canvas = ui.Canvas,
				Root = root,
				Hwnd = hwnd,
				ProcessId = processId,
				Collider = collider,
				UseTextureBridge = flag,
				BridgeRegistrationPending = flag,
				SharedTextureSlot = sharedTextureSlot,
				PendingBridgeDisplayIndex = num,
				BridgeDisplayIndexApplied = (num < 0),
				LastKnownW = w,
				LastKnownH = h,
				PanelMesh = frontPlaneRef,
				PanelCanvasScale = canvasScale
			};
			User localUser = ((Worker)root).World.LocalUser;
			obj4.OwnerUserId = ((localUser != null) ? localUser.UserID : null);
			obj4.SeenRelatedHwnds = seenRelatedHwnds;
			session = obj4;
			ActiveSessions.Add(session);
			root.Destroyed += delegate
			{
				CleanupAndRemoveSession(session, "root destroyed");
			};
			DesktopBuddyConfig config = Config;
			if (config != null && config.GetValue(DynamicLightsEnabled))
			{
				CreateAdaptiveScreenLight(root, session, hwnd, streamer.MonitorHandle);
			}
			DesktopCanvasIds.Add(((Worker)ui.Canvas).ReferenceID);
			Msg($"[StartStreaming] Registered canvas {((Worker)ui.Canvas).ReferenceID} for locomotion suppression");
			DesktopInputWiring.Wire(root, hwnd, streamer, session, frontPlaneRef, () => grabbable);
			float barH = 60f;
			float barMarginBottom = 12f * canvasScale;
			float num2 = 7f;
			float num3 = 8f;
			float num4 = 46f;
			int num5 = Math.Max(1, w);
			int num6 = Interlocked.Increment(ref _nextTopBarRenderHostId);
			Slot barRenderHost = root.AddSlot($"DesktopBuddyTopBarRenderHost {num6}", false);
			session.TopBarRenderHost = barRenderHost;
			barRenderHost.PersistentSelf = false;
			((ContainerWorker<Component>)(object)barRenderHost).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Msg($"[TopBar] Render host created under buddy root id={num6}");
			root.Destroyed += delegate
			{
				if (barRenderHost != null && !((ContainerWorker<Component>)(object)barRenderHost).IsDestroyed)
				{
					barRenderHost.Destroy();
				}
			};
			Slot val6 = barRenderHost.AddSlot("TopBarRender", true);
			((ContainerWorker<Component>)(object)val6).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Slot val7 = barRenderHost.AddSlot("TopBarBackRender", true);
			((ContainerWorker<Component>)(object)val7).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Slot val8 = barRenderHost.AddSlot("TopBarCamera", true);
			val8.LocalPosition = new float3(0f, 0f, -1f);
			RenderTextureProvider barRenderTex = ((ContainerWorker<Component>)(object)val8).AttachComponent<RenderTextureProvider>(true, (Action<RenderTextureProvider>)null);
			((SyncField<int2>)(object)barRenderTex.Size).Value = new int2(num5, (int)barH);
			((SyncField<TextureWrapMode>)(object)barRenderTex.WrapModeU).Value = (TextureWrapMode)1;
			((SyncField<TextureWrapMode>)(object)barRenderTex.WrapModeV).Value = (TextureWrapMode)1;
			Camera val9 = ((ContainerWorker<Component>)(object)val8).AttachComponent<Camera>(true, (Action<Camera>)null);
			((SyncField<CameraProjection>)(object)val9.Projection).Value = (CameraProjection)1;
			((SyncField<float>)(object)val9.OrthographicSize).Value = barH * 0.5f;
			((SyncField<bool>)(object)val9.UseTransformScale).Value = true;
			((SyncField<CameraClearMode>)(object)val9.Clear).Value = (CameraClearMode)1;
			((SyncField<colorX>)(object)val9.ClearColor).Value = colorX.Clear;
			((SyncField<float>)(object)val9.NearClipping).Value = 0.01f;
			((SyncField<float>)(object)val9.FarClipping).Value = 4f;
			((SyncField<bool>)(object)val9.Postprocessing).Value = false;
			((SyncField<bool>)(object)val9.RenderShadows).Value = false;
			((SyncField<bool>)(object)val9.ForwardOnly).Value = true;
			((SyncRef<IAssetProvider<RenderTexture>>)(object)val9.RenderTexture).Target = (IAssetProvider<RenderTexture>)(object)barRenderTex;
			val9.SelectiveRender.Add(val6);
			Slot val10 = barRenderHost.AddSlot("TopBarBackCamera", true);
			val10.LocalPosition = new float3(0f, 0f, -1f);
			RenderTextureProvider barBackRenderTex = ((ContainerWorker<Component>)(object)val10).AttachComponent<RenderTextureProvider>(true, (Action<RenderTextureProvider>)null);
			((SyncField<int2>)(object)barBackRenderTex.Size).Value = new int2(num5, (int)barH);
			((SyncField<TextureWrapMode>)(object)barBackRenderTex.WrapModeU).Value = (TextureWrapMode)1;
			((SyncField<TextureWrapMode>)(object)barBackRenderTex.WrapModeV).Value = (TextureWrapMode)1;
			Camera obj5 = ((ContainerWorker<Component>)(object)val10).AttachComponent<Camera>(true, (Action<Camera>)null);
			((SyncField<CameraProjection>)(object)obj5.Projection).Value = (CameraProjection)1;
			((SyncField<float>)(object)obj5.OrthographicSize).Value = barH * 0.5f;
			((SyncField<bool>)(object)obj5.UseTransformScale).Value = true;
			((SyncField<CameraClearMode>)(object)obj5.Clear).Value = (CameraClearMode)1;
			((SyncField<colorX>)(object)obj5.ClearColor).Value = colorX.Clear;
			((SyncField<float>)(object)obj5.NearClipping).Value = 0.01f;
			((SyncField<float>)(object)obj5.FarClipping).Value = 4f;
			((SyncField<bool>)(object)obj5.Postprocessing).Value = false;
			((SyncField<bool>)(object)obj5.RenderShadows).Value = false;
			((SyncField<bool>)(object)obj5.ForwardOnly).Value = true;
			((SyncRef<IAssetProvider<RenderTexture>>)(object)obj5.RenderTexture).Target = (IAssetProvider<RenderTexture>)(object)barBackRenderTex;
			obj5.SelectiveRender.Add(val7);
			Slot barSlot = val6.AddSlot("TopBar", true);
			barSlot.LocalScale = float3.One;
			Canvas barCanvas = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			((SyncField<float2>)(object)barCanvas.Size).Value = new float2((float)num5, barH);
			((Collider)barCanvas.Collider.Target).SetTrigger();
			UI_UnlitMaterial val11 = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<BlendMode>)(object)val11.BlendMode).Value = (BlendMode)2;
			((SyncField<ZWrite>)(object)val11.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)val11.OffsetUnits).Value = 500f;
			UI_UnlitMaterial barElementMat = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<BlendMode>)(object)barElementMat.BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)barElementMat.Sidedness).Value = (Sidedness)1;
			((SyncField<ZWrite>)(object)barElementMat.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)barElementMat.OffsetFactor).Value = -1f;
			((SyncField<float>)(object)barElementMat.OffsetUnits).Value = -500f;
			UI_UnlitMaterial val12 = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<BlendMode>)(object)val12.BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)val12.Sidedness).Value = (Sidedness)1;
			((SyncField<ZWrite>)(object)val12.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)val12.OffsetFactor).Value = -1f;
			((SyncField<float>)(object)val12.OffsetUnits).Value = -1000f;
			UI_UnlitMaterial val13 = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<BlendMode>)(object)val13.BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)val13.Sidedness).Value = (Sidedness)1;
			((SyncField<ZWrite>)(object)val13.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)val13.OffsetFactor).Value = -1f;
			((SyncField<float>)(object)val13.OffsetUnits).Value = -1500f;
			UI_TextUnlitMaterial barTextMat = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<UI_TextUnlitMaterial>(true, (Action<UI_TextUnlitMaterial>)null);
			((SyncField<BlendMode>)(object)((TextUnlitMaterial)barTextMat).BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)((TextUnlitMaterial)barTextMat).Sidedness).Value = (Sidedness)1;
			((SyncField<ZWrite>)(object)((TextUnlitMaterial)barTextMat).ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)((TextUnlitMaterial)barTextMat).OffsetFactor).Value = -1f;
			((SyncField<float>)(object)((TextUnlitMaterial)barTextMat).OffsetUnits).Value = -2000f;
			Slot val14 = val7.AddSlot("TopBarBackPanel", true);
			val14.LocalScale = float3.One;
			Canvas barBackCanvas = ((ContainerWorker<Component>)(object)val14).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			((SyncField<float2>)(object)barBackCanvas.Size).Value = new float2((float)num5, barH);
			((ComponentBase<Component>)(object)barBackCanvas.Collider.RawTarget).Enabled = false;
			UI_UnlitMaterial val15 = ((ContainerWorker<Component>)(object)val14).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<BlendMode>)(object)val15.BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)val15.Sidedness).Value = (Sidedness)3;
			((SyncField<ZWrite>)(object)val15.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)val15.OffsetUnits).Value = 500f;
			UI_TextUnlitMaterial obj6 = ((ContainerWorker<Component>)(object)val14).AttachComponent<UI_TextUnlitMaterial>(true, (Action<UI_TextUnlitMaterial>)null);
			((SyncField<BlendMode>)(object)((TextUnlitMaterial)obj6).BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)((TextUnlitMaterial)obj6).Sidedness).Value = (Sidedness)3;
			((SyncField<ZWrite>)(object)((TextUnlitMaterial)obj6).ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)((TextUnlitMaterial)obj6).OffsetFactor).Value = -1f;
			((SyncField<float>)(object)((TextUnlitMaterial)obj6).OffsetUnits).Value = -2000f;
			UIBuilder val16 = new UIBuilder(barCanvas);
			colorX value = default(colorX);
			((colorX)(ref value))..ctor(0.055f, 0.06f, 0.08f, 0.8f, (ColorProfile)1);
			Image barBg = val16.Image(ref value, false);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)barBg).Material).Target = (IAssetProvider<Material>)(object)val11;
			SpriteProvider roundedSprite = TextureProviderSettings.ClampWrap<SpriteProvider>(((ContainerWorker<Component>)(object)barSlot).AttachComponent<SpriteProvider>(true, (Action<SpriteProvider>)null));
			((SyncRef<IAssetProvider<ITexture2D>>)(object)roundedSprite.Texture).Target = UIBuilder.GetCircleTexture(((Worker)root).World);
			((SyncField<float4>)(object)roundedSprite.Borders).Value = new float4(0.49f, 0.49f, 0.49f, 0.49f);
			((SyncField<float>)(object)roundedSprite.FixedSize).Value = barH * 0.5f;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)barBg).Sprite).Target = (IAssetProvider<Sprite>)(object)roundedSprite;
			((SyncField<NineSliceSizing>)(object)((ImageBase)barBg).NineSliceSizing).Value = (NineSliceSizing)0;
			((SyncField<colorX>)(object)barBg.Tint).Value = value;
			UIBuilder val17 = new UIBuilder(barBackCanvas);
			val3 = new colorX(0.08f, 0.08f, 0.1f, 1f, (ColorProfile)1);
			Image barBackBg = val17.Image(ref val3, false);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)barBackBg).Material).Target = (IAssetProvider<Material>)(object)val15;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)barBackBg).Sprite).Target = (IAssetProvider<Sprite>)(object)roundedSprite;
			((SyncField<NineSliceSizing>)(object)((ImageBase)barBackBg).NineSliceSizing).Value = (NineSliceSizing)0;
			((SyncField<colorX>)(object)barBackBg.Tint).Value = new colorX(0.055f, 0.06f, 0.08f, 0.8f, (ColorProfile)1);
			((SyncField<bool>)(object)((ContainerWorker<Component>)(object)((Component)barBg).Slot).AttachComponent<Mask>(true, (Action<Mask>)null).ShowMaskGraphic).Value = true;
			val16.NestInto(((UIComponent)barBg).RectTransform);
			((SyncField<bool>)(object)((DirectionalLayout)val16.HorizontalLayout(8f, 8f, (Alignment?)(Alignment)3)).ForceExpandWidth).Value = false;
			val16.Style.FlexibleWidth = -1f;
			val16.Style.FlexibleHeight = 1f;
			User localUser2 = ((Worker)root).World.LocalUser;
			val16.Style.MinWidth = 48f;
			val16.Style.PreferredWidth = 48f;
			val16.Style.MinHeight = 48f;
			val16.Style.PreferredHeight = 48f;
			val16.Style.FlexibleWidth = -1f;
			val16.Style.FlexibleHeight = -1f;
			Slot val18 = val16.Empty("Image Space");
			((SyncField<bool>)(object)((ContainerWorker<Component>)(object)val18).AttachComponent<Mask>(true, (Action<Mask>)null).ShowMaskGraphic).Value = false;
			Image component = ((ContainerWorker<Component>)(object)val18).GetComponent<Image>((Predicate<Image>)null, false);
			SpriteProvider val19 = TextureProviderSettings.ClampWrap<SpriteProvider>(((ContainerWorker<Component>)(object)val18).AttachComponent<SpriteProvider>(true, (Action<SpriteProvider>)null));
			((SyncRef<IAssetProvider<ITexture2D>>)(object)val19.Texture).Target = UIBuilder.GetCircleTexture(((Worker)root).World);
			((SyncField<float4>)(object)val19.Borders).Value = new float4(0.49f, 0.49f, 0.49f, 0.49f);
			((SyncField<float>)(object)val19.FixedSize).Value = num4 * 0.5f;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)component).Sprite).Target = (IAssetProvider<Sprite>)(object)val19;
			((SyncField<NineSliceSizing>)(object)((ImageBase)component).NineSliceSizing).Value = (NineSliceSizing)0;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)component).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			val16.NestInto(val18);
			val16.Style.FlexibleWidth = -1f;
			val16.Style.FlexibleHeight = -1f;
			CloudUserInfo cloudUserInfo = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<CloudUserInfo>(true, (Action<CloudUserInfo>)null);
			Uri value2 = new Uri("resdb:///bb7d7f1414e0c0a44b4684ecd2a5dc2086c18b3f70c9ed53d467fe96af94e9a9.png");
			StaticTexture2D avatarTex = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)barSlot).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
			cloudUserInfo.UserId.ForceSet(localUser2.UserID);
			((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)avatarTex).URL).Value = value2;
			int avatarRefreshAttempts = 0;
			((Worker)root).World.RunInUpdates(1, new Action(RefreshAvatarIcon));
			Image obj7 = val16.Image((IAssetProvider<ITexture2D>)(object)avatarTex);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)obj7).Material).Target = (IAssetProvider<Material>)(object)val13;
			((SyncField<bool>)(object)((ImageBase)obj7).InteractionTarget).Value = false;
			val16.NestOut();
			float barCollapsedW = num2 * 2f + num4;
			float num7 = 545f;
			float barExpandedW = barCollapsedW + num3 + num7;
			int barRenderW = Math.Max(1, w);
			val16.Style.MinWidth = 0f;
			val16.Style.PreferredWidth = 0f;
			val16.Style.MinHeight = 0f;
			val16.Style.PreferredHeight = 0f;
			val16.Style.FlexibleWidth = -1f;
			val16.Style.FlexibleHeight = -1f;
			LocaleString val20 = LocaleString.op_Implicit("≡");
			Button obj8 = val16.Button(ref val20);
			val16.Style.FlexibleWidth = -1f;
			val16.Style.FlexibleHeight = 1f;
			((Component)obj8).Slot.ActiveSelf = false;
			val16.Style.MinWidth = num7;
			val16.Style.PreferredWidth = num7;
			val16.Style.MinHeight = 48f;
			val16.Style.PreferredHeight = 48f;
			Slot expandPanel = val16.Empty("ExpandPanel");
			expandPanel.ActiveSelf = false;
			UIBuilder val21 = new UIBuilder(expandPanel, (Slot)null);
			((SyncField<bool>)(object)((DirectionalLayout)val21.HorizontalLayout(6f, 6f, (Alignment?)(Alignment)3)).ForceExpandWidth).Value = false;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = 1f;
			val21.Style.MinWidth = 36f;
			val21.Style.PreferredWidth = 36f;
			val21.Style.MinHeight = 40f;
			val21.Style.PreferredHeight = 40f;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = -1f;
			val20 = LocaleString.op_Implicit("⚙");
			Button settingsBtn = val21.Button(ref val20);
			StyleButton(settingsBtn);
			settingsBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				int width = ((session.LastKnownW > 0) ? session.LastKnownW : w);
				int height = ((session.LastKnownH > 0) ? session.LastKnownH : h);
				ToggleSettingsPanel(root, session, width, height, canvasScale, currentPanelCurvature);
			};
			val21.Style.MinWidth = 36f;
			val21.Style.PreferredWidth = 36f;
			val21.Style.MinHeight = 40f;
			val21.Style.PreferredHeight = 40f;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = -1f;
			val20 = LocaleString.op_Implicit("\ud83d\udc41");
			Button previewBtn = val21.Button(ref val20);
			StyleButton(previewBtn);
			val21.Style.MinWidth = 1f;
			val21.Style.PreferredWidth = 1f;
			val21.Style.MinHeight = 32f;
			val21.Style.PreferredHeight = 32f;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = -1f;
			val3 = new colorX(0.42f, 0.44f, 0.48f, 0.48f, (ColorProfile)1);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val21.Image(ref val3, false)).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			val21.Style.MinWidth = 36f;
			val21.Style.PreferredWidth = 36f;
			val21.Style.MinHeight = 40f;
			val21.Style.PreferredHeight = 40f;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = -1f;
			val20 = LocaleString.op_Implicit("⌨\ufe0f");
			Button kbBtn = val21.Button(ref val20);
			StyleButton(kbBtn);
			val20 = LocaleString.op_Implicit("⚓");
			Button anchorBtn = val21.Button(ref val20);
			StyleButton(anchorBtn);
			val20 = LocaleString.op_Implicit("\ud83d\udd12");
			Button privateBtn = val21.Button(ref val20);
			StyleButton(privateBtn);
			val21.Style.MinWidth = 1f;
			val21.Style.PreferredWidth = 1f;
			val21.Style.MinHeight = 32f;
			val21.Style.PreferredHeight = 32f;
			val3 = new colorX(0.42f, 0.44f, 0.48f, 0.48f, (ColorProfile)1);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val21.Image(ref val3, false)).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			val21.Style.MinWidth = 36f;
			val21.Style.PreferredWidth = 36f;
			val21.Style.MinHeight = 40f;
			val21.Style.PreferredHeight = 40f;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.FlexibleHeight = -1f;
			val20 = LocaleString.op_Implicit("\ud83d\udd04");
			Button resyncBtn = val21.Button(ref val20);
			StyleButton(resyncBtn);
			val21.Style.MinWidth = 1f;
			val21.Style.PreferredWidth = 1f;
			val21.Style.MinHeight = 32f;
			val21.Style.PreferredHeight = 32f;
			val3 = new colorX(0.42f, 0.44f, 0.48f, 0.48f, (ColorProfile)1);
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val21.Image(ref val3, false)).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			val21.Style.MinWidth = 38f;
			val21.Style.PreferredWidth = 38f;
			val21.Style.MinHeight = 48f;
			val21.Style.PreferredHeight = 48f;
			val21.Style.FlexibleWidth = -1f;
			val20 = LocaleString.op_Implicit("Curve");
			Text obj9 = val21.Text(ref val20, true, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)obj9.Size).Value = 14f;
			((SyncField<colorX>)(object)obj9.Color).Value = new colorX(0.6f, 0.6f, 0.6f, 1f, (ColorProfile)1);
			((SyncRef<IAssetProvider<Material>>)(object)obj9.Material).Target = (IAssetProvider<Material>)(object)barTextMat;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.MinWidth = 80f;
			val21.Style.PreferredWidth = 80f;
			val21.Style.MinHeight = 48f;
			val21.Style.PreferredHeight = 48f;
			Slot obj10 = val21.Empty("Curve");
			UIBuilder val22 = new UIBuilder(obj10, (Slot)null);
			val22.Style.FlexibleWidth = 1f;
			val22.Style.FlexibleHeight = 1f;
			Image val23 = default(Image);
			Image val24 = default(Image);
			Image val25 = default(Image);
			Slider<float> curveSlider = val22.Slider<float>(20f, currentPanelCurvature, 0f, 1f, false, ref val23, ref val24, ref val25);
			((SyncField<colorX>)(object)val23.Tint).Value = SettingsPanelSoft;
			((SyncField<colorX>)(object)val24.Tint).Value = SettingsAccent;
			((SyncField<colorX>)(object)val25.Tint).Value = SettingsText;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val23).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val24).Material).Target = (IAssetProvider<Material>)(object)val12;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val25).Material).Target = (IAssetProvider<Material>)(object)val13;
			ApplyPurpleBlueGradient(val24, 10f, 0.98f, interactionTarget: false);
			GradientImage val26 = ApplyPurpleBlueGradient(val25, 18f, 0.98f, interactionTarget: false);
			if (val26 != null && ((SyncElementList<ColorDriver>)(object)((InteractionElement)curveSlider).ColorDrivers).Count > 0)
			{
				((SyncRef<IField<colorX>>)(object)((SyncElementList<ColorDriver>)(object)((InteractionElement)curveSlider).ColorDrivers)[0].ColorDrive).Target = (IField<colorX>)(object)val26.TintBottomRight;
			}
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)obj10.GetComponentInChildren<Image>((Predicate<Image>)((Image image) => ((Component)image).Slot.Name == "Background"), false, false)).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			obj10.ForeachComponentInChildren<Text>((Action<Text>)delegate(Text text)
			{
				((SyncRef<IAssetProvider<Material>>)(object)text.Material).Target = (IAssetProvider<Material>)(object)barTextMat;
			}, false, false);
			float pendingPanelCurvature = currentPanelCurvature;
			((SyncField<float>)(object)curveSlider.Value).OnValueChange += delegate(SyncField<float> field)
			{
				pendingPanelCurvature = MathX.Clamp(field.Value, 0f, 1f);
				SetPanelCurvePreference(panelCurvePreferenceKey, pendingPanelCurvature);
			};
			((SyncField<bool>)(object)((InteractionElement)curveSlider).IsPressed).OnValueChange += delegate(SyncField<bool> field)
			{
				if (!field.Value)
				{
					ApplyPanelCurvature(pendingPanelCurvature);
					UpdateDeviceIndicators();
				}
			};
			val21.Style.MinWidth = 24f;
			val21.Style.PreferredWidth = 24f;
			val21.Style.MinHeight = 48f;
			val21.Style.PreferredHeight = 48f;
			val21.Style.FlexibleWidth = -1f;
			val20 = LocaleString.op_Implicit("\ud83d\udd0a");
			Text obj11 = val21.Text(ref val20, false, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)obj11.Size).Value = 16f;
			((SyncField<colorX>)(object)obj11.Color).Value = new colorX(0.6f, 0.6f, 0.6f, 1f, (ColorProfile)1);
			((SyncRef<IAssetProvider<Material>>)(object)obj11.Material).Target = (IAssetProvider<Material>)(object)barTextMat;
			val21.Style.FlexibleWidth = -1f;
			val21.Style.MinWidth = 80f;
			val21.Style.PreferredWidth = 100f;
			val21.Style.MinHeight = 48f;
			val21.Style.PreferredHeight = 48f;
			Slot obj12 = val21.Empty("StreamVol");
			UIBuilder val27 = new UIBuilder(obj12, (Slot)null);
			val27.Style.FlexibleWidth = 1f;
			val27.Style.FlexibleHeight = 1f;
			float streamOutputVolume = NormalizeStreamAudioOutputVolume(Config?.GetValue(StreamAudioOutputVolume) ?? 1f);
			Image val28 = default(Image);
			Image val29 = default(Image);
			Image val30 = default(Image);
			Slider<float> volSlider = val27.Slider<float>(20f, streamOutputVolume, 0f, 1f, false, ref val28, ref val29, ref val30);
			session.StreamVolumeSlider = volSlider;
			ValueUserOverride<float> obj13 = ((ContainerWorker<Component>)(object)obj12).AttachComponent<ValueUserOverride<float>>(true, (Action<ValueUserOverride<float>>)null);
			((SyncRef<IField<float>>)(object)obj13.Target).Target = (IField<float>)(object)volSlider.Value;
			((SyncField<float>)(object)((ValueOverrideBase<float>)(object)obj13).Default).Value = streamOutputVolume;
			((SyncField<bool>)(object)((ValueOverrideBase<float>)(object)obj13).CreateOverrideOnWrite).Value = true;
			((SyncField<bool>)(object)((ValueOverrideBase<float>)(object)obj13).PersistentOverrides).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<float>)(object)obj13).ClearOnUserLeave).Value = true;
			((SyncField<colorX>)(object)val28.Tint).Value = SettingsPanelSoft;
			((SyncField<colorX>)(object)val29.Tint).Value = SettingsAccent;
			((SyncField<colorX>)(object)val30.Tint).Value = SettingsText;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val28).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val29).Material).Target = (IAssetProvider<Material>)(object)val12;
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)val30).Material).Target = (IAssetProvider<Material>)(object)val13;
			ApplyPurpleBlueGradient(val29, 10f, 0.98f, interactionTarget: false);
			GradientImage val31 = ApplyPurpleBlueGradient(val30, 18f, 0.98f, interactionTarget: false);
			if (val31 != null && ((SyncElementList<ColorDriver>)(object)((InteractionElement)volSlider).ColorDrivers).Count > 0)
			{
				((SyncRef<IField<colorX>>)(object)((SyncElementList<ColorDriver>)(object)((InteractionElement)volSlider).ColorDrivers)[0].ColorDrive).Target = (IField<colorX>)(object)val31.TintBottomRight;
			}
			((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)obj12.GetComponentInChildren<Image>((Predicate<Image>)((Image image) => ((Component)image).Slot.Name == "Background"), false, false)).Material).Target = (IAssetProvider<Material>)(object)barElementMat;
			obj12.ForeachComponentInChildren<Text>((Action<Text>)delegate(Text text)
			{
				((SyncRef<IAssetProvider<Material>>)(object)text.Material).Target = (IAssetProvider<Material>)(object)barTextMat;
			}, false, false);
			ValueField<float> widthField = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<ValueField<float>>(true, (Action<ValueField<float>>)null);
			((SyncField<float>)(object)widthField.Value).Value = barCollapsedW;
			SmoothValue<float> widthSmooth = ((ContainerWorker<Component>)(object)barSlot).AttachComponent<SmoothValue<float>>(true, (Action<SmoothValue<float>>)null);
			((SyncField<float>)(object)widthSmooth.Speed).Value = 10f;
			((SyncField<float>)(object)widthSmooth.TargetValue).Value = barCollapsedW;
			((SyncRef<IField<float>>)(object)widthSmooth.Value).Target = (IField<float>)(object)widthField.Value;
			((SyncField<bool>)(object)widthSmooth.WriteBack).Value = false;
			BlurMaterial topBarBlur = null;
			StaticTexture2D topBarBlurMask = null;
			int topBarBlurMaskCanvasWidth = 0;
			int topBarBlurMaskCanvasHeight = 0;
			int topBarBlurMaskPillWidth = 0;
			int topBarBlurMaskPillHeight = 0;
			float barYPos = 0f - worldHalfH - barH / 2f * canvasScale - barMarginBottom;
			((SyncField<float>)(object)widthField.Value).Value = barCollapsedW;
			((SyncField<float>)(object)widthSmooth.TargetValue).Value = barCollapsedW;
			float currentBarWidth = barCollapsedW;
			bool barExpanded = false;
			Button barHoverButton = ((ContainerWorker<Component>)(object)((Component)barBg).Slot).AttachComponent<Button>(true, (Action<Button>)null);
			((SyncField<bool>)(object)barHoverButton.RequireInitialPress).Value = false;
			if (((SyncElementList<ColorDriver>)(object)((InteractionElement)barHoverButton).ColorDrivers).Count > 0)
			{
				ColorDriver obj14 = ((SyncElementList<ColorDriver>)(object)((InteractionElement)barHoverButton).ColorDrivers)[0];
				((SyncField<colorX>)(object)obj14.NormalColor).Value = value;
				((SyncField<colorX>)(object)obj14.HighlightColor).Value = value;
				((SyncField<colorX>)(object)obj14.PressColor).Value = value;
				((SyncField<colorX>)(object)obj14.DisabledColor).Value = value;
			}
			int hoverCollapseGeneration = 0;
			bool hoverCollapseScheduled = false;
			TrackHover(barHoverButton);
			TrackHover(settingsBtn);
			TrackHover(previewBtn);
			TrackHover(kbBtn);
			TrackHover(anchorBtn);
			TrackHover(privateBtn);
			TrackHover(resyncBtn);
			((Worker)root).World.RunInUpdates(4, new Action(PollSharedBarHover));
			topBarStripRef = AddCurvedRenderPlane(root, "TopBarCurvedMesh", barRenderW, barH, canvasScale, barYPos, -0.006f, (IAssetProvider<ITexture2D>)(object)barRenderTex, val9, addCollider: true, (Sidedness)1, (ZWrite)1, 120f, (BlendMode)2, 3004);
			CurvedPlaneMesh obj15 = topBarStripRef;
			RegisterTopBarRaycastPortal((obj15 != null) ? ((Component)obj15).Slot : null, val6);
			topBarBackStripRef = AddCurvedRenderPlane(root, "TopBarBackCurvedMesh", barRenderW, barH, canvasScale, barYPos, 0.004f, (IAssetProvider<ITexture2D>)(object)barBackRenderTex, (Camera)null, addCollider: false, (Sidedness)2, (ZWrite)1, 121f, (BlendMode)2, 3004, 0.01f, (float2?)new float2(-1f, 1f), (float2?)new float2(1f, 0f));
			ApplyPanelCurvature(currentPanelCurvature);
			ApplyBarLayout(barCollapsedW);
			SetBarExpanded(expanded: true);
			ScheduleCollapseWhenHoverLeaves();
			((Worker)root).World.RunInUpdates(1, new Action(BarUpdateLoop));
			Msg("[TopBar] Created bottom hover menu");
			Slot keyboardSlot = null;
			DesktopKeyboardSource keyboardSource = null;
			kbBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				Msg("[Keyboard] Button pressed!");
				if (keyboardSlot == null || ((ContainerWorker<Component>)(object)keyboardSlot).IsDestroyed || keyboardSource == null || ((ComponentBase<Component>)(object)keyboardSource).IsDestroyed)
				{
					keyboardSlot = root.AddLocalSlot("Desktop Keyboard Focus", false);
					keyboardSource = ((ContainerWorker<Component>)(object)keyboardSlot).AttachComponent<DesktopKeyboardSource>(true, (Action<DesktopKeyboardSource>)null);
					session.KeyboardSource = keyboardSource;
				}
				keyboardSlot.LocalPosition = new float3(0f, 0f - worldHalfH - 0.15f, -0.08f);
				keyboardSlot.LocalRotation = floatQ.Euler(30f, 0f, 0f);
				keyboardSlot.LocalScale = float3.One;
				Msg("[Keyboard] Opening userspace virtual keyboard for DesktopBuddy");
				keyboardSource.OpenKeyboard();
			};
			VideoTextureProvider videoTexRef = null;
			previewBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				if (displaySlot == null || ((ContainerWorker<Component>)(object)displaySlot).IsDestroyed || videoTexRef == null || ((ComponentBase<Component>)(object)videoTexRef).IsDestroyed)
				{
					Msg("[Preview] No remote stream visual available");
				}
				else
				{
					session.LocalPreviewingRemoteStream = !session.LocalPreviewingRemoteStream;
					if (session.PreviewStreamAllowed != null && !((ComponentBase<Component>)(object)session.PreviewStreamAllowed).IsDestroyed)
					{
						((ValueOverrideBase<bool>)(object)session.PreviewStreamAllowed).SetOverride(((Worker)root).World.LocalUser, session.LocalPreviewingRemoteStream);
					}
					if (session.StreamVisualAllowed != null && !((ComponentBase<Component>)(object)session.StreamVisualAllowed).IsDestroyed)
					{
						((ValueOverrideBase<bool>)(object)session.StreamVisualAllowed).SetOverride(((Worker)root).World.LocalUser, session.LocalPreviewingRemoteStream);
					}
					displaySlot.ActiveSelf = !session.LocalPreviewingRemoteStream;
					Image component2 = ((ContainerWorker<Component>)(object)((Component)previewBtn).Slot).GetComponent<Image>((Predicate<Image>)null, false);
					if (component2 != null)
					{
						((SyncField<colorX>)(object)component2.Tint).Value = (session.LocalPreviewingRemoteStream ? new colorX(0.24f, 0.18f, 0.42f, 0.95f, (ColorProfile)1) : new colorX(0.12f, 0.13f, 0.17f, 0.88f, (ColorProfile)1));
					}
					Msg("[Preview] Local stream preview=" + (session.LocalPreviewingRemoteStream ? "remote" : "direct"));
				}
			};
			resyncBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				Msg("[Resync] Button pressed");
				if (videoTexRef == null || ((ComponentBase<Component>)(object)videoTexRef).IsDestroyed)
				{
					Msg("[Resync] No stream available");
				}
				else
				{
					Uri savedUrl = session.StreamUrl ?? ((SyncField<Uri>)(object)videoTexRef.URL).Value;
					if (savedUrl == (Uri)null)
					{
						Msg("[Resync] No URL is currently bound");
					}
					else
					{
						Msg($"[Resync] Forcing full reload: {savedUrl}");
						ClearRemoteStreamUrl(session, "manual resync");
						((Worker)root).World.RunInUpdates(10, (Action)delegate
						{
							if (videoTexRef != null && !((ComponentBase<Component>)(object)videoTexRef).IsDestroyed)
							{
								SetRemoteStreamUrl(session, savedUrl, "manual resync restore");
								Msg($"[Resync] URL restored: {savedUrl}");
							}
						});
					}
				}
			};
			bool isAnchored = false;
			colorX anchorActiveColor = new colorX(0.2f, 0.45f, 0.25f, 1f, (ColorProfile)1);
			anchorBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				Msg("[Anchor] Button pressed");
				User localUser3 = ((Worker)root).World.LocalUser;
				if (((localUser3 != null) ? localUser3.Root : null) != null)
				{
					if (!isAnchored)
					{
						root.SetParent(((Component)localUser3.Root).Slot, true);
						Msg("[Anchor] Anchored to user");
						isAnchored = true;
					}
					else
					{
						root.SetParent(((Worker)root).World.RootSlot, true);
						Msg("[Anchor] Unanchored to world");
						isAnchored = false;
					}
					Image component2 = ((ContainerWorker<Component>)(object)((Component)anchorBtn).Slot).GetComponent<Image>((Predicate<Image>)null, false);
					if (component2 != null)
					{
						((SyncField<colorX>)(object)component2.Tint).Value = (isAnchored ? anchorActiveColor : colorX.Clear);
					}
				}
			};
			deviceIndicatorsSlot = CreateVirtualDeviceControls(root, session, DeviceIndicatorY(), DeviceIndicatorZ(), Config?.GetValue(SpatialAudioEnabled) ?? false);
			bool isPrivate = startPrivate;
			string savedStreamUrl = null;
			ValueUserOverride<bool> rootVis = ((ContainerWorker<Component>)(object)root).AttachComponent<ValueUserOverride<bool>>(true, (Action<ValueUserOverride<bool>>)null);
			((SyncRef<IField<bool>>)(object)rootVis.Target).Target = (IField<bool>)(object)root.ActiveSelf_Field;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)rootVis).Default).Value = !isPrivate;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)rootVis).CreateOverrideOnWrite).Value = false;
			if (isPrivate)
			{
				((ValueOverrideBase<bool>)(object)rootVis).SetOverride(((Worker)root).World.LocalUser, true);
			}
			privateBtn.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Expected O, but got Unknown
				isPrivate = !isPrivate;
				Msg($"[Private] Mode: {isPrivate}");
				((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)rootVis).Default).Value = !isPrivate;
				((ValueOverrideBase<bool>)(object)rootVis).SetOverride(((Worker)root).World.LocalUser, true);
				if (videoTexRef != null && !((ComponentBase<Component>)(object)videoTexRef).IsDestroyed)
				{
					if (isPrivate)
					{
						savedStreamUrl = ((object)(session.StreamUrl ?? ((SyncField<Uri>)(object)videoTexRef.URL).Value))?.ToString();
						ClearRemoteStreamUrl(session, "private mode");
						Msg("[Private] Stream disconnected");
					}
					else
					{
						Uri val32 = null;
						if (savedStreamUrl != null)
						{
							val32 = new Uri(savedStreamUrl);
						}
						else if (session.StreamId > 0)
						{
							val32 = GetSharedStreamUrl(session.Hwnd, session.StreamId) ?? GetBuiltInStreamUrl(session.StreamId);
						}
						if (val32 != (Uri)null)
						{
							SetRemoteStreamUrl(session, val32, "private mode restore");
							Msg($"[Private] Stream restored: {val32}");
						}
						else
						{
							Msg($"[Private] Going public but no stream URL available yet (streamId={session.StreamId})");
						}
					}
				}
				ApplyPrivateButtonTint();
			};
			ApplyPrivateButtonTint();
			if (isPrivate)
			{
				Msg("[Private] Initial mode: true");
			}
			bool flag2 = hwnd == (nint)global::System.IntPtr.Zero;
			_ = processId;
			Canvas streamCanvasRef = null;
			backPlaneRef = AddCurvedBackPlane(root, w, h, canvasScale);
			ApplyPanelCurvature(currentPanelCurvature);
			Msg("[BackPanel] Created curved backing");
			if (!_updateShown && Config.GetValue(CheckForUpdates))
			{
				_updateShown = true;
				Slot capturedRoot = root;
				World capturedWorld = ((Worker)root).World;
				DesktopSession capturedSession = session;
				int capturedW = w;
				int capturedH = h;
				float capturedCanvasScale = canvasScale;
				float capturedCurvature = currentPanelCurvature;
				Action val32 = default(Action);
				global::System.Threading.Tasks.Task.Run((Action)delegate
				{
					//IL_0033: Unknown result type (might be due to invalid IL or missing references)
					//IL_0026: Unknown result type (might be due to invalid IL or missing references)
					//IL_002b: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Expected O, but got Unknown
					//IL_0032: Expected O, but got Unknown
					CheckForUpdate();
					if (_latestVersion != null)
					{
						World obj16 = capturedWorld;
						Action obj17 = val32;
						if (obj17 == null)
						{
							Action val33 = delegate
							{
								if (!((ContainerWorker<Component>)(object)capturedRoot).IsDestroyed && capturedSession != null)
								{
									OpenSettingsPanel(capturedRoot, capturedSession, (capturedSession.LastKnownW > 0) ? capturedSession.LastKnownW : capturedW, (capturedSession.LastKnownH > 0) ? capturedSession.LastKnownH : capturedH, capturedCanvasScale, capturedCurvature, SettingsPanelTab.UpdateInfo);
								}
							};
							Action val34 = val33;
							val32 = val33;
							obj17 = val34;
						}
						obj16.RunInUpdates(0, obj17);
					}
				});
			}
			bool useMediaMtx = IsMediaMtxEnabled;
			((Worker)root).World.RunInUpdates(1, (Action)delegate
			{
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && session != null && !session.Cleaned)
				{
					RemoteStreamVisual remoteStreamVisual = BuildRemoteStream(new RemoteStreamBuildContext
					{
						Root = root,
						Hwnd = hwnd,
						Width = w,
						Height = h,
						CanvasScale = canvasScale,
						Session = session,
						UseMediaMtx = useMediaMtx,
						VolumeSlider = volSlider,
						StreamOutputVolume = streamOutputVolume,
						IsPrivate = () => isPrivate,
						CurrentPanelCurvature = () => currentPanelCurvature,
						LinuxPipeWireNodeId = streamer.LinuxPipeWireNodeId
					});
					if (remoteStreamVisual != null)
					{
						videoTexRef = remoteStreamVisual.VideoTexture;
						streamPlaneRef = remoteStreamVisual.StreamPlane;
						streamCanvasRef = remoteStreamVisual.StreamCanvas;
						ApplyPanelCurvature(currentPanelCurvature);
					}
				}
			});
			grabbable = ((ContainerWorker<Component>)(object)root).AttachComponent<Grabbable>(true, (Action<Grabbable>)null);
			((SyncField<bool>)(object)grabbable.Scalable).Value = true;
			Msg("[StartStreaming] Grabbable attached");
			StartThrowDismissalTracker(root, grabbable, localUser2);
			session.OnResize = UpdateLayout;
			root.PersistentSelf = false;
			root.Name = "Desktop: " + title;
			session.TitleText = titleText;
			session.LastTitle = title;
			ScheduleUpdate(((Worker)root).World);
			root.Tag = "Desktop Buddy";
			if (!DesktopBuddyPlatform.IsLinux)
			{
				global::System.Threading.Tasks.Task.Run((Action)delegate
				{
					Msg($"[StartStreaming] Focus request START hwnd={hwnd} title={title}");
					Msg(WindowInput.FocusWindow(hwnd) ? ("[StartStreaming] Window focused, streaming started for: " + title) : ("[StartStreaming] Streaming started, but Windows did not foreground the window yet: " + title));
				});
			}
			bool flag3 = Config?.GetValue(SpatialAudioEnabled) ?? false;
			if (!(!DesktopBuddyPlatform.IsLinux && flag3) || flag2 || processId == 0)
			{
				return;
			}
			global::System.Threading.Tasks.Task.Run((Action)delegate
			{
				try
				{
					Msg($"[AudioRouter] Background route START pid={processId}");
					if (VBCable.HasCableInputDevice())
					{
						string text = VBCable.FindCableInputDeviceId();
						if (text != null)
						{
							AudioRouter.SetProcessOutputDevice(processId, text);
							session.OwnsAudioRedirect = true;
							Msg($"[AudioRouter] Background route DONE pid={processId}");
						}
					}
				}
				catch (global::System.Exception ex)
				{
					Msg($"[AudioRouter] Background route failed for PID {processId}: {ex.Message}");
				}
			});
			bool AnyBarControlHovered()
			{
				if ((barHoverButton == null || ((ComponentBase<Component>)(object)barHoverButton).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)barHoverButton).IsHovering).Value) && (settingsBtn == null || ((ComponentBase<Component>)(object)settingsBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)settingsBtn).IsHovering).Value) && (previewBtn == null || ((ComponentBase<Component>)(object)previewBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)previewBtn).IsHovering).Value) && (kbBtn == null || ((ComponentBase<Component>)(object)kbBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)kbBtn).IsHovering).Value) && (anchorBtn == null || ((ComponentBase<Component>)(object)anchorBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)anchorBtn).IsHovering).Value) && (privateBtn == null || ((ComponentBase<Component>)(object)privateBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)privateBtn).IsHovering).Value) && (resyncBtn == null || ((ComponentBase<Component>)(object)resyncBtn).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)resyncBtn).IsHovering).Value) && (curveSlider == null || ((ComponentBase<Component>)(object)curveSlider).IsDestroyed || !((SyncField<bool>)(object)((InteractionElement)curveSlider).IsHovering).Value))
				{
					if (volSlider != null && !((ComponentBase<Component>)(object)volSlider).IsDestroyed)
					{
						return ((SyncField<bool>)(object)((InteractionElement)volSlider).IsHovering).Value;
					}
					return false;
				}
				return true;
			}
			void ApplyBarLayout(float width)
			{
				//IL_002d: 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_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: 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_0201: Unknown result type (might be due to invalid IL or missing references)
				//IL_0238: Unknown result type (might be due to invalid IL or missing references)
				//IL_025d: Unknown result type (might be due to invalid IL or missing references)
				if (barCanvas != null && !((ComponentBase<Component>)(object)barCanvas).IsDestroyed)
				{
					((SyncField<float2>)(object)barCanvas.Size).Value = new float2((float)barRenderW, barH);
				}
				if (barRenderTex != null && !((ComponentBase<Component>)(object)barRenderTex).IsDestroyed)
				{
					((SyncField<int2>)(object)barRenderTex.Size).Value = new int2(barRenderW, (int)barH);
				}
				if (barBackRenderTex != null && !((ComponentBase<Component>)(object)barBackRenderTex).IsDestroyed)
				{
					((SyncField<int2>)(object)barBackRenderTex.Size).Value = new int2(barRenderW, (int)barH);
				}
				if (barBg != null && !((ComponentBase<Component>)(object)barBg).IsDestroyed)
				{
					RectTransform rectTransform = ((UIComponent)barBg).RectTransform;
					Rect val32 = new Rect(width * -0.5f, (0f - barH) * 0.5f, width, barH);
					float2 val33 = new float2(0.5f, 0.5f);
					rectTransform.SetFixedRect(val32, ref val33);
				}
				if (barSlot != null && !((ContainerWorker<Component>)(object)barSlot).IsDestroyed)
				{
					barSlot.LocalPosition = float3.Zero;
				}
				if (barBackCanvas != null && !((ComponentBase<Component>)(object)barBackCanvas).IsDestroyed)
				{
					((SyncField<float2>)(object)barBackCanvas.Size).Value = new float2((float)barRenderW, barH);
				}
				if (barBackBg != null && !((ComponentBase<Component>)(object)barBackBg).IsDestroyed)
				{
					RectTransform rectTransform2 = ((UIComponent)barBackBg).RectTransform;
					Rect val34 = new Rect(width * -0.5f, (0f - barH) * 0.5f, width, barH);
					float2 val33 = new float2(0.5f, 0.5f);
					rectTransform2.SetFixedRect(val34, ref val33);
				}
				if (topBarStripRef != null && !((ComponentBase<Component>)(object)topBarStripRef).IsDestroyed)
				{
					((SyncField<float2>)(object)topBarStripRef.Size).Value = new float2((float)barRenderW, barH);
					((Component)topBarStripRef).Slot.LocalPosition = new float3(0f, barYPos, -0.006f);
				}
				if (topBarBackStripRef != null && !((ComponentBase<Component>)(object)topBarBackStripRef).IsDestroyed)
				{
					((SyncField<float2>)(object)topBarBackStripRef.Size).Value = new float2((float)barRenderW, barH);
					((Component)topBarBackStripRef).Slot.LocalPosition = new float3(0f, barYPos, 0.004f);
				}
				UpdateTopBarBlurMask(Math.Max(1, barRenderW), Math.Max(1, (int)MathF.Ceiling(barH)), Math.Max(1, (int)MathF.Ceiling(width)), Math.Max(1, (int)MathF.Ceiling(barH)));
			}
			void ApplyPanelCurvature(float curvature)
			{
				currentPanelCurvature = MathX.Clamp(curvature, 0f, 1f);
				if (frontPlaneRef != null && !((ComponentBase<Component>)(object)frontPlaneRef).IsDestroyed)
				{
					((SyncField<float>)(object)frontPlaneRef.Curvature).Value = currentPanelCurvature;
				}
				if (backPlaneRef != null && !((ComponentBase<Component>)(object)backPlaneRef).IsDestroyed)
				{
					((SyncField<float>)(object)backPlaneRef.Curvature).Value = currentPanelCurvature;
				}
				if (streamPlaneRef != null && !((ComponentBase<Component>)(object)streamPlaneRef).IsDestroyed)
				{
					((SyncField<float>)(object)streamPlaneRef.Curvature).Value = currentPanelCurvature;
				}
				if (topBarStripRef != null && !((ComponentBase<Component>)(object)topBarStripRef).IsDestroyed)
				{
					((SyncField<float>)(object)topBarStripRef.Curvature).Value = currentPanelCurvature;
				}
				if (topBarBackStripRef != null && !((ComponentBase<Component>)(object)topBarBackStripRef).IsDestroyed)
				{
					((SyncField<float>)(object)topBarBackStripRef.Curvature).Value = currentPanelCurvature;
				}
				if (session != null)
				{
					UpdateAdaptiveScreenLightPosition(session);
					ResizeSettingsPanel(session, (session.LastKnownW > 0) ? session.LastKnownW : w, (session.LastKnownH > 0) ? session.LastKnownH : h, canvasScale, currentPanelCurvature);
				}
			}
			void ApplyPrivateButtonTint()
			{
				//IL_0040: 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)
				Image component2 = ((ContainerWorker<Component>)(object)((Component)privateBtn).Slot).GetComponent<Image>((Predicate<Image>)null, false);
				if (component2 != null)
				{
					((SyncField<colorX>)(object)component2.Tint).Value = (colorX)(isPrivate ? new colorX(0.5f, 0.2f, 0.2f, 1f, (ColorProfile)1) : colorX.Clear);
				}
			}
			void BarUpdateLoop()
			{
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && barSlot != null && !((ContainerWorker<Component>)(object)barSlot).IsDestroyed && barCanvas != null && !((ComponentBase<Component>)(object)barCanvas).IsDestroyed && widthField != null && !((ComponentBase<Component>)(object)widthField).IsDestroyed && widthSmooth != null && !((ComponentBase<Component>)(object)widthSmooth).IsDestroyed)
				{
					float value3 = ((SyncField<float>)(object)widthField.Value).Value;
					if (value3 != currentBarWidth)
					{
						currentBarWidth = value3;
						ApplyBarLayout(value3);
					}
					float value4 = ((SyncField<float>)(object)widthSmooth.TargetValue).Value;
					if (Math.Abs(value3 - value4) > 0.5f)
					{
						((Worker)root).World.RunInUpdates(1, new Action(BarUpdateLoop));
					}
				}
			}
			float DeviceIndicatorY()
			{
				return worldHalfH + 0.02f;
			}
			float DeviceIndicatorZ()
			{
				return 0.001f + GetCurvedPanelDepth(frontPlaneRef, canvasScale);
			}
			void PollSharedBarHover()
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed)
				{
					if (AnyBarControlHovered())
					{
						if (hoverCollapseScheduled)
						{
							hoverCollapseGeneration++;
							hoverCollapseScheduled = false;
						}
						SetBarExpanded(expanded: true);
					}
					else if (barExpanded)
					{
						ScheduleCollapseWhenHoverLeaves();
					}
					((Worker)root).World.RunInUpdates(4, new Action(PollSharedBarHover));
				}
			}
			void RefreshAvatarIcon()
			{
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Expected O, but got Unknown
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && cloudUserInfo != null && !((ComponentBase<Component>)(object)cloudUserInfo).IsDestroyed && avatarTex != null && !((ComponentBase<Component>)(object)avatarTex).IsDestroyed)
				{
					Uri value3 = ((SyncField<Uri>)(object)cloudUserInfo.IconURL).Value;
					if (value3 != (Uri)null)
					{
						((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)avatarTex).URL).Value = value3;
					}
					else if (++avatarRefreshAttempts < 120)
					{
						((Worker)root).World.RunInUpdates(10, new Action(RefreshAvatarIcon));
					}
				}
			}
			void ScheduleCollapseWhenHoverLeaves()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && !hoverCollapseScheduled)
				{
					hoverCollapseScheduled = true;
					int generation = ++hoverCollapseGeneration;
					((Worker)root).World.RunInSeconds(2f, (Action)delegate
					{
						if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && generation == hoverCollapseGeneration)
						{
							if (AnyBarControlHovered())
							{
								hoverCollapseScheduled = false;
							}
							else
							{
								hoverCollapseScheduled = false;
								SetBarExpanded(expanded: false);
							}
						}
					});
				}
			}
			void SetBarExpanded(bool expanded)
			{
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Expected O, but got Unknown
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				if (root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed && widthSmooth != null && !((ComponentBase<Component>)(object)widthSmooth).IsDestroyed && barExpanded != expanded)
				{
					barExpanded = expanded;
					if (expandPanel != null && !((ContainerWorker<Component>)(object)expandPanel).IsDestroyed)
					{
						expandPanel.ActiveSelf = barExpanded;
					}
					((SyncField<float>)(object)widthSmooth.TargetValue).Value = (barExpanded ? barExpandedW : barCollapsedW);
					((Worker)root).World.RunInUpdates(1, new Action(BarUpdateLoop));
				}
			}
			void StyleButton(Button btn)
			{
				TopBarControlStyles.StyleButton(btn, barTextMat, roundedSprite, barElementMat);
			}
			void TrackHover(Button button)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0016: Expected O, but got Unknown
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Expected O, but got Unknown
				if (button != null)
				{
					button.LocalHoverEnter += (ButtonEventHandler)delegate
					{
						hoverCollapseGeneration++;
						hoverCollapseScheduled = false;
						SetBarExpanded(expanded: true);
					};
					button.LocalHoverStay += (ButtonEventHandler)delegate
					{
						SetBarExpanded(expanded: true);
					};
					button.LocalHoverLeave += (ButtonEventHandler)delegate
					{
						ScheduleCollapseWhenHoverLeaves();
					};
				}
			}
			void UpdateDeviceIndicators()
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				if (deviceIndicatorsSlot != null && !((ContainerWorker<Component>)(object)deviceIndicatorsSlot).IsDestroyed)
				{
					deviceIndicatorsSlot.LocalPosition = new float3(0f, DeviceIndicatorY(), DeviceIndicatorZ());
				}
			}
			void UpdateLayout(int newW, int newH)
			{
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_024a: Unknown result type (might be due to invalid IL or missing references)
				w = newW;
				h = newH;
				worldHalfW = (float)newW / 2f * canvasScale;
				worldHalfH = (float)newH / 2f * canvasScale;
				barRenderW = Math.Max(1, newW);
				barYPos = 0f - worldHalfH - barH / 2f * canvasScale - barMarginBottom;
				ApplyBarLayout(currentBarWidth);
				if (session.Collider != null && !((ComponentBase<Component>)(object)session.Collider).IsDestroyed)
				{
					((SyncField<float3>)(object)session.Collider.Size).Value = new float3((float)newW * canvasScale, (float)newH * canvasScale, 0.001f);
				}
				if (ui.Canvas != null && !((ComponentBase<Component>)(object)ui.Canvas).IsDestroyed)
				{
					((SyncField<float2>)(object)ui.Canvas.Size).Value = new float2((float)newW, (float)newH);
				}
				if (frontPlaneRef != null && !((ComponentBase<Component>)(object)frontPlaneRef).IsDestroyed)
				{
					((SyncField<float2>)(object)frontPlaneRef.Size).Value = new float2((float)newW, (float)newH);
				}
				if (displayRayExitRef != null && !((ComponentBase<Component>)(object)displayRayExitRef).IsDestroyed)
				{
					displayRayExitRef.Size = new float2((float)newW, (float)newH);
				}
				if (backPlaneRef != null && !((ComponentBase<Component>)(object)backPlaneRef).IsDestroyed)
				{
					((SyncField<float2>)(object)backPlaneRef.Size).Value = new float2((float)newW, (float)newH);
				}
				if (streamPlaneRef != null && !((ComponentBase<Component>)(object)streamPlaneRef).IsDestroyed)
				{
					((SyncField<float2>)(object)streamPlaneRef.Size).Value = new float2((float)newW, (float)newH);
				}
				if (streamCanvasRef != null && !((ComponentBase<Component>)(object)streamCanvasRef).IsDestroyed)
				{
					((SyncField<float2>)(object)streamCanvasRef.Size).Value = new float2((float)newW, (float)newH);
				}
				UpdateAdaptiveScreenLightPosition(session);
				ResizeSettingsPanel(session, newW, newH, canvasScale, currentPanelCurvature);
				if (keyboardSlot != null && keyboardSlot.ActiveSelf && !((ContainerWorker<Component>)(object)keyboardSlot).IsDestroyed)
				{
					keyboardSlot.LocalPosition = new float3(0f, 0f - worldHalfH - 0.15f, -0.08f);
				}
				UpdateDeviceIndicators();
				Msg($"[Resize] UI updated to {newW}x{newH}");
			}
			void UpdateTopBarBlurMask(int canvasWidthPx, int canvasHeightPx, int pillWidthPx, int pillHeightPx)
			{
				<>c__DisplayClass281_1 CS$<>8__locals10 = new <>c__DisplayClass281_1();
				if (topBarBlur != null && !((ComponentBase<Component>)(object)topBarBlur).IsDestroyed && topBarBlurMask != null && !((ComponentBase<Component>)(object)topBarBlurMask).IsDestroyed && root != null && !((ContainerWorker<Component>)(object)root).IsDestroyed)
				{
					canvasWidthPx = Math.Max(1, canvasWidthPx);
					canvasHeightPx = Math.Max(1, canvasHeightPx);
					pillWidthPx = Math.Max(1, Math.Min(canvasWidthPx, pillWidthPx));
					pillHeightPx = Math.Max(1, Math.Min(canvasHeightPx, pillHeightPx));
					if (topBarBlurMaskCanvasWidth != canvasWidthPx || topBarBlurMaskCanvasHeight != canvasHeightPx || topBarBlurMaskPillWidth != pillWidthPx || topBarBlurMaskPillHeight != pillHeightPx)
					{
						topBarBlurMaskCanvasWidth = canvasWidthPx;
						topBarBlurMaskCanvasHeight = canvasHeightPx;
						topBarBlurMaskPillWidth = pillWidthPx;
						topBarBlurMaskPillHeight = pillHeightPx;
						CS$<>8__locals10.tex = topBarBlurMask;
						CS$<>8__locals10.blur = topBarBlur;
						CS$<>8__locals10.engine = ((Worker)root).Engine;
						if (CS$<>8__locals10.tex != null && CS$<>8__locals10.blur != null)
						{
							Engine obj16 = CS$<>8__locals10.engine;
							if (((obj16 != null) ? obj16.LocalDB : null) != null)
							{
								CS$<>8__locals10.data = CreateCenteredRoundedMaskPixels(canvasWidthPx, canvasHeightPx, pillWidthPx, pillHeightPx, barH * 0.5f, out CS$<>8__locals10.texW, out CS$<>8__locals10.texH);
								global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass281_1.<<FinishStartStreaming>b__34>d))] () =>
								{
									//IL_0002: Unknown result type (might be due to invalid IL or missing references)
									//IL_0007: Unknown result type (might be due to invalid IL or missing references)
									<>c__DisplayClass281_1.<<FinishStartStreaming>b__34>d <<FinishStartStreaming>b__34>d = default(<>c__DisplayClass281_1.<<FinishStartStreaming>b__34>d);
									<<FinishStartStreaming>b__34>d.<>t__builder = AsyncTaskMethodBuilder.Create();
									<<FinishStartStreaming>b__34>d.<>4__this = CS$<>8__locals10;
									<<FinishStartStreaming>b__34>d.<>1__state = -1;
									((AsyncTaskMethodBuilder)(ref <<FinishStartStreaming>b__34>d.<>t__builder)).Start<<>c__DisplayClass281_1.<<FinishStartStreaming>b__34>d>(ref <<FinishStartStreaming>b__34>d);
									return ((AsyncTaskMethodBuilder)(ref <<FinishStartStreaming>b__34>d.<>t__builder)).Task;
								}));
							}
						}
					}
				}
			}
		}

		private static Slot CreateVirtualDeviceControls(Slot root, DesktopSession session, float y, float z, bool spatialAudio)
		{
			//IL_0021: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			Slot obj = root.AddSlot("DeviceIndicators", true);
			obj.LocalPosition = new float3(0f, y, z);
			obj.LocalRotation = floatQ.Identity;
			obj.LocalScale = float3.One;
			Slot val = obj.AddSlot("VirtualCamera", true);
			val.LocalPosition = float3.Zero;
			val.LocalRotation = floatQ.Euler(0f, 180f, 0f);
			val.LocalScale = float3.One;
			Slot val2 = val.AddSlot("Visual", true);
			val2.LocalScale = new float3(0.04f, 0.02f, 0.001f);
			MeshRenderer obj2 = ((ContainerWorker<Component>)(object)val2).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)obj2.Mesh).Target = (IAssetProvider<Mesh>)(object)((ContainerWorker<Component>)(object)val2).AttachComponent<BoxMesh>(true, (Action<BoxMesh>)null);
			UI_UnlitMaterial val3 = ((ContainerWorker<Component>)(object)val2).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<colorX>)(object)val3.Tint).Value = new colorX(0.05f, 0.05f, 0.05f, 1f, (ColorProfile)1);
			obj2.Materials.Add((IAssetProvider<Material>)(object)val3);
			((SyncField<float3>)(object)((ContainerWorker<Component>)(object)val2).AttachComponent<BoxCollider>(true, (Action<BoxCollider>)null).Size).Value = float3.One;
			PhysicalButton obj3 = ((ContainerWorker<Component>)(object)val2).AttachComponent<PhysicalButton>(true, (Action<PhysicalButton>)null);
			object obj4 = <>c.<>9__282_0;
			if (obj4 == null)
			{
				ButtonEventHandler val4 = delegate
				{
					if (VCam == null)
					{
						Msg("[VirtualCamera] Not available");
					}
					else
					{
						VCam.ManuallyDisabled = !VCam.ManuallyDisabled;
						Msg("[VirtualCamera] " + (VCam.ManuallyDisabled ? "Disabled" : "Enabled"));
					}
				};
				<>c.<>9__282_0 = val4;
				obj4 = (object)val4;
			}
			obj3.LocalPressed += (ButtonEventHandler)obj4;
			Camera val5 = ((ContainerWorker<Component>)(object)val).AttachComponent<Camera>(true, (Action<Camera>)null);
			((SyncField<float>)(object)val5.FieldOfView).Value = 90f;
			((SyncField<float>)(object)val5.NearClipping).Value = 0.05f;
			((SyncField<float>)(object)val5.FarClipping).Value = 1000f;
			((SyncField<CameraClearMode>)(object)val5.Clear).Value = (CameraClearMode)1;
			((SyncField<colorX>)(object)val5.ClearColor).Value = new colorX(0.1f, 0.1f, 0.1f, 1f, (ColorProfile)1);
			session.VCamSlot = val;
			session.VCamCamera = val5;
			session.VCamIndicator = val3;
			Slot val6 = obj.AddSlot("VirtualMic", true);
			val6.LocalPosition = new float3(0.03f, 0f, 0f);
			val6.LocalRotation = floatQ.Identity;
			val6.LocalScale = float3.One;
			Slot val7 = val6.AddSlot("Visual", true);
			val7.LocalScale = new float3(0.015f, 0.02f, 0.001f);
			MeshRenderer obj5 = ((ContainerWorker<Component>)(object)val7).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)obj5.Mesh).Target = (IAssetProvider<Mesh>)(object)((ContainerWorker<Component>)(object)val7).AttachComponent<BoxMesh>(true, (Action<BoxMesh>)null);
			UI_UnlitMaterial micMat = ((ContainerWorker<Component>)(object)val7).AttachComponent<UI_UnlitMaterial>(true, (Action<UI_UnlitMaterial>)null);
			((SyncField<colorX>)(object)micMat.Tint).Value = new colorX(0.1f, 0.8f, 0.1f, 1f, (ColorProfile)1);
			obj5.Materials.Add((IAssetProvider<Material>)(object)micMat);
			((SyncField<float3>)(object)((ContainerWorker<Component>)(object)val7).AttachComponent<BoxCollider>(true, (Action<BoxCollider>)null).Size).Value = float3.One;
			session.VMicSlot = val6;
			session.VMicIndicator = micMat;
			AudioListener vMicListener = ((ContainerWorker<Component>)(object)val6).AttachComponent<AudioListener>(true, (Action<AudioListener>)null);
			session.VMicListener = vMicListener;
			((ContainerWorker<Component>)(object)val7).AttachComponent<PhysicalButton>(true, (Action<PhysicalButton>)null).LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				session.VMicMuted = !session.VMicMuted;
				((SyncField<colorX>)(object)micMat.Tint).Value = (session.VMicMuted ? new colorX(0.3f, 0.05f, 0.05f, 1f, (ColorProfile)1) : new colorX(0.1f, 0.8f, 0.1f, 1f, (ColorProfile)1));
				Msg("[VirtualMic] " + (session.VMicMuted ? "Muted" : "Unmuted"));
			};
			if (spatialAudio)
			{
				Slot obj6 = root.AddLocalSlot("LocalAudio", false);
				DesktopAudioSource desktopAudioSource = ((ContainerWorker<Component>)(object)obj6).AttachComponent<DesktopAudioSource>(true, (Action<DesktopAudioSource>)null);
				session.SpatialAudioSource = desktopAudioSource;
				AudioOutput val8 = ((ContainerWorker<Component>)(object)obj6).AttachComponent<AudioOutput>(true, (Action<AudioOutput>)null);
				((SyncRef<IWorldAudioDataSource>)(object)val8.Source).Target = (IWorldAudioDataSource)(object)desktopAudioSource;
				((SyncField<float>)(object)val8.Volume).Value = 1f;
				((SyncField<float>)(object)val8.SpatialBlend).Value = 1f;
				((SyncField<float>)(object)val8.MinDistance).Value = 0.5f;
				((SyncField<float>)(object)val8.MaxDistance).Value = 30f;
				((SyncField<AudioTypeGroup>)(object)val8.AudioTypeGroup).Value = (AudioTypeGroup)1;
				session.SpatialAudioOutput = val8;
			}
			return obj;
		}

		private static void CleanupSession(DesktopSession session)
		{
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa5: Expected O, but got Unknown
			if (session.Cleaned)
			{
				Msg($"[Cleanup] Already cleaned hwnd={session.Hwnd} streamId={session.StreamId}, skipping");
				return;
			}
			session.Cleaned = true;
			Msg($"[Cleanup] === START === hwnd={session.Hwnd} streamId={session.StreamId}");
			CleanupTrace($"CleanupSession ENTER hwnd={session.Hwnd} streamId={session.StreamId} rootDestroyed={((ContainerWorker<Component>)(object)session.Root)?.IsDestroyed} texDestroyed={((ComponentBase<Component>)(object)session.Texture)?.IsDestroyed}");
			session.ActiveTouchIds.Clear();
			CleanupTrace($"ActiveTouchIds cleared hwnd={session.Hwnd} streamId={session.StreamId}");
			if (session.LinuxInputSessionId != 0L)
			{
				try
				{
					using LinuxNativeBridge linuxNativeBridge = new LinuxNativeBridge();
					linuxNativeBridge.InputStop(session.LinuxInputSessionId);
					Msg($"[Cleanup] Stopped Linux input session {session.LinuxInputSessionId}");
				}
				catch (global::System.Exception ex)
				{
					Msg("[Cleanup] Linux input stop error: " + ex.Message);
				}
				if (WindowInput.LinuxInputSession == session.LinuxInputSessionId)
				{
					WindowInput.LinuxInputSession = 0uL;
				}
				session.LinuxInputSessionId = 0uL;
			}
			if (VMic != null && session.VMicListener != null)
			{
				Msg("[Cleanup] Disposing VMic (listener destroyed)");
				long startTicks = TraceStart("VMic.Dispose");
				VMic.Dispose();
				VMic = null;
				TraceDone("VMic.Dispose", startTicks);
			}
			if (session.OwnsAudioRedirect && session.ProcessId != 0)
			{
				CleanupTrace($"Audio redirect reset check START pid={session.ProcessId}");
				bool flag = false;
				Enumerator<DesktopSession> enumerator = ActiveSessions.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						if (current != session && !current.Cleaned && current.ProcessId == session.ProcessId)
						{
							flag = true;
							break;
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (!flag)
				{
					long startTicks2 = TraceStart($"AudioRouter.ResetProcessToDefault pid={session.ProcessId}");
					AudioRouter.ResetProcessToDefault(session.ProcessId);
					TraceDone($"AudioRouter.ResetProcessToDefault pid={session.ProcessId}", startTicks2);
					Msg($"[Cleanup] Reset audio routing for PID {session.ProcessId}");
				}
				else
				{
					Msg($"[Cleanup] Keeping audio routing for PID {session.ProcessId} (other sessions still active)");
				}
			}
			session.SeenRelatedHwnds.Clear();
			session.AdaptiveLightSampler?.Dispose();
			session.AdaptiveLightSampler = null;
			if (session.TopBarRenderHost != null && !((ContainerWorker<Component>)(object)session.TopBarRenderHost).IsDestroyed)
			{
				Msg("[Cleanup] Destroying top bar render host: " + session.TopBarRenderHost.Name);
				CleanupTrace($"TopBarRenderHost.Destroy START stream={session.StreamId}");
				try
				{
					session.TopBarRenderHost.Destroy();
				}
				catch (global::System.Exception ex2)
				{
					Msg("[Cleanup] Top bar render host destroy error: " + ex2.Message);
					CleanupTrace($"TopBarRenderHost.Destroy ERROR stream={session.StreamId}: {ex2}");
				}
				CleanupTrace($"TopBarRenderHost.Destroy DONE stream={session.StreamId}");
			}
			session.TopBarRenderHost = null;
			Msg("[Cleanup] Removing canvas ID");
			CleanupTrace($"Removing canvas/provider ids hwnd={session.Hwnd} streamId={session.StreamId}");
			if (session.Canvas != null)
			{
				DesktopCanvasIds.Remove(((Worker)session.Canvas).ReferenceID);
			}
			if (session.SharedTextureSlot >= 0 && TextureBridgeChannel != null)
			{
				long startTicks3 = TraceStart($"TextureBridge.StopTexture slot={session.SharedTextureSlot}");
				TextureBridgeChannel.StopTexture(session.SharedTextureSlot);
				TraceDone($"TextureBridge.StopTexture slot={session.SharedTextureSlot}", startTicks3);
				Msg($"[Cleanup] Stopped shared texture slot {session.SharedTextureSlot}");
			}
			if (session.Texture != null)
			{
				OurProviders.Remove(session.Texture);
				CleanupTrace("DesktopTextureProvider removed from provider set");
			}
			Msg("[Cleanup] Disconnecting encoder");
			CleanupTrace($"Disconnecting encoder START hwnd={session.Hwnd} streamId={session.StreamId}");
			DesktopStreamer streamer = session.Streamer;
			if (streamer != null)
			{
				Msg("[Cleanup] Detaching capture frame callback");
				CleanupTrace("Detach OnGpuFrame START");
				streamer.OnGpuFrame = null;
				CleanupTrace("Detach OnGpuFrame DONE");
			}
			CleanupTrace($"Shared stream driver-transfer START stream={session.StreamId}");
			TryTransferSharedStreamDriver(session, out var replacementDriver, out var replacementEncoder);
			if (replacementDriver != null)
			{
				CleanupTrace($"Replacement driver selected hwnd={replacementDriver.Hwnd} stream={session.StreamId}");
			}
			CleanupTrace($"Shared stream driver-transfer DONE stream={session.StreamId}");
			if (replacementDriver != null && replacementEncoder != null)
			{
				long startTicks4 = TraceStart($"ConnectEncoder replacement stream={session.StreamId}");
				ConnectEncoder(replacementDriver, replacementEncoder);
				TraceDone($"ConnectEncoder replacement stream={session.StreamId}", startTicks4);
				Msg($"[Cleanup] Transferred stream {session.StreamId} encoder driver to hwnd={replacementDriver.Hwnd}");
			}
			int streamId = session.StreamId;
			bool streamUsesMediaMtx = session.StreamUsesMediaMtx;
			nint hwnd = session.Hwnd;
			session.Streamer = null;
			CleanupTrace($"Session streamer nulled hwnd={hwnd} stream={streamId}");
			Msg($"[Cleanup] Queuing background dispose for stream {streamId}");
			CleanupTrace($"QueueUserWorkItem cleanup START stream={streamId}");
			ThreadPool.QueueUserWorkItem((WaitCallback)delegate
			{
				try
				{
					Msg($"[Cleanup:BG] === START === stream {streamId}");
					CleanupTrace($"BG cleanup ENTER stream={streamId} hwnd={hwnd}");
					AudioCapture audioToDispose = null;
					FfmpegEncoder encoderToDispose = null;
					ILiveStreamSource sourceToDispose = null;
					bool flag2 = false;
					if (streamer != null)
					{
						Msg("[Cleanup:BG] Stopping capture...");
						long startTicks5 = TraceStart($"DesktopStreamer.StopCapture stream={streamId}");
						streamer.StopCapture();
						TraceDone($"DesktopStreamer.StopCapture stream={streamId}", startTicks5);
						Msg("[Cleanup:BG] Capture stopped");
						try
						{
							Msg("[Cleanup:BG] Flushing D3D context...");
							long startTicks6 = TraceStart($"DesktopStreamer.FlushD3dContext stream={streamId}");
							streamer.FlushD3dContext();
							TraceDone($"DesktopStreamer.FlushD3dContext stream={streamId}", startTicks6);
							Msg("[Cleanup:BG] D3D context flushed");
						}
						catch (global::System.Exception ex3)
						{
							Msg("[Cleanup:BG] D3D flush error: " + ex3.Message);
						}
					}
					if (streamId > 0)
					{
						CleanupTrace($"BG shared stream release START stream={streamId}");
						flag2 = ReleaseSharedStreamReference(hwnd, streamId, session, out audioToDispose, out encoderToDispose, out sourceToDispose);
						CleanupTrace($"BG shared stream release DONE stream={streamId} shouldStopEncoder={flag2}");
						if (flag2)
						{
							Msg($"[Cleanup:BG] Stopping encoder {streamId}...");
							if (encoderToDispose != null)
							{
								long startTicks7 = TraceStart($"FfmpegEncoder.Stop stream={streamId}");
								encoderToDispose.Stop();
								TraceDone($"FfmpegEncoder.Stop stream={streamId}", startTicks7);
							}
							if (streamUsesMediaMtx)
							{
								if (encoderToDispose != null)
								{
									long startTicks8 = TraceStart($"FfmpegEncoder.Dispose stream={streamId}");
									encoderToDispose.Dispose();
									TraceDone($"FfmpegEncoder.Dispose stream={streamId}", startTicks8);
								}
								else if (sourceToDispose != null)
								{
									long startTicks9 = TraceStart($"StreamSource.Dispose stream={streamId}");
									((global::System.IDisposable)sourceToDispose).Dispose();
									TraceDone($"StreamSource.Dispose stream={streamId}", startTicks9);
								}
							}
							else if (StreamServer != null)
							{
								long startTicks10 = TraceStart($"BuiltInStreamServer.StopEncoder stream={streamId}");
								StreamServer.StopEncoder(streamId);
								TraceDone($"BuiltInStreamServer.StopEncoder stream={streamId}", startTicks10);
							}
							else if (encoderToDispose != null)
							{
								long startTicks11 = TraceStart($"FfmpegEncoder.Dispose stream={streamId}");
								encoderToDispose.Dispose();
								TraceDone($"FfmpegEncoder.Dispose stream={streamId}", startTicks11);
							}
							Msg($"[Cleanup:BG] Encoder {streamId} stopped");
						}
					}
					Msg("[Cleanup:BG] Disposing streamer...");
					long startTicks12 = TraceStart($"DesktopStreamer.Dispose stream={streamId}");
					streamer?.Dispose();
					TraceDone($"DesktopStreamer.Dispose stream={streamId}", startTicks12);
					Msg("[Cleanup:BG] Streamer disposed");
					if (audioToDispose != null)
					{
						Msg("[Cleanup:BG] Disposing audio...");
						long startTicks13 = TraceStart($"AudioCapture.Dispose stream={streamId}");
						audioToDispose.Dispose();
						TraceDone($"AudioCapture.Dispose stream={streamId}", startTicks13);
						Msg("[Cleanup:BG] Audio disposed");
					}
					Msg($"[Cleanup:BG] === DONE === stream {streamId}");
					CleanupTrace($"BG cleanup DONE stream={streamId}");
				}
				catch (global::System.Exception ex4)
				{
					Msg($"[Cleanup:BG] ERROR: {ex4}");
					CleanupTrace($"BG cleanup ERROR stream={streamId}: {ex4}");
				}
			});
			CleanupTrace($"QueueUserWorkItem cleanup DONE stream={streamId}");
			Msg($"[Cleanup] === END (bg queued) === stream {streamId}");
			CleanupTrace($"CleanupSession EXIT stream={streamId}");
		}

		private static void CleanupAndRemoveSession(DesktopSession session, string reason)
		{
			if (session != null)
			{
				Msg($"[Cleanup] Session cleanup requested: {reason} hwnd={session.Hwnd} streamId={session.StreamId}");
				if (!session.Cleaned)
				{
					CleanupSession(session);
				}
				ActiveSessions.Remove(session);
			}
		}

		private static void RetriggerDesktopTexture(DesktopTextureProvider provider)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			try
			{
				global::System.Type typeFromHandle = typeof(DesktopTextureProvider);
				FieldInfo field = typeFromHandle.GetField("_desktopTex", (BindingFlags)36);
				if (field == (FieldInfo)null)
				{
					return;
				}
				object value = field.GetValue((object)provider);
				DesktopTexture val = (DesktopTexture)((value is DesktopTexture) ? value : null);
				if (val != null)
				{
					MethodInfo method = typeFromHandle.GetMethod("OnTextureCreated", (BindingFlags)36);
					if (!(method == (MethodInfo)null))
					{
						Action val2 = (Action)global::System.Delegate.CreateDelegate(typeof(Action), (object)provider, method);
						val.Update(((SyncField<int>)(object)provider.DisplayIndex).Value, val2);
					}
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[RetriggerDesktopTexture] Error: " + ex.Message);
			}
		}

		private static void ApplySessionVisualResize(DesktopSession session, int width, int height)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (session != null && !session.Cleaned && width > 0 && height > 0)
			{
				if (session.Canvas != null && !((ComponentBase<Component>)(object)session.Canvas).IsDestroyed)
				{
					((SyncField<float2>)(object)session.Canvas.Size).Value = new float2((float)width, (float)height);
				}
				session.OnResize?.Invoke(width, height);
				Msg($"[UpdateLoop] Visual resize applied to {width}x{height}");
			}
		}

		private static void ConnectEncoder(DesktopSession session, FfmpegEncoder encoder, AudioCapture audioForEncoder = null, Action startAudioForEncoder = null)
		{
			if (encoder != null && session.Streamer != null)
			{
				if (audioForEncoder == null)
				{
					audioForEncoder = session.StreamAudioCapture ?? GetSharedStreamAudio(session.Hwnd);
				}
				if (startAudioForEncoder == null)
				{
					startAudioForEncoder = session.StartStreamAudioCapture ?? GetSharedStreamAudioStart(session.Hwnd);
				}
				FfmpegEncoder enc = encoder;
				object d3dContextLock = session.Streamer.D3dContextLock;
				nint d3dContext = session.Streamer.D3dContext;
				session.Streamer.OnGpuFrame = delegate(nint device, nint texture, int fw, int fh)
				{
					TryUpdateAdaptiveScreenLightFromGpuFrameNonBlocking(session, device, d3dContext, texture, fw, fh, d3dContextLock);
					enc.StartInitializeAsync(device, (uint)fw, (uint)fh, audioForEncoder, startAudioForEncoder, d3dContextLock);
					enc.QueueFrame(texture, (uint)fw, (uint)fh);
				};
				nint sharedTexture = session.Streamer.SharedTexture;
				int sharedTextureWidth = session.Streamer.SharedTextureWidth;
				int sharedTextureHeight = session.Streamer.SharedTextureHeight;
				nint d3dDevice = session.Streamer.D3dDevice;
				nint d3dContext2 = session.Streamer.D3dContext;
				if (sharedTexture != (nint)global::System.IntPtr.Zero && d3dDevice != (nint)global::System.IntPtr.Zero && sharedTextureWidth > 0 && sharedTextureHeight > 0)
				{
					TryUpdateAdaptiveScreenLightFromGpuFrameNonBlocking(session, d3dDevice, d3dContext2, sharedTexture, sharedTextureWidth, sharedTextureHeight, d3dContextLock);
					MarkEncoderInitialSourceSize(session, sharedTextureWidth, sharedTextureHeight);
					enc.StartInitializeAsync(d3dDevice, (uint)sharedTextureWidth, (uint)sharedTextureHeight, audioForEncoder, startAudioForEncoder, d3dContextLock);
					enc.QueueFrame(sharedTexture, (uint)sharedTextureWidth, (uint)sharedTextureHeight);
					Msg($"[RemoteStream] Seeded encoder from latest captured frame {sharedTextureWidth}x{sharedTextureHeight}");
				}
			}
		}

		private static void TryUpdateAdaptiveScreenLightFromGpuFrameNonBlocking(DesktopSession session, nint device, nint context, nint texture, int width, int height, object d3dContextLock)
		{
			if (context == (nint)global::System.IntPtr.Zero)
			{
				return;
			}
			if (d3dContextLock == null)
			{
				TryUpdateAdaptiveScreenLightFromGpuFrame(session, device, context, texture, width, height);
				return;
			}
			bool flag = false;
			try
			{
				Monitor.TryEnter(d3dContextLock, 0, ref flag);
				if (flag)
				{
					TryUpdateAdaptiveScreenLightFromGpuFrame(session, device, context, texture, width, height);
				}
			}
			finally
			{
				if (flag)
				{
					Monitor.Exit(d3dContextLock);
				}
			}
		}

		private static void MarkEncoderInitialSourceSize(DesktopSession session, int width, int height)
		{
			if (session != null && session.StreamId > 0 && width > 0 && height > 0 && (session.EncoderInitialStreamId != session.StreamId || session.EncoderInitialSourceW <= 0 || session.EncoderInitialSourceH <= 0))
			{
				session.EncoderInitialStreamId = session.StreamId;
				session.EncoderInitialSourceW = width;
				session.EncoderInitialSourceH = height;
			}
		}

		private static bool TryPublishCurrentSharedTexture(DesktopSession session)
		{
			if (session == null || !session.UseTextureBridge || !session.BridgeRegistrationPending)
			{
				return true;
			}
			DesktopStreamer streamer = session.Streamer;
			if (streamer == null || TextureBridgeChannel == null || !TextureBridgeChannel.IsOpen)
			{
				return false;
			}
			if (DesktopBuddyPlatform.IsLinux)
			{
				if (session.SharedTextureSlot < 0)
				{
					int num = TextureBridgeChannel.RegisterLinuxCapture((streamer.Width > 0) ? streamer.Width : session.LastKnownW, (streamer.Height > 0) ? streamer.Height : session.LastKnownH, streamer.LinuxPipeWireNodeId);
					if (num < 0)
					{
						return false;
					}
					session.SharedTextureSlot = num;
					Msg($"[UpdateLoop] Linux capture bridge registered: slot={num} {streamer.Width}x{streamer.Height}");
				}
				((SyncField<int>)(object)session.Texture.DisplayIndex).Value = -2147483648;
				session.PendingBridgeDisplayIndex = 10000 + session.SharedTextureSlot;
				session.BridgeDisplayIndexApplied = false;
				session.BridgeRegistrationPending = false;
				return true;
			}
			if (!streamer.HasCurrentSharedFrame || streamer.SharedTextureHandle == (nint)global::System.IntPtr.Zero || streamer.SharedTextureWidth <= 0 || streamer.SharedTextureHeight <= 0)
			{
				if (_updateCount % 30 == 0)
				{
					Msg($"[UpdateLoop] Waiting for current shared frame before bridge publish hwnd={session.Hwnd} pendingRecreate={streamer.IsResizeRecreatePending} size={streamer.Width}x{streamer.Height} shared=0x{((global::System.IntPtr)streamer.SharedTextureHandle).ToInt64():X} sharedSize={streamer.SharedTextureWidth}x{streamer.SharedTextureHeight}");
				}
				return false;
			}
			if (session.SharedTextureSlot < 0)
			{
				int num2 = TextureBridgeChannel.RegisterTexture(streamer.SharedTextureHandle, null, streamer.SharedTextureWidth, streamer.SharedTextureHeight);
				if (num2 < 0)
				{
					if (_updateCount % 60 == 0)
					{
						Msg($"[UpdateLoop] No free shared texture slots for hwnd={session.Hwnd}");
					}
					return false;
				}
				session.SharedTextureSlot = num2;
				Msg($"[UpdateLoop] Shared texture bridge registered: slot={num2} shared=0x{((global::System.IntPtr)streamer.SharedTextureHandle).ToInt64():X} {streamer.SharedTextureWidth}x{streamer.SharedTextureHeight}");
			}
			else
			{
				TextureBridgeChannel.UpdateTexture(session.SharedTextureSlot, streamer.SharedTextureHandle, null, streamer.SharedTextureWidth, streamer.SharedTextureHeight);
				Msg($"[UpdateLoop] Shared texture bridge updated: slot={session.SharedTextureSlot} shared=0x{((global::System.IntPtr)streamer.SharedTextureHandle).ToInt64():X} {streamer.SharedTextureWidth}x{streamer.SharedTextureHeight}");
			}
			((SyncField<int>)(object)session.Texture.DisplayIndex).Value = -2147483648;
			session.PendingBridgeDisplayIndex = 10000 + session.SharedTextureSlot;
			session.BridgeDisplayIndexApplied = false;
			session.BridgeRegistrationPending = false;
			return true;
		}

		private static bool ProcessSessionResizeAndEncoding(World world, DesktopSession session)
		{
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bf: Expected O, but got Unknown
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Expected O, but got Unknown
			//IL_0676: Unknown result type (might be due to invalid IL or missing references)
			//IL_067b: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			DesktopStreamer streamer = session.Streamer;
			if (streamer != null)
			{
				streamer.RecreatePoolIfNeeded();
				int width = streamer.Width;
				int height = streamer.Height;
				if (DesktopBuddyPlatform.IsLinux && session.UseTextureBridge)
				{
					if (session.BridgeRegistrationPending && !TryPublishCurrentSharedTexture(session))
					{
						return true;
					}
					if (session.SharedTextureSlot >= 0 && TextureBridgeChannel != null && TextureBridgeChannel.TryGetTextureSize(session.SharedTextureSlot, out var width2, out var height2) && width2 > 0 && height2 > 0 && (session.LastKnownW != width2 || session.LastKnownH != height2))
					{
						Msg($"[UpdateLoop] Linux renderer resize {session.LastKnownW}x{session.LastKnownH} -> {width2}x{height2}");
						session.LastKnownW = width2;
						session.LastKnownH = height2;
						ApplySessionVisualResize(session, width2, height2);
					}
					return false;
				}
				if (streamer.IsResizeRecreatePending && _updateCount % 30 == 0)
				{
					Msg($"[UpdateLoop] Resize recreate still pending hwnd={session.Hwnd} size={width}x{height} sharedSize={streamer.SharedTextureWidth}x{streamer.SharedTextureHeight}");
				}
				if (width > 0 && height > 0 && (session.LastKnownW != width || session.LastKnownH != height))
				{
					Msg($"[UpdateLoop] Window resize {session.LastKnownW}x{session.LastKnownH} -> {width}x{height}");
					session.LastKnownW = width;
					session.LastKnownH = height;
					if (session.UseTextureBridge && TextureBridgeChannel != null)
					{
						session.BridgeRegistrationPending = true;
					}
					else
					{
						ApplySessionVisualResize(session, width, height);
					}
					session.PendingResizeW = width;
					session.PendingResizeH = height;
					session.PendingVisualResizeW = width;
					session.PendingVisualResizeH = height;
					session.ResizeDebounceUntil = world.Time.WorldTime + 0.15;
					Msg($"[UpdateLoop] Resize pending: visual={width}x{height} encoder debounce=150ms");
					return true;
				}
				if (session.BridgeRegistrationPending && !TryPublishCurrentSharedTexture(session))
				{
					return true;
				}
			}
			if (session.PendingVisualResizeW > 0 && session.PendingVisualResizeH > 0)
			{
				int pendingVisualResizeW = session.PendingVisualResizeW;
				int pendingVisualResizeH = session.PendingVisualResizeH;
				if (session.SharedTextureSlot < 0 || TextureBridgeChannel == null || TextureBridgeChannel.IsTextureRunning(session.SharedTextureSlot, pendingVisualResizeW, pendingVisualResizeH))
				{
					ApplySessionVisualResize(session, pendingVisualResizeW, pendingVisualResizeH);
					session.PendingVisualResizeW = 0;
					session.PendingVisualResizeH = 0;
				}
				else
				{
					if (session.BridgeDisplayIndexApplied && _updateCount % 5 == 0)
					{
						RetriggerDesktopTexture(session.Texture);
					}
					if (_updateCount % 30 == 0)
					{
						Msg($"[UpdateLoop] Waiting for shared texture bind before visual resize {pendingVisualResizeW}x{pendingVisualResizeH}");
					}
				}
			}
			if (session.ResizeDebounceUntil > 0.0 && world.Time.WorldTime >= session.ResizeDebounceUntil)
			{
				session.ResizeDebounceUntil = 0.0;
				int pendingResizeW = session.PendingResizeW;
				int pendingResizeH = session.PendingResizeH;
				if (session.StreamId <= 0)
				{
					Msg($"[UpdateLoop] Resize debounce expired for local-only panel {pendingResizeW}x{pendingResizeH}, no encoder reinit");
					session.PendingResizeW = 0;
					session.PendingResizeH = 0;
					return true;
				}
				if (session.EncoderInitialStreamId == session.StreamId && session.EncoderInitialSourceW == pendingResizeW && session.EncoderInitialSourceH == pendingResizeH)
				{
					Msg($"[UpdateLoop] Resize debounce expired, encoder already initialized for {pendingResizeW}x{pendingResizeH}; skipping reinit");
					session.PendingResizeW = 0;
					session.PendingResizeH = 0;
					return true;
				}
				Msg($"[UpdateLoop] Resize debounce expired, reiniting encoder for {pendingResizeW}x{pendingResizeH}");
				if (session.Streamer != null)
				{
					session.Streamer.OnGpuFrame = null;
				}
				int oldStreamId = session.StreamId;
				bool oldUsesMediaMtx = session.StreamUsesMediaMtx;
				int num = NextStreamId();
				bool isMediaMtxEnabled = IsMediaMtxEnabled;
				FfmpegEncoder ffmpegEncoder;
				Uri val;
				if (isMediaMtxEnabled)
				{
					string mediaMtxRtspUrl = GetMediaMtxRtspUrl(num);
					ffmpegEncoder = new FfmpegEncoder(num, mediaMtxRtspUrl);
					val = new Uri(mediaMtxRtspUrl);
				}
				else
				{
					ffmpegEncoder = StreamServer?.CreateEncoder(num);
					val = ((StreamServer != null) ? GetBuiltInStreamUrl(num) : null);
				}
				FfmpegEncoder oldEncoder = session.Encoder;
				if (oldEncoder == null)
				{
					oldEncoder = GetSharedStreamEncoder(session.Hwnd);
				}
				DesktopStreamer oldStreamer = session.Streamer;
				ThreadPool.QueueUserWorkItem((WaitCallback)delegate
				{
					try
					{
						oldEncoder?.Stop();
						if (oldUsesMediaMtx)
						{
							oldEncoder?.Dispose();
						}
						else if (StreamServer != null)
						{
							StreamServer?.StopEncoder(oldStreamId);
						}
						else
						{
							oldEncoder?.Dispose();
						}
						oldStreamer?.FlushD3dContext();
					}
					catch (global::System.Exception ex)
					{
						Msg("[Resize:BG] Old encoder cleanup error: " + ex.Message);
					}
				});
				UpdateSharedStreamAfterResize(session.Hwnd, num, ffmpegEncoder, val, isMediaMtxEnabled);
				List<DesktopSession> val2 = Enumerable.ToList<DesktopSession>(Enumerable.Where<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)ActiveSessions, (Func<DesktopSession, bool>)((DesktopSession s) => s != null && !s.Cleaned && s.StreamId == oldStreamId)));
				if (!val2.Contains(session))
				{
					val2.Add(session);
				}
				Enumerator<DesktopSession> enumerator = val2.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						current.StreamId = num;
						current.Encoder = ffmpegEncoder;
						current.EncoderInitialStreamId = 0;
						current.EncoderInitialSourceW = 0;
						current.EncoderInitialSourceH = 0;
						current.StreamUsesMediaMtx = isMediaMtxEnabled;
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				ConnectEncoder(session, ffmpegEncoder);
				enumerator = val2.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current2 = enumerator.Current;
						if (current2.VideoTexture != null && !((ComponentBase<Component>)(object)current2.VideoTexture).IsDestroyed && val != (Uri)null)
						{
							Msg($"[UpdateLoop] Updating VTP URL: {((SyncField<Uri>)(object)current2.VideoTexture.URL).Value} -> {val}");
							SetRemoteStreamUrl(current2, val, $"encoder resize streamId={num}");
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				Msg($"[UpdateLoop] New encoder {num} created and connected for {pendingResizeW}x{pendingResizeH}");
				session.PendingResizeW = 0;
				session.PendingResizeH = 0;
			}
			return false;
		}

		private static void CleanupTrace(string message)
		{
			Log.Msg("[CleanupTrace] " + message);
		}

		private static long TraceStart(string label)
		{
			CleanupTrace(label + " START");
			return Stopwatch.GetTimestamp();
		}

		private static void TraceDone(string label, long startTicks)
		{
			double num = (double)(Stopwatch.GetTimestamp() - startTicks) * 1000.0 / (double)Stopwatch.Frequency;
			CleanupTrace($"{label} DONE {num:F2}ms");
		}

		internal static void ScheduleUpdate(World world)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!_scheduledWorlds.Contains(world))
			{
				_scheduledWorlds.Add(world);
				world.RunInUpdates(1, (Action)delegate
				{
					UpdateLoop(world);
				});
			}
		}

		private static void UpdateLoop(World world)
		{
			//IL_094b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0955: Expected O, but got Unknown
			//IL_0950: Unknown result type (might be due to invalid IL or missing references)
			//IL_075c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0766: Expected O, but got Unknown
			//IL_0761: Unknown result type (might be due to invalid IL or missing references)
			_updateCount++;
			double num = world.Time.Delta;
			bool flag = false;
			if (world.IsDestroyed)
			{
				Msg("[UpdateLoop] World destroyed, cleaning up sessions for this world");
				for (int num2 = ActiveSessions.Count - 1; num2 >= 0; num2--)
				{
					DesktopSession desktopSession = ActiveSessions[num2];
					if (desktopSession.Root == null || ((ContainerWorker<Component>)(object)desktopSession.Root).IsDestroyed || ((Worker)desktopSession.Root).World == world)
					{
						Msg($"[UpdateLoop] Cleaning up session {num2} (world destroyed)");
						CleanupSession(desktopSession);
						ActiveSessions.RemoveAt(num2);
					}
				}
				_scheduledWorlds.Remove(world);
				return;
			}
			try
			{
				ProcessWindowEvents(world);
				int num3 = -1;
				int num4 = -1;
				for (int num5 = ActiveSessions.Count - 1; num5 >= 0; num5--)
				{
					DesktopSession desktopSession2 = ActiveSessions[num5];
					if (desktopSession2.Cleaned)
					{
						ActiveSessions.RemoveAt(num5);
					}
					else if (desktopSession2.Root == null || ((ContainerWorker<Component>)(object)desktopSession2.Root).IsDestroyed || desktopSession2.Texture == null || ((ComponentBase<Component>)(object)desktopSession2.Texture).IsDestroyed)
					{
						Msg($"[UpdateLoop] Session {num5} root/texture destroyed, cleaning up (root={desktopSession2.Root != null} rootDestroyed={((ContainerWorker<Component>)(object)desktopSession2.Root)?.IsDestroyed} tex={desktopSession2.Texture != null} texDestroyed={((ComponentBase<Component>)(object)desktopSession2.Texture)?.IsDestroyed} hwnd={desktopSession2.Hwnd} streamId={desktopSession2.StreamId})");
						CleanupTrace($"UpdateLoop destroyed branch sessionIndex={num5} root={desktopSession2.Root != null} rootDestroyed={((ContainerWorker<Component>)(object)desktopSession2.Root)?.IsDestroyed} tex={desktopSession2.Texture != null} texDestroyed={((ComponentBase<Component>)(object)desktopSession2.Texture)?.IsDestroyed} hwnd={desktopSession2.Hwnd} streamId={desktopSession2.StreamId}");
						VideoTextureProvider videoTexture = desktopSession2.VideoTexture;
						if (videoTexture != null && !((ComponentBase<Component>)(object)videoTexture).IsDestroyed)
						{
							long startTicks = TraceStart($"VideoTexture stop stream={desktopSession2.StreamId}");
							((SyncField<Uri>)(object)videoTexture.URL).Value = null;
							videoTexture.Stop();
							TraceDone($"VideoTexture stop stream={desktopSession2.StreamId}", startTicks);
						}
						desktopSession2.VideoTexture = null;
						long startTicks2 = TraceStart($"CleanupSession call stream={desktopSession2.StreamId}");
						CleanupSession(desktopSession2);
						TraceDone($"CleanupSession call stream={desktopSession2.StreamId}", startTicks2);
						ActiveSessions.RemoveAt(num5);
						CleanupTrace($"ActiveSessions removed destroyed sessionIndex={num5}");
					}
					else
					{
						if (((Worker)desktopSession2.Root).World != world)
						{
							continue;
						}
						flag = true;
						if (desktopSession2.UpdateInProgress)
						{
							continue;
						}
						if (num3 < 0 && desktopSession2.VCamCamera != null && !((ComponentBase<Component>)(object)desktopSession2.VCamCamera).IsDestroyed)
						{
							num3 = num5;
						}
						if (num4 < 0 && desktopSession2.VMicListener != null && !((ComponentBase<Component>)(object)desktopSession2.VMicListener).IsDestroyed)
						{
							num4 = num5;
						}
						desktopSession2.TimeSinceValidCheck += num;
						if (desktopSession2.TimeSinceValidCheck >= 0.5)
						{
							desktopSession2.TimeSinceValidCheck = 0.0;
							bool flag2 = desktopSession2.Streamer == null || desktopSession2.Streamer.IsValid;
							bool flag3 = desktopSession2.StreamSource == null || desktopSession2.StreamSource.IsSourceAlive;
							desktopSession2.LastValidState = flag2 && flag3;
						}
						if (desktopSession2.Streamer != null && !desktopSession2.LastValidState)
						{
							Msg("[UpdateLoop] Window closed (IsValid=false), destroying viewer");
							VideoTextureProvider videoTexture2 = desktopSession2.VideoTexture;
							if (videoTexture2 != null && !((ComponentBase<Component>)(object)videoTexture2).IsDestroyed)
							{
								Msg("[UpdateLoop] Disconnecting VideoTextureProvider before cleanup");
								long startTicks3 = TraceStart($"VideoTexture stop invalid hwnd={desktopSession2.Hwnd} stream={desktopSession2.StreamId}");
								((SyncField<Uri>)(object)videoTexture2.URL).Value = null;
								videoTexture2.Stop();
								TraceDone($"VideoTexture stop invalid hwnd={desktopSession2.Hwnd} stream={desktopSession2.StreamId}", startTicks3);
							}
							long startTicks4 = TraceStart($"CleanupSession invalid hwnd={desktopSession2.Hwnd} stream={desktopSession2.StreamId}");
							CleanupSession(desktopSession2);
							TraceDone($"CleanupSession invalid hwnd={desktopSession2.Hwnd} stream={desktopSession2.StreamId}", startTicks4);
							ActiveSessions.RemoveAt(num5);
							Slot rootToDestroy = desktopSession2.Root;
							world.RunInUpdates(10, (Action)delegate
							{
								Msg("[UpdateLoop] Deferred destroy executing");
								if (rootToDestroy != null && !((ContainerWorker<Component>)(object)rootToDestroy).IsDestroyed)
								{
									rootToDestroy.DestroyChildren(false, true, false, (Predicate<Slot>)null);
									rootToDestroy.Destroy();
								}
								Msg("[UpdateLoop] Deferred destroy complete");
							});
						}
						else
						{
							if (ProcessSessionResizeAndEncoding(world, desktopSession2))
							{
								continue;
							}
							if (desktopSession2.PendingBridgeDisplayIndex >= 0 && !desktopSession2.BridgeDisplayIndexApplied)
							{
								if (TextureBridgeChannel == null || !TextureBridgeChannel.IsTextureRunning(desktopSession2.SharedTextureSlot))
								{
									if (_updateCount % 30 == 0)
									{
										Msg($"[UpdateLoop] Waiting for shared texture bind before applying DisplayIndex={desktopSession2.PendingBridgeDisplayIndex} slot={desktopSession2.SharedTextureSlot}");
									}
									continue;
								}
								((SyncField<int>)(object)desktopSession2.Texture.DisplayIndex).Value = desktopSession2.PendingBridgeDisplayIndex;
								desktopSession2.BridgeDisplayIndexApplied = true;
								Msg($"[UpdateLoop] Shared texture bridge ready; applying DisplayIndex={desktopSession2.PendingBridgeDisplayIndex} slot={desktopSession2.SharedTextureSlot}");
								RetriggerDesktopTexture(desktopSession2.Texture);
							}
							if (!((AssetProvider<DesktopTexture>)(object)desktopSession2.Texture).IsAssetAvailable)
							{
								if (_updateCount <= 5)
								{
									Msg("[UpdateLoop] Asset not available yet, waiting...");
								}
								if (desktopSession2.SharedTextureSlot >= 0 && desktopSession2.BridgeDisplayIndexApplied && _updateCount % 5 == 0)
								{
									RetriggerDesktopTexture(desktopSession2.Texture);
								}
							}
							else
							{
								TickVirtualCamera(desktopSession2, num5, num3);
								TickVirtualMic(desktopSession2, num5, num4);
								Perf.IncrementFrames();
							}
						}
					}
				}
			}
			catch (global::System.Exception ex)
			{
				Msg($"ERROR in UpdateLoop: {ex}");
				flag = HasSessionsInWorld(world);
			}
			if (flag)
			{
				world.RunInUpdates(1, (Action)delegate
				{
					UpdateLoop(world);
				});
			}
			else
			{
				Msg("[UpdateLoop] No sessions left for this world, stopping loop");
				_scheduledWorlds.Remove(world);
			}
		}

		private static bool HasSessionsInWorld(World world)
		{
			for (int i = 0; i < ActiveSessions.Count; i++)
			{
				Slot root = ActiveSessions[i].Root;
				if (((root != null) ? ((Worker)root).World : null) == world)
				{
					return true;
				}
			}
			return false;
		}

		private static void TickVirtualCamera(DesktopSession session, int sessionIndex, int lastVCamIdx)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			if (VCam != null && !VCam.ManuallyDisabled && VCam.ConsumerConnected && session.VCamCamera != null && !((ComponentBase<Component>)(object)session.VCamCamera).IsDestroyed && !session.VCamRenderPending && sessionIndex == lastVCamIdx)
			{
				long timestamp = Stopwatch.GetTimestamp();
				long num = Stopwatch.Frequency / 60;
				if (session.VCamLastSubmitTicks == 0L || timestamp - session.VCamLastSubmitTicks >= num)
				{
					session.VCamLastSubmitTicks = timestamp;
					session.VCamRenderPending = true;
					Camera vCamCamera = session.VCamCamera;
					VirtualCamera vcamRef = VCam;
					RenderTask renderSettings = vCamCamera.GetRenderSettings(new int2(1280, 720));
					renderSettings.parameters.textureFormat = (TextureFormat)16;
					((Worker)vCamCamera).World.Render.RenderToBitmap(renderSettings, true).ContinueWith((Action<global::System.Threading.Tasks.Task<Bitmap2D>>)delegate(global::System.Threading.Tasks.Task<Bitmap2D> task)
					{
						//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
						//IL_0103: Unknown result type (might be due to invalid IL or missing references)
						//IL_010e: Unknown result type (might be due to invalid IL or missing references)
						//IL_0067: Unknown result type (might be due to invalid IL or missing references)
						//IL_0085: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
						Bitmap2D val = null;
						try
						{
							if (!((global::System.Threading.Tasks.Task)task).IsFaulted && task.Result != null)
							{
								val = task.Result;
								if (((Bitmap)val).RawData.Length != 0)
								{
									if (vcamRef._logNextFrame)
									{
										vcamRef._logNextFrame = false;
										Log.Msg($"[VirtualCamera] Bitmap: {((Bitmap2DBase)val).Size.x}x{((Bitmap2DBase)val).Size.y} format={((Bitmap)val).Format} bpp={((Bitmap)val).BitsPerPixel} profile={((Bitmap)val).Profile}");
									}
									vcamRef.SendFrame(((Bitmap)val).RawData, ((Bitmap2DBase)val).Size.x, ((Bitmap2DBase)val).Size.y, ((Bitmap)val).Format);
								}
							}
						}
						finally
						{
							try
							{
								if (val != null)
								{
									((global::System.IDisposable)((Bitmap)val).Buffer)?.Dispose();
								}
							}
							catch
							{
							}
							session.VCamRenderPending = false;
						}
					});
				}
			}
			UpdateVirtualCameraIndicator(session);
		}

		private static void UpdateVirtualCameraIndicator(DesktopSession session)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (session.VCamIndicator != null && !((ComponentBase<Component>)(object)session.VCamIndicator).IsDestroyed && VCam != null)
			{
				bool flag = VCam.ConsumerConnected && !VCam.ManuallyDisabled;
				if (flag != session.VCamLastLitState)
				{
					session.VCamLastLitState = flag;
					((SyncField<colorX>)(object)session.VCamIndicator.Tint).Value = (flag ? new colorX(0.8f, 0.1f, 0.1f, 1f, (ColorProfile)1) : new colorX(0.05f, 0.05f, 0.05f, 1f, (ColorProfile)1));
				}
			}
		}

		private static void TickVirtualMic(DesktopSession session, int sessionIndex, int lastVMicIdx)
		{
			if ((VMic == null || !VMic.IsActive) && session.VMicListener != null && !((ComponentBase<Component>)(object)session.VMicListener).IsDestroyed && HasCachedVBCableInputDevice() && sessionIndex == lastVMicIdx)
			{
				VMic = new VirtualMic();
				if (VMic.Start())
				{
					AudioListener listener = session.VMicListener;
					VirtualMic mic = VMic;
					AudioSimulator simulator = ((Worker)session.Root).Engine.AudioSystem.Simulator;
					if (listener != null && simulator != null)
					{
						int frameSize = simulator.FrameSize;
						StereoSample[] stereoBuf = (StereoSample[])(object)new StereoSample[frameSize];
						float[] floatBuf = new float[frameSize * 2];
						simulator.RenderFinished += delegate(AudioSimulator sim)
						{
							if (!mic.Muted && !((ComponentBase<Component>)(object)listener).IsDestroyed)
							{
								global::System.Span<StereoSample> span = MemoryExtensions.AsSpan<StereoSample>(stereoBuf, 0, sim.FrameSize);
								span.Clear();
								listener.Read<StereoSample>(span, sim);
								for (int i = 0; i < span.Length; i++)
								{
									floatBuf[i * 2] = span[i].left;
									floatBuf[i * 2 + 1] = span[i].right;
								}
								mic.WriteGameAudio(MemoryExtensions.AsSpan<float>(floatBuf, 0, span.Length * 2));
							}
						};
						Msg($"[VirtualMic] Hooked AudioListener (frameSize={frameSize})");
					}
				}
				else
				{
					VMic.Dispose();
					VMic = null;
				}
			}
			if (VMic != null)
			{
				VMic.Muted = session.VMicMuted;
			}
		}

		private static bool HasCachedVBCableInputDevice()
		{
			long timestamp = Stopwatch.GetTimestamp();
			long num = Interlocked.Read(ref _lastVBCableInputCheckTicks);
			long num2 = (long)((double)Stopwatch.Frequency * 5.0);
			if (num != 0L && timestamp - num < num2)
			{
				return _lastVBCableInputPresent;
			}
			bool result = (_lastVBCableInputPresent = VBCable.HasCableInputDevice());
			Interlocked.Exchange(ref _lastVBCableInputCheckTicks, timestamp);
			return result;
		}

		private static void ProcessWindowEvents(World world)
		{
			int count = _windowEvents.Count;
			WindowEvent windowEvent = default(WindowEvent);
			for (int i = 0; i < count; i++)
			{
				if (!_windowEvents.TryDequeue(ref windowEvent))
				{
					break;
				}
				if (windowEvent.Session.Cleaned || windowEvent.Session.Root == null || ((ContainerWorker<Component>)(object)windowEvent.Session.Root).IsDestroyed)
				{
					continue;
				}
				if (((Worker)windowEvent.Session.Root).World != world)
				{
					_windowEvents.Enqueue(windowEvent);
					continue;
				}
				switch (windowEvent.EventType)
				{
				case WindowEventType.TitleChanged:
					windowEvent.Session.LastTitle = windowEvent.Title;
					if (windowEvent.Session.TitleText != null && !((ComponentBase<Component>)(object)windowEvent.Session.TitleText).IsDestroyed)
					{
						((SyncField<string>)(object)windowEvent.Session.TitleText.Text).Value = windowEvent.Title;
					}
					if (windowEvent.Session.Root != null && !((ContainerWorker<Component>)(object)windowEvent.Session.Root).IsDestroyed)
					{
						windowEvent.Session.Root.Name = "Desktop: " + windowEvent.Title;
					}
					break;
				case WindowEventType.NewTopLevelWindow:
				{
					DesktopBuddyConfig config = Config;
					string title;
					string reason;
					if (config != null && !config.GetValue(SpawnNewWindowsInGame))
					{
						Msg($"[WindowPoller] Ignored new window hwnd={windowEvent.WindowHwnd} title='{windowEvent.Title}': automatic new-window spawning disabled");
					}
					else if (!WindowEnumerator.TryValidateStandaloneProcessWindow(windowEvent.WindowHwnd, 0u, out title, out reason))
					{
						Msg($"[WindowPoller] Ignored new window hwnd={windowEvent.WindowHwnd} title='{windowEvent.Title}': {reason}");
					}
					else
					{
						string text = ((!string.IsNullOrWhiteSpace(title)) ? title : windowEvent.Title);
						bool flag = Config?.GetValue(SpawnNewWindowsPrivate) ?? true;
						Msg($"[WindowPoller] Detected new top-level window: hwnd={windowEvent.WindowHwnd} title='{text}' private={flag}");
						SpawnStreaming(((Worker)windowEvent.Session.Root).World, windowEvent.WindowHwnd, text, 0, -1, flag);
					}
					break;
				}
				}
			}
		}

		private static void EnsureAutoSpawnWindowBaseline(global::System.Collections.Generic.IEnumerable<WindowEnumerator.WindowInfo> openWindows = null, HashSet<nint> activeWindows = null)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			lock (AutoSpawnSeenWindows)
			{
				if (AutoSpawnWindowBaselineInitialized)
				{
					return;
				}
				try
				{
					if (openWindows == null)
					{
						openWindows = (global::System.Collections.Generic.IEnumerable<WindowEnumerator.WindowInfo>)WindowEnumerator.GetOpenWindows();
					}
					global::System.Collections.Generic.IEnumerator<WindowEnumerator.WindowInfo> enumerator = openWindows.GetEnumerator();
					try
					{
						while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
						{
							WindowEnumerator.WindowInfo current = enumerator.Current;
							if (current.Handle != (nint)global::System.IntPtr.Zero)
							{
								AutoSpawnSeenWindows.Add(current.Handle);
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator)?.Dispose();
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("[WindowPoller] Error building open-window baseline: " + ex.Message);
				}
				if (activeWindows != null)
				{
					Enumerator<nint> enumerator2 = activeWindows.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							nint current2 = enumerator2.Current;
							AutoSpawnSeenWindows.Add(current2);
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
				}
				AutoSpawnWindowBaselineInitialized = true;
				Msg($"[WindowPoller] Baseline open windows for auto-spawn: {AutoSpawnSeenWindows.Count}");
			}
		}

		private static void WindowPollerLoop()
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			List<DesktopSession> val3 = default(List<DesktopSession>);
			while (_windowPollerRunning)
			{
				Thread.Sleep(250);
				if (!_windowPollerRunning)
				{
					break;
				}
				DesktopSession[] array;
				try
				{
					array = ActiveSessions.ToArray();
				}
				catch
				{
					continue;
				}
				if (array.Length == 0)
				{
					lock (AutoSpawnSeenWindows)
					{
						AutoSpawnSeenWindows.Clear();
						AutoSpawnWindowBaselineInitialized = false;
					}
					continue;
				}
				HashSet<nint> val = new HashSet<nint>();
				DesktopSession desktopSession = null;
				DesktopSession[] array2 = array;
				foreach (DesktopSession desktopSession2 in array2)
				{
					if (!desktopSession2.Cleaned && desktopSession2.Root != null && !((ContainerWorker<Component>)(object)desktopSession2.Root).IsDestroyed)
					{
						if (desktopSession == null)
						{
							desktopSession = desktopSession2;
						}
						if (desktopSession2.Hwnd != (nint)global::System.IntPtr.Zero)
						{
							val.Add(desktopSession2.Hwnd);
						}
					}
				}
				Dictionary<uint, List<DesktopSession>> val2 = new Dictionary<uint, List<DesktopSession>>();
				array2 = array;
				foreach (DesktopSession desktopSession3 in array2)
				{
					if (!desktopSession3.Cleaned && desktopSession3.ProcessId != 0)
					{
						if (!val2.TryGetValue(desktopSession3.ProcessId, ref val3))
						{
							val3 = (val2[desktopSession3.ProcessId] = new List<DesktopSession>());
						}
						val3.Add(desktopSession3);
					}
				}
				Enumerator<uint, List<DesktopSession>> enumerator = val2.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						KeyValuePair<uint, List<DesktopSession>> current = enumerator.Current;
						if (!_windowPollerRunning)
						{
							break;
						}
						List<DesktopSession> value = current.Value;
						List<WindowEnumerator.WindowInfo> processWindows;
						try
						{
							processWindows = WindowEnumerator.GetProcessWindows(current.Key);
						}
						catch (global::System.Exception ex)
						{
							Msg($"[WindowPoller] Error enumerating PID {current.Key}: {ex.Message}");
							continue;
						}
						Enumerator<DesktopSession> enumerator2 = value.GetEnumerator();
						try
						{
							while (enumerator2.MoveNext())
							{
								DesktopSession current2 = enumerator2.Current;
								try
								{
									for (int j = 0; j < processWindows.Count; j++)
									{
										if (processWindows[j].Handle == current2.Hwnd && !string.IsNullOrEmpty(processWindows[j].Title))
										{
											if (processWindows[j].Title != current2.LastTitle)
											{
												_windowEvents.Enqueue(new WindowEvent
												{
													Session = current2,
													EventType = WindowEventType.TitleChanged,
													Title = processWindows[j].Title
												});
											}
											break;
										}
									}
								}
								catch (global::System.Exception ex2)
								{
									Msg($"[WindowPoller] Error for session hwnd={current2.Hwnd}: {ex2.Message}");
								}
							}
						}
						finally
						{
							((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (desktopSession == null)
				{
					continue;
				}
				DesktopBuddyConfig config = Config;
				if (config != null && !config.GetValue(SpawnNewWindowsInGame))
				{
					lock (AutoSpawnSeenWindows)
					{
						AutoSpawnSeenWindows.Clear();
						AutoSpawnWindowBaselineInitialized = false;
					}
					continue;
				}
				List<WindowEnumerator.WindowInfo> openWindows;
				try
				{
					openWindows = WindowEnumerator.GetOpenWindows();
				}
				catch (global::System.Exception ex3)
				{
					Msg("[WindowPoller] Error enumerating open windows: " + ex3.Message);
					continue;
				}
				lock (AutoSpawnSeenWindows)
				{
					if (!AutoSpawnWindowBaselineInitialized)
					{
						EnsureAutoSpawnWindowBaseline((global::System.Collections.Generic.IEnumerable<WindowEnumerator.WindowInfo>)openWindows, val);
						continue;
					}
					Enumerator<WindowEnumerator.WindowInfo> enumerator3 = openWindows.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							WindowEnumerator.WindowInfo current3 = enumerator3.Current;
							if (current3.Handle != (nint)global::System.IntPtr.Zero && !val.Contains(current3.Handle) && !WindowEnumerator.IsResoniteWindow(current3.Title) && !AutoSpawnSeenWindows.Contains(current3.Handle))
							{
								AutoSpawnSeenWindows.Add(current3.Handle);
								_windowEvents.Enqueue(new WindowEvent
								{
									Session = desktopSession,
									EventType = WindowEventType.NewTopLevelWindow,
									WindowHwnd = current3.Handle,
									Title = current3.Title
								});
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
		}

		private static void CreateViewerCullingGate(DesktopSession session, Slot streamSlot, VideoTextureProvider videoTex, User owner)
		{
			if (session == null || streamSlot == null || videoTex == null)
			{
				return;
			}
			Slot obj = session.Root.AddSlot("ViewerCullingGate", true);
			ValueField<bool> val = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueField<bool>>(true, (Action<ValueField<bool>>)null);
			((SyncField<bool>)(object)val.Value).Value = true;
			ValueUserOverride<bool> val2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueUserOverride<bool>>(true, (Action<ValueUserOverride<bool>>)null);
			((SyncRef<IField<bool>>)(object)val2.Target).Target = (IField<bool>)(object)val.Value;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val2).Default).Value = true;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val2).CreateOverrideOnWrite).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val2).ClearOnUserLeave).Value = true;
			ValueField<bool> val3 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueField<bool>>(true, (Action<ValueField<bool>>)null);
			((SyncField<bool>)(object)val3.Value).Value = false;
			ValueUserOverride<bool> val4 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueUserOverride<bool>>(true, (Action<ValueUserOverride<bool>>)null);
			((SyncRef<IField<bool>>)(object)val4.Target).Target = (IField<bool>)(object)val3.Value;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).Default).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).CreateOverrideOnWrite).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val4).ClearOnUserLeave).Value = true;
			ValueField<bool> val5 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueField<bool>>(true, (Action<ValueField<bool>>)null);
			((SyncField<bool>)(object)val5.Value).Value = false;
			ValueUserOverride<bool> val6 = ((ContainerWorker<Component>)(object)obj).AttachComponent<ValueUserOverride<bool>>(true, (Action<ValueUserOverride<bool>>)null);
			((SyncRef<IField<bool>>)(object)val6.Target).Target = (IField<bool>)(object)val5.Value;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val6).Default).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val6).CreateOverrideOnWrite).Value = false;
			((SyncField<bool>)(object)((ValueOverrideBase<bool>)(object)val6).ClearOnUserLeave).Value = true;
			BooleanValueDriver<Uri> val7 = ((ContainerWorker<Component>)(object)obj).AttachComponent<BooleanValueDriver<Uri>>(true, (Action<BooleanValueDriver<Uri>>)null);
			((SyncRef<IField<Uri>>)(object)val7.TargetField).Target = (IField<Uri>)(object)videoTex.URL;
			((SyncField<Uri>)(object)val7.FalseValue).Value = null;
			((SyncField<Uri>)(object)val7.TrueValue).Value = null;
			ValueCopyExtensions.DriveFrom<bool>((IField<bool>)(object)val7.State, (IField<bool>)(object)val5.Value, false, false, true);
			session.ViewerAllowedField = val;
			session.PreviewAllowedField = val3;
			session.FinalStreamAllowedField = val5;
			session.ViewerStreamAllowed = val2;
			session.PreviewStreamAllowed = val4;
			session.FinalStreamAllowedOverride = val6;
			session.StreamUrlDriver = val7;
			((ValueOverrideBase<bool>)(object)val2).SetOverride(owner, false);
			((ValueOverrideBase<bool>)(object)val4).SetOverride(owner, false);
			global::System.Collections.Generic.IEnumerator<User> enumerator = Enumerable.Where<User>((global::System.Collections.Generic.IEnumerable<User>)((Worker)session.Root).World.AllUsers, (Func<User, bool>)((User u) => u.IsPresentInWorld)).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					User current = enumerator.Current;
					if (current == owner)
					{
						((ValueOverrideBase<bool>)(object)val2).SetOverride(current, false);
					}
					else if (IsViewerStreamEnabled(session, current))
					{
						((ValueOverrideBase<bool>)(object)val2).SetOverride(current, true);
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			StartViewerCullingPlaybackLoop(session, videoTex);
		}

		private static bool IsLocalSessionOwner(DesktopSession session)
		{
			object obj;
			if (session == null)
			{
				obj = null;
			}
			else
			{
				Slot root = session.Root;
				if (root == null)
				{
					obj = null;
				}
				else
				{
					World world = ((Worker)root).World;
					obj = ((world != null) ? world.LocalUser : null);
				}
			}
			User val = (User)obj;
			if (session == null || val == null)
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(session.OwnerUserId) && string.Equals(session.OwnerUserId, val.UserID, (StringComparison)5))
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(session.OwnerUserId))
			{
				return val == ((Worker)session.Root).World.LocalUser;
			}
			return false;
		}

		private static bool IsSessionOwner(DesktopSession session, User user)
		{
			if (session == null || user == null)
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(session.OwnerUserId) && string.Equals(session.OwnerUserId, user.UserID, (StringComparison)5))
			{
				return true;
			}
			if (string.IsNullOrWhiteSpace(session.OwnerUserId))
			{
				Slot root = session.Root;
				object obj;
				if (root == null)
				{
					obj = null;
				}
				else
				{
					World world = ((Worker)root).World;
					obj = ((world != null) ? world.LocalUser : null);
				}
				return user == obj;
			}
			return false;
		}

		private static string LocalViewerKey(User user)
		{
			if (!string.IsNullOrWhiteSpace((user != null) ? user.UserID : null))
			{
				return user.UserID;
			}
			if (user == null)
			{
				return null;
			}
			return user.UserName;
		}

		private static bool IsLocalViewerStreamEnabled(DesktopSession session)
		{
			object obj;
			if (session == null)
			{
				obj = null;
			}
			else
			{
				Slot root = session.Root;
				if (root == null)
				{
					obj = null;
				}
				else
				{
					World world = ((Worker)root).World;
					obj = ((world != null) ? world.LocalUser : null);
				}
			}
			User val = (User)obj;
			if (session == null || val == null || IsLocalSessionOwner(session))
			{
				return false;
			}
			string text = LocalViewerKey(val);
			bool flag = default(bool);
			return string.IsNullOrWhiteSpace(text) || !session.ViewerStreamEnabledByUserId.TryGetValue(text, ref flag) || flag;
		}

		private static bool ShouldLocalStreamBeAllowedWithoutGrace(DesktopSession session)
		{
			if (session?.ViewerAllowedField == null || session.PreviewAllowedField == null)
			{
				return true;
			}
			bool localPreviewingRemoteStream = session.LocalPreviewingRemoteStream;
			bool flag = IsLocalViewerStreamEnabled(session);
			Slot root = session.Root;
			object user;
			if (root == null)
			{
				user = null;
			}
			else
			{
				World world = ((Worker)root).World;
				user = ((world != null) ? world.LocalUser : null);
			}
			if (IsViewerInConfiguredRange(session, (User)user))
			{
				return localPreviewingRemoteStream || flag;
			}
			return false;
		}

		private static bool IsLocalStreamAllowedByGraceGate(DesktopSession session)
		{
			if (session?.FinalStreamAllowedField == null || ((ComponentBase<Component>)(object)session.FinalStreamAllowedField).IsDestroyed)
			{
				return ShouldLocalStreamBeAllowedWithoutGrace(session);
			}
			return ((SyncField<bool>)(object)session.FinalStreamAllowedField.Value).Value;
		}

		private static void SetLocalStreamAllowedByGraceGate(DesktopSession session, bool allowed)
		{
			if (session?.FinalStreamAllowedField != null && !((ComponentBase<Component>)(object)session.FinalStreamAllowedField).IsDestroyed && ((SyncField<bool>)(object)session.FinalStreamAllowedField.Value).Value != allowed)
			{
				Slot root = session.Root;
				object obj;
				if (root == null)
				{
					obj = null;
				}
				else
				{
					World world = ((Worker)root).World;
					obj = ((world != null) ? world.LocalUser : null);
				}
				User val = (User)obj;
				if (session.FinalStreamAllowedOverride != null && !((ComponentBase<Component>)(object)session.FinalStreamAllowedOverride).IsDestroyed && val != null)
				{
					((ValueOverrideBase<bool>)(object)session.FinalStreamAllowedOverride).SetOverride(val, allowed);
				}
				else
				{
					((SyncField<bool>)(object)session.FinalStreamAllowedField.Value).Value = allowed;
				}
			}
		}

		private static bool GetAppliedStreamAllowed(DesktopSession session, User user)
		{
			string text = ViewerKey(user);
			bool flag = default(bool);
			return !string.IsNullOrWhiteSpace(text) && session.CullingAppliedStreamAllowedByUserId.TryGetValue(text, ref flag) && flag;
		}

		private static void SetStreamAllowedForUser(DesktopSession session, User user, bool allowed)
		{
			string text = ViewerKey(user);
			bool flag = default(bool);
			if (!string.IsNullOrWhiteSpace(text) && (!session.CullingAppliedStreamAllowedByUserId.TryGetValue(text, ref flag) || flag != allowed))
			{
				session.CullingAppliedStreamAllowedByUserId[text] = allowed;
				if (session.FinalStreamAllowedOverride != null && !((ComponentBase<Component>)(object)session.FinalStreamAllowedOverride).IsDestroyed)
				{
					((ValueOverrideBase<bool>)(object)session.FinalStreamAllowedOverride).SetOverride(user, allowed);
				}
			}
		}

		private static float GetCurvedPanelDepthAtU(CurvedPlaneMesh mesh, float u, float scale)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (mesh == null || ((ComponentBase<Component>)(object)mesh).IsDestroyed)
			{
				return 0f;
			}
			float num = MathX.Clamp01(((SyncField<float>)(object)mesh.Curvature).Value);
			if (num < 0.01f)
			{
				return 0f;
			}
			float2 value = ((SyncField<float2>)(object)mesh.Size).Value;
			float num2 = CurvedPlaneMesh.CompensateSize(ref value, num, ((SyncField<CurvatureAspectRatioCompensation>)(object)mesh.AspectRatioCompensation).Value).x * 0.5f;
			float num3 = (float)Math.PI * num;
			float num4 = ((float)Math.PI - num3) * 0.5f;
			return (MathX.Sin(num4 + num3 * MathX.Clamp01(u)) * num2 - MathX.Sin(num4) * num2) * scale;
		}

		private static bool TryGetCurvedPlaneUV(CurvedPlaneMesh mesh, in float3 globalPoint, out float2 uv)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			uv = default(float2);
			if (mesh == null || ((ComponentBase<Component>)(object)mesh).IsDestroyed)
			{
				return false;
			}
			float3 val = ((Component)mesh).Slot.GlobalPointToLocal(ref globalPoint);
			float num = MathX.Clamp01(((SyncField<float>)(object)mesh.Curvature).Value);
			float2 value = ((SyncField<float2>)(object)mesh.Size).Value;
			float2 val2 = CurvedPlaneMesh.CompensateSize(ref value, num, ((SyncField<CurvatureAspectRatioCompensation>)(object)mesh.AspectRatioCompensation).Value);
			if (val2.x <= 0f || val2.y <= 0f)
			{
				return false;
			}
			float num2;
			if (num < 0.01f)
			{
				num2 = val.x / val2.x + 0.5f;
			}
			else
			{
				float num3 = val2.x * 0.5f;
				float num4 = (float)Math.PI * num;
				float num5 = ((float)Math.PI - num4) * 0.5f;
				float num6 = 1f / MathX.Cos(num5);
				num2 = (MathF.Acos(MathX.Clamp(val.x / ((0f - num6) * num3), -1f, 1f)) - num5) / num4;
			}
			float num7 = 0.5f - val.y / val2.y;
			uv = new float2(MathX.Clamp01(num2), MathX.Clamp01(num7));
			return true;
		}

		private static void StartViewerCullingPlaybackLoop(DesktopSession session, VideoTextureProvider videoTex)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			DesktopSession desktopSession = session;
			object obj;
			if (desktopSession == null)
			{
				obj = null;
			}
			else
			{
				Slot root = desktopSession.Root;
				obj = ((root != null) ? ((Worker)root).World : null);
			}
			int generation;
			if (obj != null && videoTex != null)
			{
				generation = ++session.CullingGateGeneration;
				session.CullingOutOfRangeSince = -1.0;
				session.CullingAppliedStreamAllowedByUserId.Clear();
				session.CullingOutOfRangeSinceByUserId.Clear();
				session.CullingPresentUserIds.Clear();
				session.CullingStaleUserIds.Clear();
				((Worker)session.Root).World.RunInUpdates(1, new Action(Tick));
			}
			void Tick()
			{
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: 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_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c0: Expected O, but got Unknown
				//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
				if (session.Root != null && !((ContainerWorker<Component>)(object)session.Root).IsDestroyed && !((ComponentBase<Component>)(object)videoTex).IsDestroyed && generation == session.CullingGateGeneration)
				{
					double worldTime = ((Worker)session.Root).World.Time.WorldTime;
					HashSet<string> cullingPresentUserIds = session.CullingPresentUserIds;
					List<string> cullingStaleUserIds = session.CullingStaleUserIds;
					cullingPresentUserIds.Clear();
					cullingStaleUserIds.Clear();
					bool flag = false;
					Enumerator<RefID, User> enumerator = ((Worker)session.Root).World.AllUsers.GetEnumerator();
					try
					{
						double num = default(double);
						while (enumerator.MoveNext())
						{
							User current = enumerator.Current;
							if (current.IsPresentInWorld)
							{
								string text = ViewerKey(current);
								if (!string.IsNullOrWhiteSpace(text))
								{
									cullingPresentUserIds.Add(text);
									bool flag2 = (IsSessionOwner(session, current) ? session.LocalPreviewingRemoteStream : IsViewerStreamEnabled(session, current));
									bool flag3 = IsViewerInConfiguredRange(session, current);
									bool appliedStreamAllowed = GetAppliedStreamAllowed(session, current);
									bool flag4;
									if (flag2 && flag3)
									{
										session.CullingOutOfRangeSinceByUserId.Remove(text);
										flag4 = true;
									}
									else if (flag2 && appliedStreamAllowed)
									{
										if (!session.CullingOutOfRangeSinceByUserId.TryGetValue(text, ref num))
										{
											num = worldTime;
											session.CullingOutOfRangeSinceByUserId[text] = num;
										}
										flag4 = worldTime - num < 5.0;
									}
									else
									{
										session.CullingOutOfRangeSinceByUserId.Remove(text);
										flag4 = false;
									}
									SetStreamAllowedForUser(session, current, flag4);
									flag = flag || flag4;
								}
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
					Enumerator<string, bool> enumerator2 = session.CullingAppliedStreamAllowedByUserId.Keys.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							string current2 = enumerator2.Current;
							if (!cullingPresentUserIds.Contains(current2))
							{
								cullingStaleUserIds.Add(current2);
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
					Enumerator<string> enumerator3 = cullingStaleUserIds.GetEnumerator();
					try
					{
						while (enumerator3.MoveNext())
						{
							string current3 = enumerator3.Current;
							session.CullingAppliedStreamAllowedByUserId.Remove(current3);
							session.CullingOutOfRangeSinceByUserId.Remove(current3);
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
					}
					if (flag)
					{
						if (!videoTex.IsPlaying)
						{
							videoTex.Play();
						}
					}
					else if (videoTex.IsPlaying)
					{
						videoTex.Stop();
					}
					((Worker)session.Root).World.RunInUpdates(2, new Action(Tick));
				}
			}
		}

		private static bool IsLocalStreamPlaybackAllowedNow(DesktopSession session)
		{
			if (session?.StreamUrlDriver != null && !((ComponentBase<Component>)(object)session.StreamUrlDriver).IsDestroyed)
			{
				return true;
			}
			return IsLocalStreamAllowedByGraceGate(session);
		}

		private static void SetRemoteStreamUrl(DesktopSession session, Uri url, string reason)
		{
			VideoTextureProvider val = session?.VideoTexture;
			if (val != null && !((ComponentBase<Component>)(object)val).IsDestroyed)
			{
				session.StreamUrl = url;
				if (session.StreamUrlDriver != null && !((ComponentBase<Component>)(object)session.StreamUrlDriver).IsDestroyed)
				{
					((SyncField<Uri>)(object)session.StreamUrlDriver.FalseValue).Value = null;
					((SyncField<Uri>)(object)session.StreamUrlDriver.TrueValue).Value = url;
				}
				else
				{
					((SyncField<Uri>)(object)val.URL).Value = url;
				}
				if (!val.IsPlaying)
				{
					val.Play();
				}
				if (!string.IsNullOrWhiteSpace(reason))
				{
					Msg($"[RemoteStream] URL set ({reason}): {url}");
				}
			}
		}

		private static void ClearRemoteStreamUrl(DesktopSession session, string reason)
		{
			VideoTextureProvider val = session?.VideoTexture;
			if (val != null && !((ComponentBase<Component>)(object)val).IsDestroyed)
			{
				session.StreamUrl = null;
				if (val.IsPlaying)
				{
					val.Stop();
				}
				if (session.StreamUrlDriver != null && !((ComponentBase<Component>)(object)session.StreamUrlDriver).IsDestroyed)
				{
					((SyncField<Uri>)(object)session.StreamUrlDriver.TrueValue).Value = null;
				}
				((SyncField<Uri>)(object)val.URL).Value = null;
				if (!string.IsNullOrWhiteSpace(reason))
				{
					Msg("[RemoteStream] URL cleared (" + reason + ")");
				}
			}
		}

		private static SharedStream AcquireSharedStream(nint hwnd, bool useMediaMtx, uint linuxPipeWireNodeId = 0u, int width = 0, int height = 0)
		{
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (hwnd != (nint)global::System.IntPtr.Zero && _sharedStreams.TryGetValue(hwnd, ref sharedStream))
				{
					Msg($"[RemoteStream] Reusing shared stream {sharedStream.StreamId} for hwnd={hwnd} (refs={sharedStream.RefCount})");
					sharedStream.RefCount++;
					return sharedStream;
				}
				int num = NextStreamId();
				FfmpegEncoder ffmpegEncoder = null;
				ILiveStreamSource source;
				Uri val;
				if (DesktopBuddyPlatform.IsLinux)
				{
					string text = (useMediaMtx ? GetMediaMtxRtspUrl(num) : null);
					LinuxNativeStreamSource linuxNativeStreamSource = new LinuxNativeStreamSource(num, text);
					source = linuxNativeStreamSource;
					val = (Uri)((text == null) ? ((object)GetBuiltInStreamUrl(num)) : ((object)new Uri(text)));
					if (!useMediaMtx)
					{
						StreamServer?.RegisterSource(num, linuxNativeStreamSource);
					}
					if (!linuxNativeStreamSource.Start(linuxPipeWireNodeId))
					{
						Msg($"[RemoteStream] Linux native stream did not start stream={num} node={linuxPipeWireNodeId}");
					}
					else if (useMediaMtx)
					{
						Msg("[RemoteStream] Using Linux native MediaMTX RTSP: " + text);
					}
					else
					{
						Msg($"[RemoteStream] Using Linux native built-in HTTP stream: {val}");
					}
				}
				else if (useMediaMtx)
				{
					string mediaMtxRtspUrl = GetMediaMtxRtspUrl(num);
					ffmpegEncoder = new FfmpegEncoder(num, mediaMtxRtspUrl);
					source = ffmpegEncoder;
					val = new Uri(mediaMtxRtspUrl);
					Msg("[RemoteStream] Using MediaMTX RTSP: " + mediaMtxRtspUrl);
				}
				else
				{
					ffmpegEncoder = StreamServer.CreateEncoder(num);
					source = ffmpegEncoder;
					val = GetBuiltInStreamUrl(num);
					Msg($"[RemoteStream] Using built-in HTTP stream: {val}");
				}
				AudioCapture audioCapture = (DesktopBuddyPlatform.IsLinux ? null : new AudioCapture());
				Action startAudio = ((audioCapture != null) ? CreateAudioStartAction(audioCapture, hwnd) : null);
				sharedStream = new SharedStream
				{
					StreamId = num,
					Encoder = ffmpegEncoder,
					Source = source,
					UsesMediaMtx = useMediaMtx,
					Audio = audioCapture,
					StartAudio = startAudio,
					StreamUrl = val,
					RefCount = 1
				};
				if (hwnd != (nint)global::System.IntPtr.Zero)
				{
					_sharedStreams[hwnd] = sharedStream;
				}
				Msg($"[RemoteStream] Created new shared stream {num} for hwnd={hwnd}");
				return sharedStream;
			}
		}

		private static Action CreateAudioStartAction(AudioCapture audio, nint hwnd)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			int started = 0;
			return (Action)delegate
			{
				if (audio == null || audio.IsCapturing || Interlocked.Exchange(ref started, 1) != 0)
				{
					return;
				}
				try
				{
					if (hwnd != (nint)global::System.IntPtr.Zero)
					{
						audio.Start(hwnd, AudioCaptureMode.IncludeProcess);
					}
					else
					{
						audio.Start(global::System.IntPtr.Zero, AudioCaptureMode.ExcludeProcess);
					}
				}
				catch (global::System.Exception ex)
				{
					Msg($"[AudioCapture] Async start error: {ex}");
				}
			};
		}

		private static AudioCapture GetSharedStreamAudio(nint hwnd)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				return _sharedStreams.TryGetValue(hwnd, ref sharedStream) ? sharedStream.Audio : null;
			}
		}

		private static Action GetSharedStreamAudioStart(nint hwnd)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				return _sharedStreams.TryGetValue(hwnd, ref sharedStream) ? sharedStream.StartAudio : null;
			}
		}

		private static FfmpegEncoder GetSharedStreamEncoder(nint hwnd)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				return _sharedStreams.TryGetValue(hwnd, ref sharedStream) ? sharedStream.Encoder : null;
			}
		}

		private static Uri GetSharedStreamUrl(nint hwnd, int streamId)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (_sharedStreams.TryGetValue(hwnd, ref sharedStream) && sharedStream.StreamId == streamId)
				{
					return sharedStream.StreamUrl;
				}
				return null;
			}
		}

		private static DesktopSession GetSharedStreamDriver(nint hwnd, int streamId)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (_sharedStreams.TryGetValue(hwnd, ref sharedStream) && sharedStream.StreamId == streamId && sharedStream.DriverSession != null && !sharedStream.DriverSession.Cleaned && sharedStream.DriverSession.Streamer != null)
				{
					return sharedStream.DriverSession;
				}
				return null;
			}
		}

		private static bool TryClaimSharedStreamDriver(nint hwnd, int streamId, DesktopSession session)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (!_sharedStreams.TryGetValue(hwnd, ref sharedStream) || sharedStream.StreamId != streamId)
				{
					return true;
				}
				int num;
				if (sharedStream.DriverSession != null && !sharedStream.DriverSession.Cleaned)
				{
					num = ((sharedStream.DriverSession.Streamer == null) ? 1 : 0);
					if (num == 0)
					{
						goto IL_005c;
					}
				}
				else
				{
					num = 1;
				}
				sharedStream.DriverSession = session;
				goto IL_005c;
				IL_005c:
				return (byte)num != 0;
			}
		}

		private static bool TryTransferSharedStreamDriver(DesktopSession session, out DesktopSession replacementDriver, out FfmpegEncoder replacementEncoder)
		{
			//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)
			replacementDriver = null;
			replacementEncoder = null;
			if (session.StreamId <= 0)
			{
				return false;
			}
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (!_sharedStreams.TryGetValue(session.Hwnd, ref sharedStream) || sharedStream.StreamId != session.StreamId || sharedStream.DriverSession != session)
				{
					return false;
				}
				sharedStream.DriverSession = null;
				Enumerator<DesktopSession> enumerator = ActiveSessions.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						if (current != session && !current.Cleaned && current.Hwnd == session.Hwnd && current.StreamId == session.StreamId && current.Streamer != null)
						{
							replacementDriver = current;
							replacementEncoder = sharedStream.Encoder;
							sharedStream.DriverSession = current;
							return true;
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			return false;
		}

		private static void UpdateSharedStreamAfterResize(nint hwnd, int newStreamId, FfmpegEncoder newEncoder, Uri newUrl, bool useMediaMtx)
		{
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (_sharedStreams.TryGetValue(hwnd, ref sharedStream))
				{
					sharedStream.StreamId = newStreamId;
					sharedStream.Encoder = newEncoder;
					sharedStream.UsesMediaMtx = useMediaMtx;
					if (newUrl != (Uri)null)
					{
						sharedStream.StreamUrl = newUrl;
					}
				}
			}
		}

		private static bool ReleaseSharedStreamReference(nint hwnd, int streamId, DesktopSession session, out AudioCapture audioToDispose, out FfmpegEncoder encoderToDispose, out ILiveStreamSource sourceToDispose)
		{
			audioToDispose = null;
			encoderToDispose = null;
			sourceToDispose = null;
			lock (_sharedStreams)
			{
				SharedStream sharedStream = default(SharedStream);
				if (_sharedStreams.TryGetValue(hwnd, ref sharedStream) && sharedStream.StreamId == streamId)
				{
					sharedStream.RefCount--;
					Msg($"[Cleanup:BG] Stream {sharedStream.StreamId} refs now {sharedStream.RefCount}");
					if (sharedStream.RefCount <= 0)
					{
						_sharedStreams.Remove(hwnd);
						audioToDispose = sharedStream.Audio;
						encoderToDispose = sharedStream.Encoder;
						sourceToDispose = sharedStream.Source;
						return true;
					}
					if (sharedStream.DriverSession == session)
					{
						sharedStream.DriverSession = null;
					}
					return false;
				}
				encoderToDispose = session.Encoder;
				sourceToDispose = session.StreamSource;
				return true;
			}
		}

		private static CurvedPlaneMesh AddCurvedTexturePlane(Slot parent, string name, int width, int height, float scale, IAssetProvider<ITexture2D> texture, float zOffset, bool flipY, float offsetUnits)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			Slot obj = parent.AddSlot(name, true);
			obj.LocalPosition = new float3(0f, 0f, zOffset);
			float3 one = float3.One;
			obj.LocalScale = (ref one) * scale;
			MeshRenderer val = ((ContainerWorker<Component>)(object)obj).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			CurvedPlaneMesh val2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)val2.Size).Value = new float2((float)width, (float)height);
			((SyncField<float>)(object)val2.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)val2.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)val2.Segments).Value = 48;
			((SyncRef<IAssetProvider<Mesh>>)(object)val.Mesh).Target = (IAssetProvider<Mesh>)(object)val2;
			MeshCollider obj2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<MeshCollider>(true, (Action<MeshCollider>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)((MeshBasedCollider<Mesh, MeshColliderData>)(object)obj2).Mesh).Target = (IAssetProvider<Mesh>)(object)val2;
			((SyncField<MeshColliderSidedness>)(object)obj2.Sidedness).Value = (MeshColliderSidedness)0;
			UnlitMaterial val3 = ((ContainerWorker<Component>)(object)obj).AttachComponent<UnlitMaterial>(true, (Action<UnlitMaterial>)null);
			((SyncRef<IAssetProvider<ITexture2D>>)(object)val3.Texture).Target = texture;
			((SyncField<BlendMode>)(object)val3.BlendMode).Value = (BlendMode)0;
			((SyncField<Sidedness>)(object)val3.Sidedness).Value = (Sidedness)3;
			((SyncField<ZWrite>)(object)val3.ZWrite).Value = (ZWrite)2;
			((SyncField<float>)(object)val3.OffsetUnits).Value = offsetUnits;
			if (flipY)
			{
				((SyncField<float2>)(object)val3.TextureScale).Value = new float2(1f, -1f);
				((SyncField<float2>)(object)val3.TextureOffset).Value = new float2(0f, 1f);
			}
			val.Materials.Add((IAssetProvider<Material>)(object)val3);
			return val2;
		}

		private static CurvedPlaneMesh AddCurvedBackPlane(Slot parent, int width, int height, float scale)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			Slot slot = parent.AddSlot("BackPanelCurvedPlane", true);
			slot.LocalPosition = new float3(0f, 0f, 0.001f);
			Slot obj = slot;
			float3 one = float3.One;
			obj.LocalScale = (ref one) * scale;
			MeshRenderer renderer = ((ContainerWorker<Component>)(object)slot).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			CurvedPlaneMesh val = ((ContainerWorker<Component>)(object)slot).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)val.Size).Value = new float2((float)width, (float)height);
			((SyncField<float>)(object)val.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)val.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)val.Segments).Value = 48;
			((SyncRef<IAssetProvider<Mesh>>)(object)renderer.Mesh).Target = (IAssetProvider<Mesh>)(object)val;
			MeshCollider obj2 = ((ContainerWorker<Component>)(object)slot).AttachComponent<MeshCollider>(true, (Action<MeshCollider>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)((MeshBasedCollider<Mesh, MeshColliderData>)(object)obj2).Mesh).Target = (IAssetProvider<Mesh>)(object)val;
			((SyncField<MeshColliderSidedness>)(object)obj2.Sidedness).Value = (MeshColliderSidedness)1;
			AddBackMaterial((Culling)1);
			AddBackMaterial((Culling)2);
			return val;
			[CompilerGenerated]
			PBS_DualSidedMetallic AddBackMaterial(Culling culling)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				PBS_DualSidedMetallic val2 = ((ContainerWorker<Component>)(object)slot).AttachComponent<PBS_DualSidedMetallic>(true, (Action<PBS_DualSidedMetallic>)null);
				((SyncField<colorX>)(object)((PBS_DualSidedMaterial)val2).AlbedoColor).Value = new colorX(0.08f, 0.08f, 0.1f, 1f, (ColorProfile)1);
				((SyncField<Culling>)(object)((PBS_DualSidedMaterial)val2).Culling).Value = culling;
				((SyncField<AlphaHandling>)(object)((PBS_DualSidedMaterial)val2).AlphaHandling).Value = (AlphaHandling)0;
				((SyncField<float>)(object)val2.Metallic).Value = 0f;
				((SyncField<float>)(object)val2.Smoothness).Value = 0.35f;
				renderer.Materials.Add((IAssetProvider<Material>)(object)val2);
				return val2;
			}
		}

		private static CurvedPlaneMesh AddCurvedStripPlane(Slot parent, string name, int width, float height, float scale, float yOffset, float zOffset)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
			Slot obj = parent.AddSlot(name, true);
			obj.LocalPosition = new float3(0f, yOffset, zOffset);
			float3 one = float3.One;
			obj.LocalScale = (ref one) * scale;
			MeshRenderer val = ((ContainerWorker<Component>)(object)obj).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			CurvedPlaneMesh val2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)val2.Size).Value = new float2((float)width, height);
			((SyncField<float>)(object)val2.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)val2.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)val2.Segments).Value = 48;
			((SyncRef<IAssetProvider<Mesh>>)(object)val.Mesh).Target = (IAssetProvider<Mesh>)(object)val2;
			UnlitMaterial val3 = ((ContainerWorker<Component>)(object)obj).AttachComponent<UnlitMaterial>(true, (Action<UnlitMaterial>)null);
			((SyncField<colorX>)(object)val3.TintColor).Value = new colorX(1f, 1f, 1f, 0f, (ColorProfile)1);
			((SyncField<BlendMode>)(object)val3.BlendMode).Value = (BlendMode)2;
			((SyncField<Sidedness>)(object)val3.Sidedness).Value = (Sidedness)3;
			((SyncField<ZWrite>)(object)val3.ZWrite).Value = (ZWrite)1;
			val.Materials.Add((IAssetProvider<Material>)(object)val3);
			return val2;
		}

		private static CurvedPlaneMesh AddCurvedRenderPlane(Slot parent, string name, int width, float height, float scale, float yOffset, float zOffset, IAssetProvider<ITexture2D> texture, Camera rayExit, bool addCollider = true, Sidedness sidedness = (Sidedness)1, ZWrite zWrite = (ZWrite)2, float offsetUnits = 120f, BlendMode blendMode = (BlendMode)2, int renderQueue = -1, float alphaCutoff = 0.01f, float2? textureScale = null, float2? textureOffset = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			Slot val = parent.AddSlot(name, true);
			val.LocalPosition = new float3(0f, yOffset, zOffset);
			float3 one = float3.One;
			val.LocalScale = (ref one) * scale;
			MeshRenderer val2 = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			CurvedPlaneMesh val3 = ((ContainerWorker<Component>)(object)val).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)val3.Size).Value = new float2((float)width, height);
			((SyncField<float>)(object)val3.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)val3.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)val3.Segments).Value = 48;
			((SyncRef<IAssetProvider<Mesh>>)(object)val2.Mesh).Target = (IAssetProvider<Mesh>)(object)val3;
			if (addCollider)
			{
				MeshCollider obj = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshCollider>(true, (Action<MeshCollider>)null);
				((SyncRef<IAssetProvider<Mesh>>)(object)((MeshBasedCollider<Mesh, MeshColliderData>)(object)obj).Mesh).Target = (IAssetProvider<Mesh>)(object)val3;
				((SyncField<MeshColliderSidedness>)(object)obj.Sidedness).Value = (MeshColliderSidedness)0;
			}
			if (rayExit != null)
			{
				MeshUVRaycastPortal obj2 = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshUVRaycastPortal>(true, (Action<MeshUVRaycastPortal>)null);
				obj2.RayExit.Target = (IUVToRayConverter)(object)rayExit;
				((SyncField<bool?>)(object)obj2.OverrideHitTriggers).Value = true;
				((SyncField<bool>)(object)obj2.RepeatUV).Value = false;
			}
			UnlitMaterial val4 = ((ContainerWorker<Component>)(object)val).AttachComponent<UnlitMaterial>(true, (Action<UnlitMaterial>)null);
			((SyncRef<IAssetProvider<ITexture2D>>)(object)val4.Texture).Target = texture;
			((SyncField<BlendMode>)(object)val4.BlendMode).Value = blendMode;
			((SyncField<float>)(object)val4.AlphaCutoff).Value = alphaCutoff;
			((SyncField<Sidedness>)(object)val4.Sidedness).Value = sidedness;
			((SyncField<ZWrite>)(object)val4.ZWrite).Value = zWrite;
			((SyncField<float>)(object)val4.OffsetUnits).Value = offsetUnits;
			((SyncField<int>)(object)val4.RenderQueue).Value = renderQueue;
			if (textureScale.HasValue)
			{
				((SyncField<float2>)(object)val4.TextureScale).Value = textureScale.Value;
			}
			if (textureOffset.HasValue)
			{
				((SyncField<float2>)(object)val4.TextureOffset).Value = textureOffset.Value;
			}
			val2.Materials.Add((IAssetProvider<Material>)(object)val4);
			return val3;
		}

		private static CurvedPlaneMesh AddCurvedMeshOnly(Slot parent, string name, float width, float height, float scale, float yOffset, float zOffset)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Slot obj = parent.AddSlot(name, true);
			obj.LocalPosition = new float3(0f, yOffset, zOffset);
			float3 one = float3.One;
			obj.LocalScale = (ref one) * scale;
			CurvedPlaneMesh obj2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)obj2.Size).Value = new float2(width, height);
			((SyncField<float>)(object)obj2.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)obj2.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)obj2.Segments).Value = 48;
			return obj2;
		}

		private static BlurMaterial AddCurvedMeshBackdropBlur(Slot slot, CurvedPlaneMesh mesh, int iterations, float spread)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer obj = ((ContainerWorker<Component>)(object)slot).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)obj.Mesh).Target = (IAssetProvider<Mesh>)(object)mesh;
			BlurMaterial val = ((ContainerWorker<Component>)(object)slot).AttachComponent<BlurMaterial>(true, (Action<BlurMaterial>)null);
			((SyncField<int>)(object)val.Iterations).Value = iterations;
			Sync<float2> spread2 = val.Spread;
			float2 one = float2.One;
			((SyncField<float2>)(object)spread2).Value = (ref one) * spread;
			((SyncField<bool>)(object)val.PerObject).Value = true;
			((SyncField<ZWrite>)(object)val.ZWrite).Value = (ZWrite)1;
			((SyncField<ZTest>)(object)val.ZTest).Value = (ZTest)2;
			((SyncField<Sidedness>)(object)val.Sidedness).Value = (Sidedness)1;
			((SyncField<BlendMode>)(object)val.BlendMode).Value = (BlendMode)0;
			((SyncField<bool>)(object)val.UsePoissonDisc).Value = true;
			((SyncField<bool>)(object)val.Refract).Value = false;
			((SyncField<float>)(object)val.DepthFadeDivisor).Value = 1f;
			obj.Materials.Add((IAssetProvider<Material>)(object)val);
			return val;
		}

		private static float GetCurvedPanelDepth(CurvedPlaneMesh mesh, float scale)
		{
			if (mesh == null || ((ComponentBase<Component>)(object)mesh).IsDestroyed)
			{
				return 0f;
			}
			return GetCurvedPanelDepthAtU(mesh, 0.5f, scale);
		}

		private static void AddButtonRow(UIBuilder ui, SettingsPanelState state, string label, Action pressed, bool selected = false, string buttonLabel = null)
		{
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 8f, 12f, 8f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 116f;
			ui.Style.PreferredWidth = 116f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			val2 = LocaleString.op_Implicit(buttonLabel ?? label);
			colorX? val3 = (selected ? SettingsAccent : SettingsPanelSoft);
			Button obj2 = ui.Button(ref val2, ref val3);
			StyleSettingsButton(obj2, selected);
			obj2.LocalPressed += (ButtonEventHandler)delegate
			{
				Action obj3 = pressed;
				if (obj3 != null)
				{
					obj3.Invoke();
				}
				RebuildSettingsContent(state, null);
			};
			ui.NestOut();
		}

		private static void AddLinkButtonRow(UIBuilder ui, SettingsPanelState state, string label, string url, string buttonLabel = null)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 8f, 12f, 8f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 116f;
			ui.Style.PreferredWidth = 116f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			val2 = LocaleString.op_Implicit(buttonLabel ?? label);
			colorX? val3 = SettingsPanelSoft;
			Button obj2 = ui.Button(ref val2, ref val3);
			StyleSettingsButton(obj2, selected: false);
			Hyperlink obj3 = ((ContainerWorker<Component>)(object)((Component)obj2).Slot).AttachComponent<Hyperlink>(true, (Action<Hyperlink>)null);
			((SyncField<Uri>)(object)obj3.URL).Value = new Uri(url);
			((SyncField<bool>)(object)obj3.OpenOnce).Value = false;
			((SyncField<string>)(object)obj3.Reason).Value = "DesktopBuddy";
			ui.NestOut();
		}

		private static void BuildAudioTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: 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_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Stream Audio");
			AddOptionRow(ui, state, "Mode", NormalizeStreamAudioGlobalMode(Config?.GetValue(StreamAudioGlobalMode)), new ValueTuple<string, string>[3]
			{
				new ValueTuple<string, string>("global", "Global"),
				new ValueTuple<string, string>("auto", "Auto"),
				new ValueTuple<string, string>("positional", "Positional")
			}, delegate(string value)
			{
				SaveConfigValue(StreamAudioGlobalMode, NormalizeStreamAudioGlobalMode(value));
				ApplyStreamAudioSettingsToAllSessions();
			}, 3);
			AddSectionHeader(ui, "Spatial Output");
			AddCheckbox(ui, state, "Spatialize", Config?.GetValue(StreamAudioSpatialize) ?? true, delegate(bool value)
			{
				SaveConfigValue(StreamAudioSpatialize, value);
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Spatial blend", Config?.GetValue(StreamAudioSpatialBlend) ?? 1f, 0f, 1f, delegate(float value)
			{
				SaveConfigValue(StreamAudioSpatialBlend, Math.Clamp(value, 0f, 1f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddOptionRow(ui, state, "Distance space", NormalizeStreamAudioDistanceSpace(Config?.GetValue(StreamAudioDistanceSpace)), new ValueTuple<string, string>[2]
			{
				new ValueTuple<string, string>("global", "Global"),
				new ValueTuple<string, string>("local", "Local")
			}, delegate(string value)
			{
				SaveConfigValue(StreamAudioDistanceSpace, NormalizeStreamAudioDistanceSpace(value));
				ApplyStreamAudioSettingsToAllSessions();
			}, 2);
			AddOptionRow(ui, state, "Rolloff", NormalizeStreamAudioRolloffMode(Config?.GetValue(StreamAudioRolloffMode)), new ValueTuple<string, string>[2]
			{
				new ValueTuple<string, string>("logarithmic_fade_off", "Log fade"),
				new ValueTuple<string, string>("linear", "Linear")
			}, delegate(string value)
			{
				SaveConfigValue(StreamAudioRolloffMode, NormalizeStreamAudioRolloffMode(value));
				ApplyStreamAudioSettingsToAllSessions();
			}, 2);
			AddFloatSlider(ui, state, "Min distance", Config?.GetValue(StreamAudioMinDistance) ?? 1f, 0f, 10f, delegate(float value)
			{
				SaveConfigValue(StreamAudioMinDistance, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Max distance", Config?.GetValue(StreamAudioMaxDistance) ?? 30f, 1f, 50f, delegate(float value)
			{
				SaveConfigValue(StreamAudioMaxDistance, Math.Clamp(value, 1f, 50f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Spatial start", Config?.GetValue(StreamAudioSpatializationStartDistance) ?? 0.01f, 0f, 10f, delegate(float value)
			{
				SaveConfigValue(StreamAudioSpatializationStartDistance, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Transition range", Config?.GetValue(StreamAudioSpatializationTransitionRange) ?? 0.01f, 0f, 10f, delegate(float value)
			{
				SaveConfigValue(StreamAudioSpatializationTransitionRange, Math.Clamp(value, 0f, 10f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Min scale", Config?.GetValue(StreamAudioMinScale) ?? 0f, 0f, 1000f, delegate(float value)
			{
				SaveConfigValue(StreamAudioMinScale, Math.Clamp(value, 0f, 1000f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Max scale", Config?.GetValue(StreamAudioMaxScale) ?? 1000f, 0f, 1000f, delegate(float value)
			{
				SaveConfigValue(StreamAudioMaxScale, Math.Clamp(value, 0f, 1000f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddSectionHeader(ui, "Playback");
			AddOptionRow(ui, state, "Type group", NormalizeStreamAudioTypeGroup(Config?.GetValue(StreamAudioTypeGroup)), new ValueTuple<string, string>[4]
			{
				new ValueTuple<string, string>("multimedia", "Multimedia"),
				new ValueTuple<string, string>("sound_effect", "Sound"),
				new ValueTuple<string, string>("voice", "Voice"),
				new ValueTuple<string, string>("ui", "UI")
			}, delegate(string value)
			{
				SaveConfigValue(StreamAudioTypeGroup, NormalizeStreamAudioTypeGroup(value));
				ApplyStreamAudioSettingsToAllSessions();
			}, 4, 108f);
			AddCheckbox(ui, state, "Ignore audio effects", Config?.GetValue(StreamAudioIgnoreAudioEffects) ?? true, delegate(bool value)
			{
				SaveConfigValue(StreamAudioIgnoreAudioEffects, value);
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Pitch", Config?.GetValue(StreamAudioPitch) ?? 1f, 0.5f, 2f, delegate(float value)
			{
				SaveConfigValue(StreamAudioPitch, Math.Clamp(value, 0.5f, 2f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddFloatSlider(ui, state, "Doppler", Config?.GetValue(StreamAudioDopplerLevel) ?? 0f, 0f, 1f, delegate(float value)
			{
				SaveConfigValue(StreamAudioDopplerLevel, Math.Clamp(value, 0f, 1f));
				ApplyStreamAudioSettingsToAllSessions();
			});
			AddIntField(ui, state, "Priority", Config?.GetValue(StreamAudioPriority) ?? 128, 0, 256, delegate(int value)
			{
				SaveConfigValue(StreamAudioPriority, Math.Clamp(value, 0, 256));
				ApplyStreamAudioSettingsToAllSessions();
			});
		}

		private static void BuildSettingsPanelShell(SettingsPanelState state, DesktopSession session)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_009e: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: 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_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			((Component)state.Canvas).Slot.DestroyChildren(false, true, false, (Predicate<Slot>)null);
			UIBuilder val = new UIBuilder(state.Canvas);
			SpriteProvider val2 = ((ContainerWorker<Component>)(object)((Component)state.Canvas).Slot).GetComponent<SpriteProvider>((Predicate<SpriteProvider>)null, false);
			if (val2 == null)
			{
				val2 = ((ContainerWorker<Component>)(object)((Component)state.Canvas).Slot).AttachComponent<SpriteProvider>(true, (Action<SpriteProvider>)null);
			}
			val2 = TextureProviderSettings.ClampWrap<SpriteProvider>(val2);
			((SyncRef<IAssetProvider<ITexture2D>>)(object)val2.Texture).Target = UIBuilder.GetCircleTexture(((Worker)state.Canvas).World);
			Sync<float4> borders = val2.Borders;
			float4 one = float4.One;
			((SyncField<float4>)(object)borders).Value = (ref one) * 0.49f;
			((SyncField<float>)(object)val2.FixedSize).Value = 28f;
			val.Style.ButtonSprite = (IAssetProvider<Sprite>)(object)val2;
			val.Style.NineSliceSizing = (NineSliceSizing)0;
			val.Style.MinHeight = 44f;
			val.Style.PreferredHeight = 44f;
			colorX val3 = new colorX(0.055f, 0.06f, 0.072f, 0.8f, (ColorProfile)1);
			Image val4 = val.Image(ref val3, false);
			state.ModalRect = ((UIComponent)val4).RectTransform;
			SetSettingsModalRect(state);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val4).Sprite).Target = (IAssetProvider<Sprite>)(object)val2;
			((SyncField<NineSliceSizing>)(object)((ImageBase)val4).NineSliceSizing).Value = (NineSliceSizing)0;
			val.NestInto(((UIComponent)val4).RectTransform);
			val.LayoutTarget = ((Component)val4).Slot;
			val.VerticalLayout(14f, 22f, 22f, 22f, 22f, (Alignment?)null, (bool?)null, (bool?)null);
			val.Style.MinHeight = 56f;
			val.Style.PreferredHeight = 56f;
			val.Style.FlexibleHeight = -1f;
			Slot val5 = val.Empty("Header");
			UIBuilder val6 = new UIBuilder(val5, (Slot)null)
			{
				LayoutTarget = val5
			};
			HorizontalLayout obj = val6.HorizontalLayout(12f, 0f, 0f, 0f, 0f, (Alignment?)(Alignment)4);
			((SyncField<bool>)(object)((DirectionalLayout)obj).ForceExpandWidth).Value = true;
			((SyncField<bool>)(object)((DirectionalLayout)obj).ForceExpandHeight).Value = true;
			val6.Style.FlexibleWidth = 1f;
			val6.Style.MinHeight = 56f;
			val6.Style.PreferredHeight = 56f;
			LocaleString val7 = LocaleString.op_Implicit("DesktopBuddy - 1.1.0");
			Text obj2 = val6.Text(ref val7, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj2.Size).Value = 28f;
			((SyncField<colorX>)(object)obj2.Color).Value = SettingsText;
			val6.Style.FlexibleWidth = -1f;
			val6.Style.MinWidth = 42f;
			val6.Style.PreferredWidth = 42f;
			val6.Style.MinHeight = 38f;
			val6.Style.PreferredHeight = 38f;
			Uri cross = Icons.Cross;
			colorX? val8 = SettingsPanelSoft;
			Button obj3 = val6.Button(cross, ref val8, ref SettingsText);
			StyleSettingsButton(obj3, selected: false);
			obj3.LocalPressed += (ButtonEventHandler)delegate
			{
				if (state.SurfaceSlot != null && !((ContainerWorker<Component>)(object)state.SurfaceSlot).IsDestroyed)
				{
					state.SurfaceSlot.ActiveSelf = false;
				}
				if (state.RenderHost != null && !((ContainerWorker<Component>)(object)state.RenderHost).IsDestroyed)
				{
					state.RenderHost.ActiveSelf = false;
				}
				StopVirtualCameraPreview(session);
				FlushSettingsConfig();
			};
			val.Style.MinHeight = 62f;
			val.Style.PreferredHeight = 62f;
			val.Style.FlexibleHeight = -1f;
			val.Style.FlexibleWidth = 1f;
			state.TabRoot = val.Empty("Tabs");
			val.Style.FlexibleHeight = 1f;
			val.Style.MinHeight = 0f;
			val.Style.FlexibleWidth = 1f;
			state.ContentRoot = val.Empty("Content");
			RebuildSettingsPanel(state, session);
		}

		private static void RebuildSettingsPanel(SettingsPanelState state, DesktopSession session)
		{
			if (session == null)
			{
				session = state.Session;
			}
			SyncLiveCullingStateFromConfig(state);
			RebuildSettingsTabs(state, session);
			RebuildSettingsContent(state, session);
			UpdateCullingPreview(session, state);
		}

		private static void RebuildSettingsTabs(SettingsPanelState state, DesktopSession session)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			state.TabRoot.DestroyChildren(false, true, false, (Predicate<Slot>)null);
			DestroyLayoutControllers(state.TabRoot);
			UIBuilder val = new UIBuilder(state.TabRoot, (Slot)null);
			val.LayoutTarget = state.TabRoot;
			val.HorizontalLayout(8f, 0f, 2f, 0f, 2f, (Alignment?)(Alignment)4);
			ValueTuple<SettingsPanelTab, string, string>[] settingsTabs = SettingsTabs;
			for (int i = 0; i < settingsTabs.Length; i++)
			{
				ValueTuple<SettingsPanelTab, string, string> val2 = settingsTabs[i];
				val.Style.MinWidth = 86f;
				val.Style.PreferredWidth = 86f;
				val.Style.MinHeight = 54f;
				val.Style.PreferredHeight = 54f;
				val.Style.FlexibleWidth = -1f;
				val.Style.FlexibleHeight = -1f;
				bool flag = val2.Item1 == state.ActiveTab;
				colorX val3 = (flag ? SettingsAccent : SettingsPanelSoft);
				LocaleString val4 = LocaleString.op_Implicit(val2.Item3);
				colorX? val5 = val3;
				Button val6 = val.Button(ref val4, ref val5);
				StyleSettingsButton(val6, flag);
				((Component)val6).Slot.Name = "Tab " + val2.Item2;
				if (val6.Label != null)
				{
					((SyncField<float>)(object)val6.Label.Size).Value = 25f;
					((SyncField<colorX>)(object)val6.Label.Color).Value = SettingsText;
					val6.Label.Align = (Alignment)4;
				}
				SettingsPanelTab captured = val2.Item1;
				val6.LocalPressed += (ButtonEventHandler)delegate
				{
					state.ActiveTab = captured;
					RebuildSettingsPanel(state, session);
				};
			}
		}

		private static void RebuildSettingsContent(SettingsPanelState state, DesktopSession session)
		{
			//IL_0032: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			if (session == null)
			{
				session = state.Session;
			}
			StopVirtualCameraPreview(session);
			state.ContentRoot.DestroyChildren(false, true, false, (Predicate<Slot>)null);
			DestroyLayoutControllers(state.ContentRoot);
			UIBuilder val = new UIBuilder(state.ContentRoot, (Slot)null);
			state.DebugLogText = null;
			state.DebugLogScroll = null;
			state.ContentScroll = null;
			state.DebugLogContent = null;
			state.Scrollbars.Clear();
			val.LayoutTarget = state.ContentRoot;
			val.VerticalLayout(0f, 0f, 0f, 0f, 0f, (Alignment?)(Alignment)0, (bool?)true, (bool?)true);
			ScrollRect scroll;
			UIBuilder ui = BeginRoundedScroll(val, state, "SettingsContentScroll", 0f, (Alignment)0, out scroll);
			state.ContentScroll = scroll;
			switch (state.ActiveTab)
			{
			case SettingsPanelTab.Viewers:
				BuildViewersTab(ui, state, session);
				break;
			case SettingsPanelTab.General:
				BuildGeneralTab(ui, state);
				break;
			case SettingsPanelTab.Stream:
				BuildStreamTab(ui, state, session);
				break;
			case SettingsPanelTab.Audio:
				BuildAudioTab(ui, state, session);
				break;
			case SettingsPanelTab.Network:
				BuildNetworkTab(ui, state);
				break;
			case SettingsPanelTab.Devices:
				BuildDevicesTab(ui, state, session);
				break;
			case SettingsPanelTab.Debug:
				BuildDebugTab(ui, state, session);
				break;
			case SettingsPanelTab.UpdateInfo:
				BuildUpdateInfoTab(ui, state, session);
				break;
			}
			ScheduleScrollbarGeometryUpdate(state);
		}

		private static void ApplyPanelCurve(DesktopSession session, float curvature)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (session == null || session.Root == null || ((ContainerWorker<Component>)(object)session.Root).IsDestroyed)
			{
				return;
			}
			Enumerator<CurvedPlaneMesh> enumerator = session.Root.GetComponentsInChildren<CurvedPlaneMesh>((Predicate<CurvedPlaneMesh>)null, false, false, (Predicate<Slot>)null).GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					CurvedPlaneMesh current = enumerator.Current;
					if (current != null && !((ComponentBase<Component>)(object)current).IsDestroyed)
					{
						((SyncField<float>)(object)current.Curvature).Value = curvature;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static void UpdateCullingPreview(DesktopSession session, SettingsPanelState state = null)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			if (session?.Root == null || ((ContainerWorker<Component>)(object)session.Root).IsDestroyed)
			{
				return;
			}
			if (state == null)
			{
				state = session.SettingsPanel;
			}
			if (session.CullingPreviewSlot != null && !((ContainerWorker<Component>)(object)session.CullingPreviewSlot).IsDestroyed)
			{
				session.CullingPreviewSlot.Destroy();
				session.CullingPreviewSlot = null;
			}
			bool num;
			if (state == null)
			{
				DesktopBuddyConfig config = Config;
				if (config == null)
				{
					return;
				}
				num = config.GetValue(ViewerCullingPreview);
			}
			else
			{
				num = state.ViewerCullingPreviewEnabled;
			}
			if (num)
			{
				string text = NormalizeViewerCullingMode(state?.ViewerCullingMode ?? Config.GetValue(ViewerCullingMode));
				Slot val = session.Root.AddSlot("ViewerCullingPreviewGuide", true);
				val.LocalPosition = float3.Zero;
				val.LocalRotation = floatQ.Identity;
				if (text == "distance")
				{
					float radius = Math.Clamp(state?.ViewerDistance ?? Config.GetValue(ViewerDistance), 1f, 10f);
					AddPreviewSphere(val, session, radius, new colorX(0.25f, 0.55f, 1f, 0.16f, (ColorProfile)1));
				}
				else
				{
					float depth = Math.Clamp(state?.ViewerFrustumDepth ?? Config.GetValue(ViewerFrustumDepth), 1f, 10f);
					float angleDegrees = NormalizeViewerFrustumAngle(state?.ViewerFrustumAngle ?? Config.GetValue(ViewerFrustumWidth));
					AddPreviewFrustum(val, session, angleDegrees, depth, new colorX(0.25f, 1f, 0.7f, 0.16f, (ColorProfile)1));
				}
				session.CullingPreviewSlot = val;
			}
		}

		private static float NormalizeViewerFrustumAngle(float value)
		{
			if (value < 5f)
			{
				return 120f;
			}
			return Math.Clamp(value, 30f, 170f);
		}

		private static UnlitMaterial CreatePreviewMaterial(Slot slot, colorX tint)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			UnlitMaterial obj = ((ContainerWorker<Component>)(object)slot).AttachComponent<UnlitMaterial>(true, (Action<UnlitMaterial>)null);
			((SyncField<colorX>)(object)obj.TintColor).Value = tint;
			((SyncField<BlendMode>)(object)obj.BlendMode).Value = (BlendMode)2;
			((SyncField<ZWrite>)(object)obj.ZWrite).Value = (ZWrite)1;
			((SyncField<Sidedness>)(object)obj.Sidedness).Value = (Sidedness)3;
			((SyncField<int>)(object)obj.RenderQueue).Value = 3004;
			return obj;
		}

		private static float GetCullingPreviewOriginZ(DesktopSession session)
		{
			if (session == null)
			{
				return 0.001f;
			}
			CurvedPlaneMesh val = session.PanelMesh;
			float num = session.PanelCanvasScale;
			if ((val == null || ((ComponentBase<Component>)(object)val).IsDestroyed) && session.SettingsPanel != null)
			{
				val = session.SettingsPanel.Mesh;
				num = session.SettingsPanel.CanvasScale;
			}
			if (num <= 0f)
			{
				num = 0.0005f;
			}
			return GetCurvedPanelDepth(val, num) + 0.001f;
		}

		private static void AddPreviewSphere(Slot parent, DesktopSession session, float radius, colorX tint)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Slot val = parent.AddSlot("DistanceSphere", true);
			val.LocalPosition = new float3(0f, 0f, GetCullingPreviewOriginZ(session));
			val.LocalRotation = floatQ.Identity;
			MeshRenderer obj = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			SphereMesh val2 = ((ContainerWorker<Component>)(object)val).AttachComponent<SphereMesh>(true, (Action<SphereMesh>)null);
			((SyncField<float>)(object)val2.Radius).Value = radius;
			((SyncField<int>)(object)val2.Segments).Value = 48;
			((SyncField<int>)(object)val2.Rings).Value = 24;
			((SyncRef<IAssetProvider<Mesh>>)(object)obj.Mesh).Target = (IAssetProvider<Mesh>)(object)val2;
			obj.Materials.Add((IAssetProvider<Material>)(object)CreatePreviewMaterial(val, tint));
		}

		private static void AddPreviewFrustum(Slot parent, DesktopSession session, float angleDegrees, float depth, colorX tint)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: 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_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			if (session != null && session.SettingsPanel != null)
			{
				int num = session.LastKnownW;
				int num2 = session.LastKnownH;
				if ((num <= 0 || num2 <= 0) && session.Canvas != null && !((ComponentBase<Component>)(object)session.Canvas).IsDestroyed)
				{
					num = MathX.RoundToInt(((SyncField<float2>)(object)session.Canvas.Size).Value.x);
					num2 = MathX.RoundToInt(((SyncField<float2>)(object)session.Canvas.Size).Value.y);
				}
				if (num > 0 && num2 > 0 && !(session.SettingsPanel.CanvasScale <= 0f))
				{
					float num3 = (float)num * session.SettingsPanel.CanvasScale;
					float num4 = (float)num2 * session.SettingsPanel.CanvasScale;
					float cullingPreviewOriginZ = GetCullingPreviewOriginZ(session);
					float num5 = cullingPreviewOriginZ - depth;
					float num6 = num3 * 0.5f;
					float num7 = num4 * 0.5f;
					float num8 = num6 + (float)Math.Tan((double)angleDegrees * Math.PI / 360.0) * depth;
					float num9 = angleDegrees * 0.5f;
					float num10 = num7 + (float)Math.Tan((double)num9 * Math.PI / 360.0) * depth;
					float3[] array = (float3[])(object)new float3[4]
					{
						new float3(0f - num6, 0f - num7, cullingPreviewOriginZ),
						new float3(num6, 0f - num7, cullingPreviewOriginZ),
						new float3(num6, num7, cullingPreviewOriginZ),
						new float3(0f - num6, num7, cullingPreviewOriginZ)
					};
					float3[] array2 = (float3[])(object)new float3[4]
					{
						new float3(0f - num8, 0f - num10, num5),
						new float3(num8, 0f - num10, num5),
						new float3(num8, num10, num5),
						new float3(0f - num8, num10, num5)
					};
					AddPreviewQuad(parent, "NearPlane", array[0], array[1], array[2], array[3], tint);
					AddPreviewQuad(parent, "FarPlane", array2[1], array2[0], array2[3], array2[2], tint);
					AddPreviewQuad(parent, "LeftPlane", array2[0], array[0], array[3], array2[3], tint);
					AddPreviewQuad(parent, "RightPlane", array[1], array2[1], array2[2], array[2], tint);
					AddPreviewQuad(parent, "BottomPlane", array2[0], array2[1], array[1], array[0], tint);
					AddPreviewQuad(parent, "TopPlane", array[3], array[2], array2[2], array2[3], tint);
				}
			}
		}

		private static void AddPreviewQuad(Slot parent, string name, float3 a, float3 b, float3 c, float3 d, colorX tint)
		{
			//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)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			AddPreviewTriangle(parent, name + " A", a, b, c, tint);
			AddPreviewTriangle(parent, name + " B", a, c, d, tint);
		}

		private static void AddPreviewTriangle(Slot parent, string name, float3 a, float3 b, float3 c, colorX tint)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			Slot val = parent.AddSlot(name, true);
			MeshRenderer obj = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			TriangleMesh val2 = ((ContainerWorker<Component>)(object)val).AttachComponent<TriangleMesh>(true, (Action<TriangleMesh>)null);
			((SyncField<float3>)(object)val2.Vertex0.Position).Value = a;
			((SyncField<float3>)(object)val2.Vertex1.Position).Value = b;
			((SyncField<float3>)(object)val2.Vertex2.Position).Value = c;
			((SyncField<bool>)(object)val2.AutoNormals).Value = true;
			((SyncField<bool>)(object)val2.AutoTangents).Value = true;
			((SyncField<bool>)(object)val2.DualSided).Value = true;
			((SyncRef<IAssetProvider<Mesh>>)(object)obj.Mesh).Target = (IAssetProvider<Mesh>)(object)val2;
			obj.Materials.Add((IAssetProvider<Material>)(object)CreatePreviewMaterial(val, tint));
		}

		private static void BuildDebugTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Debug");
			AddButtonRow(ui, state, "Create diagnostics bundle", (Action)delegate
			{
				try
				{
					Log.ExportDiagnosticsBundle();
				}
				catch (global::System.Exception ex)
				{
					Msg("[Log] Diagnostics export failed: " + ex.Message);
				}
				try
				{
					SpawnDiagnosticsLogInWorld(session, state);
				}
				catch (global::System.Exception ex2)
				{
					Msg("[Log] Diagnostics in-world spawn failed: " + ex2.Message);
				}
				RebuildSettingsPanel(state, session);
			}, selected: false, "Create");
			AddSectionHeader(ui, "Debug Log");
			float num = Math.Clamp((float)state.ModalHeight - 360f, 180f, 340f);
			ui.Style.MinHeight = num;
			ui.Style.PreferredHeight = num;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			ScrollRect scroll;
			UIBuilder val = BeginRoundedScroll(ui, state, "DebugLogScroll", num, (Alignment)6, out scroll, (colorX?)new colorX(0f, 0f, 0f, 0.8f, (ColorProfile)1));
			val.Style.MinHeight = Math.Max(160f, num - 24f);
			val.Style.PreferredHeight = Math.Max(160f, num - 24f);
			val.Style.FlexibleWidth = 1f;
			val.PushStyle();
			val.Style.SupressLayoutElement = true;
			SettingsPanelState settingsPanelState = state;
			LocaleString val2 = LocaleString.op_Implicit("");
			settingsPanelState.DebugLogText = val.Text(ref val2, false, (Alignment?)(Alignment)6, true, (string)null);
			val.PopStyle();
			((SyncField<float>)(object)state.DebugLogText.Size).Value = 13f;
			((SyncField<colorX>)(object)state.DebugLogText.Color).Value = new colorX(0.73f, 0.78f, 0.84f, 1f, (ColorProfile)1);
			((SyncField<float>)(object)state.DebugLogText.LineHeight).Value = 1.08f;
			((SyncField<bool>)(object)state.DebugLogText.ParseRichText).Value = false;
			state.DebugLogScroll = scroll;
			UpdateDebugLogText(state);
			((Worker)state.OwnerRoot).World.RunInUpdates(1, (Action)delegate
			{
				if (state.DebugLogScroll != null && !((ComponentBase<Component>)(object)state.DebugLogScroll).IsDestroyed)
				{
					state.DebugLogScroll.MoveToBottom();
				}
			});
			ScheduleDebugLogRefresh(state, session);
		}

		private static void SpawnDiagnosticsLogInWorld(DesktopSession session, SettingsPanelState state)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			Slot val = session?.Root ?? state?.OwnerRoot;
			World world = ((val != null) ? ((Worker)val).World : null);
			if (val == null || ((ContainerWorker<Component>)(object)val).IsDestroyed || world == null)
			{
				Msg("[Log] Diagnostics in-world spawn skipped: no panel root");
				return;
			}
			string path = Log.ExportCombinedLog();
			if (string.IsNullOrWhiteSpace(path) || !File.Exists(path))
			{
				Msg("[Log] Diagnostics in-world spawn skipped: combined log not written");
				return;
			}
			float3 globalPosition = val.GlobalPosition;
			floatQ globalRotation = val.GlobalRotation;
			float3 forward = float3.Forward;
			float3 val2 = (ref globalRotation) * (ref forward);
			float3 val3 = (ref val2) * 0.35f;
			float3 position = (ref globalPosition) + (ref val3);
			floatQ rotation = val.GlobalRotation;
			world.RunSynchronously((Action)delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					UniversalImporter.Import(path, world, position, rotation, false, false);
					Msg("[Log] Importing diagnostics log into world: " + path);
				}
				catch (global::System.Exception ex)
				{
					Msg("[Log] In-world import failed: " + ex.Message);
				}
			}, false, (IUpdatable)null, false);
		}

		private static void BuildUpdateInfoTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			QueueUpdateInfoCheck(state);
			AddSectionHeader(ui, "Update & Info");
			AddInfoRow(ui, state, "About", "Made with love by DevL0rd and the Resonite community ❤\ufe0f");
			bool flag = !string.IsNullOrWhiteSpace(_latestVersion);
			string status;
			colorX badgeColor;
			if (_updateCheckInProgress)
			{
				status = "Checking";
				badgeColor = SettingsStatusWarn;
			}
			else if (flag)
			{
				status = "Available";
				badgeColor = SettingsStatusWarn;
			}
			else if (!string.IsNullOrWhiteSpace(_remoteVersion))
			{
				status = "Current";
				badgeColor = SettingsStatusGood;
			}
			else if (!string.IsNullOrWhiteSpace(_updateCheckError))
			{
				status = "Failed";
				badgeColor = SettingsStatusBad;
			}
			else
			{
				status = "Unknown";
				badgeColor = SettingsStatusNeutral;
			}
			AddStatusRow(ui, state, "Update", status, badgeColor);
			AddInfoRow(ui, state, "Current version", "1.1.0 (e5251e3)");
			AddLinkButtonRow(ui, state, "Releases", "https://github.com/DevL0rd/DesktopBuddy/releases", "Open");
			AddLinkButtonRow(ui, state, "Repository", "https://github.com/DevL0rd/DesktopBuddy", "GitHub");
			AddSectionHeader(ui, "Settings");
			AddButtonRow(ui, state, "Reset settings to defaults", (Action)delegate
			{
				ResetSettingsToDefaults(state, session);
			}, selected: false, "Reset");
			AddSectionHeader(ui, "Changelog");
			float num = Math.Clamp(((float)state.ModalHeight - 540f) * 3f, 360f, 720f);
			ScrollRect scroll;
			UIBuilder val = BeginRoundedScroll(ui, state, "UpdateChangelogScroll", num, (Alignment)0, out scroll);
			string text = ((!string.IsNullOrWhiteSpace(_remoteChangelog)) ? _remoteChangelog : (_updateCheckInProgress ? "Checking CHANGELOG.md..." : "No changelog found."));
			val.Style.MinHeight = Math.Max(140f, num - 24f);
			val.Style.PreferredHeight = Math.Max(140f, num - 24f);
			val.Style.FlexibleWidth = 1f;
			val.PushStyle();
			val.Style.SupressLayoutElement = true;
			LocaleString val2 = LocaleString.op_Implicit(text);
			Text obj = val.Text(ref val2, false, (Alignment?)(Alignment)0, true, (string)null);
			val.PopStyle();
			((SyncField<float>)(object)obj.Size).Value = 14f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsSubtext;
			((SyncField<float>)(object)obj.LineHeight).Value = 1.12f;
			((SyncField<bool>)(object)obj.ParseRichText).Value = false;
		}

		private static void ResetSettingsToDefaults(SettingsPanelState state, DesktopSession session)
		{
			//IL_0035: 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)
			try
			{
				if (Config == null)
				{
					return;
				}
				ApplyFreshConfigDefaults();
				RefreshRuntimeStreamSettingsFromConfig();
				_settingsConfigDirty = false;
				Config.Save();
				ApplyStreamNetworkMode();
				Enumerator<DesktopSession> enumerator = Enumerable.ToList<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)ActiveSessions).GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						if (current != null && !current.Cleaned && current.SettingsPanel != null)
						{
							SyncLiveCullingStateFromConfig(current.SettingsPanel);
							UpdateCullingPreview(current, current.SettingsPanel);
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				ApplyStreamAudioSettingsToAllSessions();
				RequestStreamEncoderRestart(session, "settings reset");
				Msg("[Settings] Reset settings to defaults");
			}
			catch (global::System.Exception ex)
			{
				Msg("[Settings] Failed to reset defaults: " + ex.Message);
			}
		}

		private static void UpdateDebugLogText(SettingsPanelState state)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			if (state?.DebugLogText == null || ((ComponentBase<Component>)(object)state.DebugLogText).IsDestroyed)
			{
				return;
			}
			string text = string.Join("\n", Log.GetRecentLines());
			if (text == state.DebugLogContent)
			{
				return;
			}
			state.DebugLogContent = text;
			((SyncField<string>)(object)state.DebugLogText.Content).Value = text;
			ScheduleScrollbarGeometryUpdate(state);
			Slot ownerRoot = state.OwnerRoot;
			if (ownerRoot == null)
			{
				return;
			}
			World world = ((Worker)ownerRoot).World;
			if (world == null)
			{
				return;
			}
			world.RunInUpdates(1, (Action)delegate
			{
				if (state.DebugLogScroll != null && !((ComponentBase<Component>)(object)state.DebugLogScroll).IsDestroyed)
				{
					state.DebugLogScroll.MoveToBottom();
				}
			});
		}

		private static void ScheduleDebugLogRefresh(SettingsPanelState state, DesktopSession session)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			SettingsPanelState settingsPanelState = state;
			object obj;
			if (settingsPanelState == null)
			{
				obj = null;
			}
			else
			{
				Slot ownerRoot = settingsPanelState.OwnerRoot;
				obj = ((ownerRoot != null) ? ((Worker)ownerRoot).World : null);
			}
			if (obj == null)
			{
				return;
			}
			int generation = ++state.DebugLogRefreshGeneration;
			((Worker)state.OwnerRoot).World.RunInUpdates(60, (Action)delegate
			{
				if (state.SurfaceSlot != null && !((ContainerWorker<Component>)(object)state.SurfaceSlot).IsDestroyed && state.SurfaceSlot.ActiveSelf && state.ActiveTab == SettingsPanelTab.Debug && state.DebugLogRefreshGeneration == generation)
				{
					UpdateDebugLogText(state);
					ScheduleDebugLogRefresh(state, session);
				}
			});
		}

		private static void BuildDevicesTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			AddSectionHeader(ui, "Virtual Devices");
			bool flag = SoftCam.IsFilterRegistered();
			bool flag2 = VBCable.HasCableInputDevice();
			AddStatusRow(ui, state, "SoftCam", flag ? "Installed" : "Missing", flag ? SettingsStatusGood : SettingsStatusBad);
			AddStatusRow(ui, state, "VB-Cable", flag2 ? "Installed" : "Missing", flag2 ? SettingsStatusGood : SettingsStatusBad);
			AddCheckbox(ui, state, "Virtual camera enabled", VCam != null && !VCam.ManuallyDisabled, delegate(bool value)
			{
				if (VCam != null)
				{
					VCam.ManuallyDisabled = !value;
				}
			});
			if (DesktopBuddyPlatform.IsLinux)
			{
				object obj = <>c.<>9__375_1;
				if (obj == null)
				{
					Action val = delegate
					{
						LinuxVirtualCameraSetup.Run();
					};
					<>c.<>9__375_1 = val;
					obj = (object)val;
				}
				AddButtonRow(ui, state, "Virtual camera setup (requires v4l2loopback installed)", (Action)obj, selected: false, "Configure");
			}
			AddVirtualCameraPreview(ui, state, session);
			AddCheckbox(ui, state, "Virtual mic muted", session?.VMicMuted ?? false, delegate(bool value)
			{
				if (session != null)
				{
					session.VMicMuted = value;
				}
				if (VMic != null)
				{
					VMic.Muted = value;
				}
			});
		}

		private static void AddVirtualCameraPreview(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Camera Preview");
			float num = Math.Clamp(((float)state.ModalWidth - 120f) * 9f / 16f, 150f, 340f);
			ui.Style.MinHeight = num;
			ui.Style.PreferredHeight = num;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			colorX val = new colorX(0.065f, 0.072f, 0.09f, 0.78f, (ColorProfile)1);
			Image val2 = ui.Image(ref val, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val2).Slot, ((Worker)state.Canvas).World, 18f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val2).RectTransform);
			ui.LayoutTarget = ((Component)val2).Slot;
			RenderTextureProvider val3 = StartVirtualCameraPreview(state, session);
			if (val3 == null)
			{
				ui.VerticalLayout(0f, 10f, 10f, 10f, 10f, (Alignment?)(Alignment)4, (bool?)null, (bool?)null);
				ui.Style.MinHeight = num - 20f;
				ui.Style.PreferredHeight = num - 20f;
				ui.Style.FlexibleWidth = 1f;
				LocaleString val4 = LocaleString.op_Implicit("Virtual camera preview unavailable");
				Text obj = ui.Text(ref val4, true, (Alignment?)(Alignment)4, true, (string)null);
				((SyncField<float>)(object)obj.Size).Value = 18f;
				((SyncField<colorX>)(object)obj.Color).Value = SettingsSubtext;
				ui.NestOut();
				return;
			}
			ui.PushStyle();
			ui.Style.SupressLayoutElement = true;
			SpriteProvider val5 = CreateRoundedSprite(((Component)val2).Slot, ((Worker)state.Canvas).World, 16f);
			Image val6 = default(Image);
			ui.SpriteMask((IAssetProvider<Sprite>)(object)val5, false, ref val6);
			((SyncField<colorX>)(object)val6.Tint).Value = colorX.White;
			((SyncField<NineSliceSizing>)(object)((ImageBase)val6).NineSliceSizing).Value = (NineSliceSizing)0;
			((SyncField<float2>)(object)((UIComponent)val6).RectTransform.AnchorMin).Value = float2.Zero;
			((SyncField<float2>)(object)((UIComponent)val6).RectTransform.AnchorMax).Value = float2.One;
			((SyncField<float2>)(object)((UIComponent)val6).RectTransform.OffsetMin).Value = new float2(10f, 10f);
			((SyncField<float2>)(object)((UIComponent)val6).RectTransform.OffsetMax).Value = new float2(-10f, -10f);
			ui.Nest();
			RawImage obj2 = ui.RawImage((IAssetProvider<ITexture2D>)(object)val3, true);
			((SyncField<colorX>)(object)obj2.Tint).Value = colorX.White;
			((SyncField<bool>)(object)obj2.InteractionTarget).Value = false;
			((SyncField<float2>)(object)((UIComponent)obj2).RectTransform.AnchorMin).Value = float2.Zero;
			((SyncField<float2>)(object)((UIComponent)obj2).RectTransform.AnchorMax).Value = float2.One;
			((SyncField<float2>)(object)((UIComponent)obj2).RectTransform.OffsetMin).Value = float2.Zero;
			((SyncField<float2>)(object)((UIComponent)obj2).RectTransform.OffsetMax).Value = float2.Zero;
			ui.NestOut();
			ui.PopStyle();
			ui.NestOut();
		}

		private static RenderTextureProvider StartVirtualCameraPreview(SettingsPanelState state, DesktopSession session)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			if (state?.ContentRoot == null || ((ContainerWorker<Component>)(object)state.ContentRoot).IsDestroyed || session?.VCamCamera == null || ((ComponentBase<Component>)(object)session.VCamCamera).IsDestroyed)
			{
				return null;
			}
			StopVirtualCameraPreview(session);
			Slot obj = state.ContentRoot.AddSlot("VirtualCameraPreviewTexture", false);
			obj.PersistentSelf = false;
			RenderTextureProvider val = ((ContainerWorker<Component>)(object)obj).AttachComponent<RenderTextureProvider>(true, (Action<RenderTextureProvider>)null);
			((SyncField<int2>)(object)val.Size).Value = new int2(640, 360);
			((SyncField<TextureWrapMode>)(object)val.WrapModeU).Value = (TextureWrapMode)1;
			((SyncField<TextureWrapMode>)(object)val.WrapModeV).Value = (TextureWrapMode)1;
			session.VCamPreviewTexture = val;
			((SyncRef<IAssetProvider<RenderTexture>>)(object)session.VCamCamera.RenderTexture).Target = (IAssetProvider<RenderTexture>)(object)val;
			return val;
		}

		private static void StopVirtualCameraPreview(DesktopSession session)
		{
			if (session == null)
			{
				return;
			}
			try
			{
				RenderTextureProvider vCamPreviewTexture = session.VCamPreviewTexture;
				if (session.VCamCamera != null && !((ComponentBase<Component>)(object)session.VCamCamera).IsDestroyed && vCamPreviewTexture != null && !((ComponentBase<Component>)(object)vCamPreviewTexture).IsDestroyed && (object)((SyncRef<IAssetProvider<RenderTexture>>)(object)session.VCamCamera.RenderTexture).Target == vCamPreviewTexture)
				{
					((SyncRef<IAssetProvider<RenderTexture>>)(object)session.VCamCamera.RenderTexture).Target = null;
				}
				if (vCamPreviewTexture != null && !((ComponentBase<Component>)(object)vCamPreviewTexture).IsDestroyed)
				{
					((Component)vCamPreviewTexture).Slot.Destroy();
				}
				session.VCamPreviewTexture = null;
			}
			catch (global::System.Exception ex)
			{
				Msg("[Settings] Virtual camera preview cleanup failed: " + ex.Message);
				session.VCamPreviewTexture = null;
			}
		}

		private static void BuildGeneralTab(UIBuilder ui, SettingsPanelState state)
		{
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "General");
			AddCheckbox(ui, state, "Show in context menu", Config?.GetValue(ShowContextMenuItem) ?? true, delegate(bool value)
			{
				SaveConfigValue(ShowContextMenuItem, value);
			});
			AddCheckbox(ui, state, "Throw to destroy", Config?.GetValue(ThrowToDestroy) ?? true, delegate(bool value)
			{
				SaveConfigValue(ThrowToDestroy, value);
			});
			AddCheckbox(ui, state, "Dynamic lights", Config?.GetValue(DynamicLightsEnabled) ?? false, delegate(bool value)
			{
				SaveConfigValue(DynamicLightsEnabled, value);
			});
			AddSectionHeader(ui, "Auto-Spawned Windows");
			AddCheckbox(ui, state, "Auto-open new app windows", Config?.GetValue(SpawnNewWindowsInGame) ?? true, delegate(bool value)
			{
				SaveConfigValue(SpawnNewWindowsInGame, value);
			});
			AddCheckbox(ui, state, "Auto-opened windows start private", Config?.GetValue(SpawnNewWindowsPrivate) ?? true, delegate(bool value)
			{
				SaveConfigValue(SpawnNewWindowsPrivate, value);
			});
			AddSectionHeader(ui, "Manually Spawned Windows");
			AddCheckbox(ui, state, "Windows I open start private", Config?.GetValue(NewWindowsStartPrivate) ?? true, delegate(bool value)
			{
				SaveConfigValue(NewWindowsStartPrivate, value);
			});
			AddSectionHeader(ui, "Audio");
			AddCheckboxWithBadge(ui, state, "Spatial audio", "(Experimental)", SettingsExperimentalOrange, Config?.GetValue(SpatialAudioEnabled) ?? false, delegate(bool value)
			{
				SaveConfigValue(SpatialAudioEnabled, value);
			});
		}

		private static void ResizeSettingsPanel(DesktopSession session, int width, int height, float canvasScale, float curvature)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			SettingsPanelState settingsPanelState = session?.SettingsPanel;
			if (settingsPanelState != null)
			{
				SettingsPanelState settingsPanelState2 = settingsPanelState;
				ValueTuple<int, int> settingsModalSize = GetSettingsModalSize(width, height);
				settingsPanelState.ModalWidth = settingsModalSize.Item1;
				settingsPanelState2.ModalHeight = settingsModalSize.Item2;
				settingsPanelState.RenderWidth = Math.Max(1, width);
				settingsPanelState.RenderHeight = Math.Max(1, height);
				settingsPanelState.CanvasScale = canvasScale;
				if (settingsPanelState.RenderTexture != null && !((ComponentBase<Component>)(object)settingsPanelState.RenderTexture).IsDestroyed)
				{
					((SyncField<int2>)(object)settingsPanelState.RenderTexture.Size).Value = new int2(settingsPanelState.RenderWidth, settingsPanelState.RenderHeight);
				}
				if (settingsPanelState.Camera != null && !((ComponentBase<Component>)(object)settingsPanelState.Camera).IsDestroyed)
				{
					((SyncField<float>)(object)settingsPanelState.Camera.OrthographicSize).Value = (float)settingsPanelState.RenderHeight * 0.5f;
				}
				if (settingsPanelState.Canvas != null && !((ComponentBase<Component>)(object)settingsPanelState.Canvas).IsDestroyed)
				{
					((SyncField<float2>)(object)settingsPanelState.Canvas.Size).Value = new float2((float)settingsPanelState.RenderWidth, (float)settingsPanelState.RenderHeight);
				}
				if (settingsPanelState.Mesh != null && !((ComponentBase<Component>)(object)settingsPanelState.Mesh).IsDestroyed)
				{
					((SyncField<float2>)(object)settingsPanelState.Mesh.Size).Value = new float2((float)settingsPanelState.RenderWidth, (float)settingsPanelState.RenderHeight);
					((SyncField<float>)(object)settingsPanelState.Mesh.Curvature).Value = curvature;
					Slot slot = ((Component)settingsPanelState.Mesh).Slot;
					float3 one = float3.One;
					slot.LocalScale = (ref one) * canvasScale;
					((Component)settingsPanelState.Mesh).Slot.LocalPosition = new float3(0f, 0f, GetSettingsPanelZOffset(session, canvasScale));
				}
				UpdateSettingsBlurMask(settingsPanelState);
				SetSettingsModalRect(settingsPanelState);
				UpdateCullingPreview(session, settingsPanelState);
			}
		}

		private static float GetSettingsPanelZOffset(DesktopSession session, float canvasScale)
		{
			return -0.018f;
		}

		private static void SyncLiveCullingStateFromConfig(SettingsPanelState state)
		{
			if (state != null)
			{
				state.ViewerCullingPreviewEnabled = Config?.GetValue(ViewerCullingPreview) ?? false;
				state.ViewerCullingMode = NormalizeViewerCullingMode(Config?.GetValue(ViewerCullingMode));
				state.ViewerFrustumAngle = NormalizeViewerFrustumAngle(Config?.GetValue(ViewerFrustumWidth) ?? 120f);
				state.ViewerDistance = (state.ViewerFrustumDepth = Math.Clamp(Config?.GetValue(ViewerDistance) ?? Config?.GetValue(ViewerFrustumDepth) ?? 3f, 1f, 10f));
			}
		}

		private static void SetSettingsModalRect(SettingsPanelState state)
		{
			//IL_004a: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if (state?.ModalRect != null && !((ComponentBase<Component>)(object)state.ModalRect).IsDestroyed)
			{
				RectTransform modalRect = state.ModalRect;
				Rect val = new Rect((float)state.ModalWidth * -0.5f, (float)state.ModalHeight * -0.5f, (float)state.ModalWidth, (float)state.ModalHeight);
				float2 val2 = new float2(0.5f, 0.5f);
				modalRect.SetFixedRect(val, ref val2);
			}
		}

		private static void UpdateSettingsBlurMask(SettingsPanelState state)
		{
			<>c__DisplayClass384_0 CS$<>8__locals7 = new <>c__DisplayClass384_0();
			if (state?.BackgroundBlur == null || ((ComponentBase<Component>)(object)state.BackgroundBlur).IsDestroyed || state.BackgroundBlurMask == null || ((ComponentBase<Component>)(object)state.BackgroundBlurMask).IsDestroyed || state.OwnerRoot == null || ((ContainerWorker<Component>)(object)state.OwnerRoot).IsDestroyed)
			{
				return;
			}
			int num = Math.Max(1, state.RenderWidth);
			int num2 = Math.Max(1, state.RenderHeight);
			int pillW = Math.Max(1, Math.Min(num, state.ModalWidth));
			int pillH = Math.Max(1, Math.Min(num2, state.ModalHeight));
			if (state.BackgroundBlurMaskWidth != num || state.BackgroundBlurMaskHeight != num2)
			{
				state.BackgroundBlurMaskWidth = num;
				state.BackgroundBlurMaskHeight = num2;
				CS$<>8__locals7.tex = state.BackgroundBlurMask;
				CS$<>8__locals7.blur = state.BackgroundBlur;
				CS$<>8__locals7.engine = ((Worker)state.OwnerRoot).Engine;
				CS$<>8__locals7.data = CreateCenteredRoundedMaskPixels(num, num2, pillW, pillH, 28f, out CS$<>8__locals7.texW, out CS$<>8__locals7.texH);
				global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass384_0.<<UpdateSettingsBlurMask>b__0>d))] () =>
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass384_0.<<UpdateSettingsBlurMask>b__0>d <<UpdateSettingsBlurMask>b__0>d = default(<>c__DisplayClass384_0.<<UpdateSettingsBlurMask>b__0>d);
					<<UpdateSettingsBlurMask>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
					<<UpdateSettingsBlurMask>b__0>d.<>4__this = CS$<>8__locals7;
					<<UpdateSettingsBlurMask>b__0>d.<>1__state = -1;
					((AsyncTaskMethodBuilder)(ref <<UpdateSettingsBlurMask>b__0>d.<>t__builder)).Start<<>c__DisplayClass384_0.<<UpdateSettingsBlurMask>b__0>d>(ref <<UpdateSettingsBlurMask>b__0>d);
					return ((AsyncTaskMethodBuilder)(ref <<UpdateSettingsBlurMask>b__0>d.<>t__builder)).Task;
				}));
			}
		}

		private static byte[] CreateRoundedMaskPixels(int modalW, int modalH, float radiusPixels, out int texW, out int texH)
		{
			float num = (float)modalW / (float)Math.Max(1, modalH);
			if (num >= 1f)
			{
				texW = 512;
				texH = Math.Clamp((int)MathF.Round((float)texW / num), 128, 512);
			}
			else
			{
				texH = 512;
				texW = Math.Clamp((int)MathF.Round((float)texH * num), 128, 512);
			}
			byte[] array = new byte[texW * texH * 4];
			float num2 = Math.Clamp(radiusPixels, 1f, (float)Math.Min(modalW, modalH) * 0.5f);
			for (int i = 0; i < texH; i++)
			{
				float num3 = ((float)i + 0.5f) / (float)texH * (float)modalH;
				for (int j = 0; j < texW; j++)
				{
					float num4 = ((float)j + 0.5f) / (float)texW * (float)modalW;
					float num5 = Math.Clamp(num4, num2, (float)modalW - num2);
					float num6 = Math.Clamp(num3, num2, (float)modalH - num2);
					float num7 = MathF.Sqrt((num4 - num5) * (num4 - num5) + (num3 - num6) * (num3 - num6));
					byte b = (byte)Math.Clamp((int)MathF.Round((1f - Math.Clamp((num7 - (num2 - 2f)) / 4f, 0f, 1f)) * 255f), 0, 255);
					int num8 = (i * texW + j) * 4;
					array[num8] = b;
					array[num8 + 1] = b;
					array[num8 + 2] = b;
					array[num8 + 3] = 255;
				}
			}
			return array;
		}

		private static byte[] CreateCenteredRoundedMaskPixels(int canvasW, int canvasH, int pillW, int pillH, float radiusPixels, out int texW, out int texH)
		{
			float num = (float)canvasW / (float)Math.Max(1, canvasH);
			if (num >= 1f)
			{
				texW = 512;
				texH = Math.Clamp((int)MathF.Round((float)texW / num), 64, 512);
			}
			else
			{
				texH = 512;
				texW = Math.Clamp((int)MathF.Round((float)texH * num), 64, 512);
			}
			byte[] array = new byte[texW * texH * 4];
			float num2 = (float)(canvasW - pillW) * 0.5f;
			float num3 = num2 + (float)pillW;
			float num4 = (float)(canvasH - pillH) * 0.5f;
			float num5 = num4 + (float)pillH;
			float num6 = Math.Clamp(radiusPixels, 1f, (float)Math.Min(pillW, pillH) * 0.5f);
			for (int i = 0; i < texH; i++)
			{
				float num7 = ((float)i + 0.5f) / (float)texH * (float)canvasH;
				for (int j = 0; j < texW; j++)
				{
					float num8 = ((float)j + 0.5f) / (float)texW * (float)canvasW;
					float num9 = Math.Clamp(num8, num2 + num6, num3 - num6);
					float num10 = Math.Clamp(num7, num4 + num6, num5 - num6);
					float num11 = MathF.Sqrt((num8 - num9) * (num8 - num9) + (num7 - num10) * (num7 - num10));
					float num12 = 1f - Math.Clamp((num11 - (num6 - 2f)) / 4f, 0f, 1f);
					if (num8 < num2 || num8 > num3 || num7 < num4 || num7 > num5)
					{
						num12 = 0f;
					}
					byte b = (byte)Math.Clamp((int)MathF.Round(num12 * 255f), 0, 255);
					int num13 = (i * texW + j) * 4;
					array[num13] = b;
					array[num13 + 1] = b;
					array[num13 + 2] = b;
					array[num13 + 3] = 255;
				}
			}
			return array;
		}

		private static ValueTuple<int, int> GetSettingsModalSize(int panelWidth, int panelHeight)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			int num = Math.Max(360, Math.Min(1120, panelWidth - 120));
			int num2 = Math.Max(300, Math.Min(760, panelHeight - 120));
			int num3 = Math.Min(720, num);
			int num4 = Math.Min(480, num2);
			int num5 = (int)Math.Clamp((float)panelWidth * 0.62f, (float)num3, (float)num);
			int num6 = (int)Math.Clamp((float)panelHeight * 0.68f, (float)num4, (float)num2);
			return new ValueTuple<int, int>(num5, num6);
		}

		private static void DestroyLayoutControllers(Slot slot)
		{
			UiPrimitiveStyles.DestroyLayoutControllers(slot);
		}

		private static void AddSectionHeader(UIBuilder ui, string text)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 56f;
			ui.Style.PreferredHeight = 56f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			colorX val = new colorX(0.035f, 0.04f, 0.052f, 0.58f, (ColorProfile)1);
			Image val2 = ui.Image(ref val, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val2).Slot, ((Worker)ui.Root).World, 16f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val2).RectTransform);
			ui.LayoutTarget = ((Component)val2).Slot;
			ui.HorizontalLayout(12f, 8f, 14f, 8f, 14f, (Alignment?)(Alignment)3);
			ui.Style.MinWidth = 5f;
			ui.Style.PreferredWidth = 5f;
			ui.Style.MinHeight = 28f;
			ui.Style.PreferredHeight = 28f;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.FlexibleHeight = -1f;
			Image val3 = ui.Image(ref SettingsAccent, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val3).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val3).Slot, ((Worker)ui.Root).World, 5f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val3).NineSliceSizing).Value = (NineSliceSizing)0;
			ApplyPurpleBlueGradient(val3, 5f, 1f, interactionTarget: false);
			ui.Style.MinWidth = 0f;
			ui.Style.PreferredWidth = 0f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			ui.Style.FlexibleWidth = 1f;
			LocaleString val4 = LocaleString.op_Implicit(text);
			Text obj = ui.Text(ref val4, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 23f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.NestOut();
		}

		private static void AddBodyText(UIBuilder ui, string text)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			ui.Style.FlexibleWidth = 1f;
			LocaleString val = LocaleString.op_Implicit(text ?? "");
			Text obj = ui.Text(ref val, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsSubtext;
		}

		private static void AddInfoRow(UIBuilder ui, SettingsPanelState state, string label, string value)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 48f;
			ui.Style.PreferredHeight = 48f;
			ui.Style.FlexibleWidth = 1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 7f, 12f, 7f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 32f;
			ui.Style.PreferredHeight = 32f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsSubtext;
			ui.Style.FlexibleWidth = 1f;
			val2 = LocaleString.op_Implicit(value ?? "");
			Text obj2 = ui.Text(ref val2, true, (Alignment?)(Alignment)5, true, (string)null);
			((SyncField<float>)(object)obj2.Size).Value = 16f;
			((SyncField<colorX>)(object)obj2.Color).Value = SettingsText;
			ui.NestOut();
		}

		private static void AddStatusRow(UIBuilder ui, SettingsPanelState state, string label, string status, colorX badgeColor)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 48f;
			ui.Style.PreferredHeight = 48f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			((SyncField<bool>)(object)((DirectionalLayout)ui.HorizontalLayout(10f, 7f, 10f, 7f, 14f, (Alignment?)(Alignment)4)).ForceExpandHeight).Value = true;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 76f;
			ui.Style.PreferredWidth = 76f;
			ui.Style.MinHeight = 26f;
			ui.Style.PreferredHeight = 26f;
			Image val3 = ui.Image(ref badgeColor, false);
			LayoutElement obj2 = ((ContainerWorker<Component>)(object)((Component)val3).Slot).GetComponent<LayoutElement>((Predicate<LayoutElement>)null, false) ?? ((ContainerWorker<Component>)(object)((Component)val3).Slot).AttachComponent<LayoutElement>(true, (Action<LayoutElement>)null);
			((SyncField<float>)(object)obj2.MinWidth).Value = 76f;
			((SyncField<float>)(object)obj2.PreferredWidth).Value = 76f;
			((SyncField<float>)(object)obj2.FlexibleWidth).Value = -1f;
			((SyncField<float>)(object)obj2.MinHeight).Value = 26f;
			((SyncField<float>)(object)obj2.PreferredHeight).Value = 26f;
			((SyncField<float>)(object)obj2.FlexibleHeight).Value = -1f;
			StyleBadgePill(val3, badgeColor);
			ui.NestInto(((UIComponent)val3).RectTransform);
			ui.LayoutTarget = ((Component)val3).Slot;
			HorizontalLayout obj3 = ui.HorizontalLayout(0f, 0f, (Alignment?)(Alignment)4);
			((SyncField<bool>)(object)((DirectionalLayout)obj3).ForceExpandWidth).Value = true;
			((SyncField<bool>)(object)((DirectionalLayout)obj3).ForceExpandHeight).Value = true;
			ui.Style.MinHeight = 26f;
			ui.Style.PreferredHeight = 26f;
			ui.Style.FlexibleWidth = 1f;
			val2 = LocaleString.op_Implicit(status ?? "");
			Text obj4 = ui.Text(ref val2, true, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)obj4.Size).Value = 13f;
			((SyncField<colorX>)(object)obj4.Color).Value = SettingsText;
			ui.NestOut();
			ui.NestOut();
		}

		private static void BuildNetworkTab(UIBuilder ui, SettingsPanelState state)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Stream");
			AddStatusRow(ui, state, "Stream Server", (StreamServer == null) ? "Stopped" : "Running", (StreamServer == null) ? SettingsStatusBad : SettingsStatusGood);
			bool flag = NormalizeStreamNetworkMode(Config?.GetValue(StreamNetworkMode)) == "cloudflare";
			AddStatusRow(ui, state, "Cloudflare", (!flag) ? "Off" : ((TunnelUrl == null) ? "Waiting" : "Connected"), (!flag) ? SettingsStatusNeutral : ((TunnelUrl == null) ? SettingsStatusWarn : SettingsStatusGood));
			AddStatusRow(ui, state, "Port", 48080.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), SettingsStatusNeutral);
			AddOptionRow(ui, state, "Access", NormalizeStreamNetworkMode(Config?.GetValue(StreamNetworkMode)), new ValueTuple<string, string>[2]
			{
				new ValueTuple<string, string>("cloudflare", "Cloudflare"),
				new ValueTuple<string, string>("port_forward", "Port forward")
			}, delegate(string value)
			{
				SaveConfigValue(StreamNetworkMode, NormalizeStreamNetworkMode(value));
				ApplyStreamNetworkMode();
				RequestStreamEncoderRestart(state.Session, "network mode");
			});
			if (NormalizeStreamNetworkMode(Config?.GetValue(StreamNetworkMode)) == "port_forward")
			{
				AddCheckbox(ui, state, "Auto NAT / UPnP", Config?.GetValue(PortForwardUseNat) ?? false, delegate(bool value)
				{
					SaveConfigValue(PortForwardUseNat, value);
					ApplyStreamNetworkMode();
				});
				AddOptionRow(ui, state, "Host", NormalizePortForwardHostMode(Config?.GetValue(PortForwardHostMode)), new ValueTuple<string, string>[2]
				{
					new ValueTuple<string, string>("auto", "Auto public IP"),
					new ValueTuple<string, string>("manual", "Manual")
				}, delegate(string value)
				{
					SaveConfigValue(PortForwardHostMode, NormalizePortForwardHostMode(value));
					ApplyStreamNetworkMode();
				});
				if (NormalizePortForwardHostMode(Config?.GetValue(PortForwardHostMode)) == "manual")
				{
					AddStringField(ui, state, "Manual IP / host", Config?.GetValue(PortForwardHost) ?? "", delegate(string value)
					{
						SaveConfigValue(PortForwardHost, value.Trim());
						ApplyStreamNetworkMode();
					});
				}
				else
				{
					AddInfoRow(ui, state, "Auto public IP", ResolvePortForwardHost() ?? "");
				}
			}
			AddSectionHeader(ui, "MediaMTX");
			AddCheckbox(ui, state, "Use MediaMTX", Config?.GetValue(UseMediaMtx) ?? false, delegate(bool value)
			{
				SaveConfigValue(UseMediaMtx, value);
				ApplyStreamNetworkMode();
				RequestStreamEncoderRestart(state.Session, "MediaMTX mode");
			});
			AddStringField(ui, state, "Host", Config?.GetValue(MediaMtxHost) ?? "", delegate(string value)
			{
				SaveConfigValue(MediaMtxHost, value.Trim());
				ApplyStreamNetworkMode();
				RequestStreamEncoderRestart(state.Session, "MediaMTX host");
			});
			AddIntField(ui, state, "Port", Config?.GetValue(MediaMtxPort) ?? 8554, 1, 65535, delegate(int value)
			{
				SaveConfigValue(MediaMtxPort, value);
				ApplyStreamNetworkMode();
				RequestStreamEncoderRestart(state.Session, "MediaMTX port");
			});
			AddStringField(ui, state, "Stream name", Config?.GetValue(MediaMtxStreamName) ?? "", delegate(string value)
			{
				SaveConfigValue(MediaMtxStreamName, value.Trim());
				ApplyStreamNetworkMode();
				RequestStreamEncoderRestart(state.Session, "MediaMTX stream name");
			});
		}

		private static void AddOptionRow(UIBuilder ui, SettingsPanelState state, string label, string current, ValueTuple<string, string>[] options, Action<string> selected, int? preferredColumns = null, float cellWidth = 126f)
		{
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: 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_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Expected O, but got Unknown
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Expected O, but got Unknown
			int num = EstimateOptionColumns(state, options.Length, cellWidth, preferredColumns);
			int num2 = (int)Math.Ceiling((double)options.Length / (double)num);
			float num3 = Math.Max(62f, (float)num2 * 46f + 18f);
			ui.Style.MinHeight = num3;
			ui.Style.PreferredHeight = num3;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(14f, 9f, 12f, 9f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 160f;
			ui.Style.PreferredWidth = 160f;
			ui.Style.MinHeight = 40f;
			ui.Style.PreferredHeight = 40f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = Math.Max(42f, num3 - 18f);
			ui.Style.PreferredHeight = Math.Max(42f, num3 - 18f);
			Slot val3 = ui.Empty(label + " options");
			ui.NestOut();
			UIBuilder val4 = new UIBuilder(val3, (Slot)null)
			{
				LayoutTarget = val3
			};
			float2 val5 = new float2(cellWidth, 38f);
			float2 val6 = new float2(8f, 8f);
			((SyncField<bool>)(object)val4.GridLayout(ref val5, ref val6, (Alignment)5).AlignLastRowIndividually).Value = true;
			UIBuilder val7 = new UIBuilder(val3, (Slot)null);
			for (int i = 0; i < options.Length; i++)
			{
				ValueTuple<string, string> val8 = options[i];
				val7.Style.MinWidth = cellWidth;
				val7.Style.PreferredWidth = cellWidth;
				val7.Style.MinHeight = 38f;
				val7.Style.PreferredHeight = 38f;
				val7.Style.FlexibleWidth = -1f;
				colorX val9 = ((val8.Item1 == current) ? new colorX(0.22f, 0.34f, 0.42f, 0.98f, (ColorProfile)1) : new colorX(0.13f, 0.135f, 0.155f, 0.94f, (ColorProfile)1));
				val2 = LocaleString.op_Implicit(val8.Item2);
				colorX? val10 = val9;
				Button obj2 = val7.Button(ref val2, ref val10);
				StyleSettingsButton(obj2, val8.Item1 == current);
				string captured = val8.Item1;
				obj2.LocalPressed += (ButtonEventHandler)delegate
				{
					selected?.Invoke(captured);
					RebuildSettingsContent(state, null);
				};
			}
		}

		private static int EstimateOptionColumns(SettingsPanelState state, int optionCount, float cellWidth, int? preferredColumns)
		{
			int num = (int)Math.Floor((double)((Math.Max(cellWidth, (float)(state?.ModalWidth ?? 820) - 300f) + 8f) / (cellWidth + 8f)));
			return Math.Clamp((preferredColumns.HasValue && preferredColumns.Value <= num) ? preferredColumns.Value : num, 1, Math.Max(1, optionCount));
		}

		private static UIBuilder BeginRoundedScroll(UIBuilder ui, SettingsPanelState state, string name, float minHeight, Alignment alignment, out ScrollRect scroll, colorX? frameTint = null)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			return UiScrollbars.BeginRoundedScroll(ui, ((Worker)state.Canvas).World, (global::System.Collections.Generic.IList<UiScrollbarState>)state.Scrollbars, (Action)delegate
			{
				ScheduleScrollbarGeometryUpdate(state);
			}, SettingsScrollbarStyle, name, minHeight, alignment, out scroll, frameTint);
		}

		private static void ScheduleScrollbarGeometryUpdate(SettingsPanelState state)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			SettingsPanelState settingsPanelState = state;
			object obj;
			if (settingsPanelState == null)
			{
				obj = null;
			}
			else
			{
				Slot ownerRoot = settingsPanelState.OwnerRoot;
				obj = ((ownerRoot != null) ? ((Worker)ownerRoot).World : null);
			}
			World val = (World)obj;
			if (val != null)
			{
				val.RunInUpdates(2, (Action)delegate
				{
					UpdateScrollbarGeometry(state);
				});
			}
		}

		private static void UpdateScrollbarGeometry(SettingsPanelState state)
		{
			if (state?.Scrollbars != null)
			{
				UiScrollbars.UpdateGeometry((global::System.Collections.Generic.IEnumerable<UiScrollbarState>)state.Scrollbars);
			}
		}

		private static void ToggleSettingsPanel(Slot root, DesktopSession session, int width, int height, float canvasScale, float curvature)
		{
			OpenSettingsPanel(root, session, width, height, canvasScale, curvature, null, toggle: true);
		}

		private static void OpenSettingsPanel(Slot root, DesktopSession session, int width, int height, float canvasScale, float curvature, SettingsPanelTab? tab = null, bool toggle = false)
		{
			if (root == null || ((ContainerWorker<Component>)(object)root).IsDestroyed || session == null)
			{
				return;
			}
			if (session.SettingsPanel == null || session.SettingsPanel.SurfaceSlot == null || ((ContainerWorker<Component>)(object)session.SettingsPanel.SurfaceSlot).IsDestroyed)
			{
				CreateSettingsPanel(root, session, width, height, canvasScale, curvature);
			}
			SettingsPanelState settingsPanel = session.SettingsPanel;
			if (settingsPanel?.SurfaceSlot != null && !((ContainerWorker<Component>)(object)settingsPanel.SurfaceSlot).IsDestroyed)
			{
				if (tab.HasValue)
				{
					settingsPanel.ActiveTab = tab.Value;
				}
				bool flag = !toggle || !settingsPanel.SurfaceSlot.ActiveSelf;
				settingsPanel.SurfaceSlot.ActiveSelf = flag;
				if (settingsPanel.RenderHost != null && !((ContainerWorker<Component>)(object)settingsPanel.RenderHost).IsDestroyed)
				{
					settingsPanel.RenderHost.ActiveSelf = flag;
				}
				if (flag)
				{
					RebuildSettingsPanel(settingsPanel, session);
					StartSettingsStickScrollLoop(settingsPanel);
				}
				else
				{
					settingsPanel.StickScrollGeneration++;
					StopVirtualCameraPreview(session);
					FlushSettingsConfig();
				}
			}
		}

		private static void CreateSettingsPanel(Slot root, DesktopSession session, int width, int height, float canvasScale, float curvature)
		{
			//IL_0008: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			ValueTuple<int, int> settingsModalSize = GetSettingsModalSize(width, height);
			int item = settingsModalSize.Item1;
			int item2 = settingsModalSize.Item2;
			int num = Math.Max(1, width);
			int num2 = Math.Max(1, height);
			Slot host = root.AddSlot("DesktopBuddySettingsRenderHost", false);
			host.PersistentSelf = false;
			((ContainerWorker<Component>)(object)host).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			host.ActiveSelf = false;
			root.Destroyed += delegate
			{
				if (host != null && !((ContainerWorker<Component>)(object)host).IsDestroyed)
				{
					host.Destroy();
				}
			};
			Slot val = host.AddSlot("SettingsRender", true);
			((ContainerWorker<Component>)(object)val).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Slot obj = host.AddSlot("SettingsCamera", true);
			obj.LocalPosition = new float3(0f, 0f, -1f);
			RenderTextureProvider val2 = ((ContainerWorker<Component>)(object)obj).AttachComponent<RenderTextureProvider>(true, (Action<RenderTextureProvider>)null);
			((SyncField<int2>)(object)val2.Size).Value = new int2(num, num2);
			((SyncField<TextureWrapMode>)(object)val2.WrapModeU).Value = (TextureWrapMode)1;
			((SyncField<TextureWrapMode>)(object)val2.WrapModeV).Value = (TextureWrapMode)1;
			Camera val3 = ((ContainerWorker<Component>)(object)obj).AttachComponent<Camera>(true, (Action<Camera>)null);
			((SyncField<CameraProjection>)(object)val3.Projection).Value = (CameraProjection)1;
			((SyncField<float>)(object)val3.OrthographicSize).Value = (float)num2 * 0.5f;
			((SyncField<bool>)(object)val3.UseTransformScale).Value = true;
			((SyncField<CameraClearMode>)(object)val3.Clear).Value = (CameraClearMode)1;
			((SyncField<colorX>)(object)val3.ClearColor).Value = colorX.Clear;
			((SyncField<float>)(object)val3.NearClipping).Value = 0.01f;
			((SyncField<float>)(object)val3.FarClipping).Value = 4f;
			((SyncField<bool>)(object)val3.Postprocessing).Value = false;
			((SyncField<bool>)(object)val3.RenderShadows).Value = false;
			((SyncField<bool>)(object)val3.ForwardOnly).Value = true;
			((SyncRef<IAssetProvider<RenderTexture>>)(object)val3.RenderTexture).Target = (IAssetProvider<RenderTexture>)(object)val2;
			val3.SelectiveRender.Add(val);
			Slot val4 = val.AddSlot("SettingsCanvas", true);
			Canvas canvas = ((ContainerWorker<Component>)(object)val4).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			((SyncField<float2>)(object)canvas.Size).Value = new float2((float)num, (float)num2);
			((Collider)canvas.Collider.Target).SetTrigger();
			DesktopCanvasIds.Add(((Worker)canvas).ReferenceID);
			((ComponentBase<Component>)(object)canvas).Destroyed += delegate
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				DesktopCanvasIds.Remove(((Worker)canvas).ReferenceID);
			};
			Msg($"[Settings] Registered canvas {((Worker)canvas).ReferenceID} for locomotion suppression");
			SettingsPanelState settingsPanelState = (session.SettingsPanel = new SettingsPanelState
			{
				RenderHost = host,
				RenderRoot = val,
				Canvas = canvas,
				RenderTexture = val2,
				Camera = val3,
				OwnerRoot = root,
				Session = session,
				RenderWidth = num,
				RenderHeight = num2,
				ModalWidth = item,
				ModalHeight = item2,
				CanvasScale = canvasScale,
				ActiveTab = SettingsPanelTab.Viewers
			});
			CurvedPlaneMesh val5 = AddCurvedRenderPlane(root, "SettingsCurvedMesh", num, num2, canvasScale, 0f, GetSettingsPanelZOffset(session, canvasScale), (IAssetProvider<ITexture2D>)(object)val2, val3, addCollider: true, (Sidedness)1, (ZWrite)1, 80f, (BlendMode)2, 3004);
			((SyncField<float>)(object)val5.Curvature).Value = curvature;
			((Component)val5).Slot.ActiveSelf = false;
			settingsPanelState.Mesh = val5;
			settingsPanelState.SurfaceSlot = ((Component)val5).Slot;
			settingsPanelState.BackgroundBlur = AddCurvedMeshBackdropBlur(((Component)val5).Slot, val5, 64, 0.012f);
			settingsPanelState.BackgroundBlurMask = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)((Component)val5).Slot).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
			UpdateSettingsBlurMask(settingsPanelState);
			RegisterTopBarRaycastPortal(((Component)val5).Slot, val);
			BuildSettingsPanelShell(settingsPanelState, session);
			Msg("[Settings] Created shared curved settings panel");
		}

		private static void AddFloatSlider(UIBuilder ui, SettingsPanelState state, string label, float value, float min, float max, Action<float> changed, bool commitOnReleaseOnly = false, bool wholeNumbers = false)
		{
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			value = (wholeNumbers ? MathF.Round(value) : value);
			ui.Style.MinHeight = 92f;
			ui.Style.PreferredHeight = 92f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.VerticalLayout(8f, 10f, 14f, 12f, 14f, (Alignment?)(Alignment)0, (bool?)true, (bool?)false);
			ui.Style.MinHeight = 24f;
			ui.Style.PreferredHeight = 24f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			LocaleString val2 = LocaleString.op_Implicit(label + ": " + FormatSliderValue(value));
			Text valueLabel = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)valueLabel.Size).Value = 16f;
			((SyncField<colorX>)(object)valueLabel.Color).Value = new colorX(0.72f, 0.74f, 0.78f, 1f, (ColorProfile)1);
			ui.Style.MinHeight = 36f;
			ui.Style.PreferredHeight = 36f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val3 = default(Image);
			Image val4 = default(Image);
			Image val5 = default(Image);
			Slider<float> slider = ui.Slider<float>(22f, value, min, max, false, ref val3, ref val4, ref val5);
			((SyncField<colorX>)(object)val3.Tint).Value = SettingsPanelSoft;
			((SyncField<colorX>)(object)val4.Tint).Value = SettingsAccent;
			((SyncField<colorX>)(object)val5.Tint).Value = SettingsText;
			ApplyPurpleBlueGradient(val4, 10f, 0.98f, interactionTarget: false);
			GradientImage val6 = ApplyPurpleBlueGradient(val5, 18f, 0.98f, interactionTarget: false);
			if (val6 != null && ((SyncElementList<ColorDriver>)(object)((InteractionElement)slider).ColorDrivers).Count > 0)
			{
				((SyncRef<IField<colorX>>)(object)((SyncElementList<ColorDriver>)(object)((InteractionElement)slider).ColorDrivers)[0].ColorDrive).Target = (IField<colorX>)(object)val6.TintBottomRight;
			}
			float lastApplied = Math.Clamp(value, min, max);
			float lastCommitted = lastApplied;
			((SyncField<float>)(object)slider.Value).LocalFilter = delegate(float candidate, IField<float> field)
			{
				float num = Math.Clamp(candidate, min, max);
				if (wholeNumbers)
				{
					num = MathF.Round(num);
				}
				((SyncField<string>)(object)valueLabel.Content).Value = label + ": " + FormatSliderValue(num);
				if (Math.Abs(num - lastApplied) > 0.0001f)
				{
					lastApplied = num;
					if (!commitOnReleaseOnly)
					{
						changed?.Invoke(num);
					}
				}
				return num;
			};
			if (commitOnReleaseOnly)
			{
				((SyncField<bool>)(object)((InteractionElement)slider).IsPressed).OnValueChange += delegate(SyncField<bool> field)
				{
					if (!field.Value)
					{
						float num = Math.Clamp(((SyncField<float>)(object)slider.Value).Value, min, max);
						if (wholeNumbers)
						{
							num = MathF.Round(num);
						}
						if (!(Math.Abs(num - lastCommitted) <= 0.0001f))
						{
							lastCommitted = num;
							changed?.Invoke(num);
						}
					}
				};
			}
			ui.NestOut();
			string FormatSliderValue(float v)
			{
				if (!wholeNumbers)
				{
					return v.ToString("0.##", (IFormatProvider)(object)CultureInfo.InvariantCulture);
				}
				return MathF.Round(v).ToString("0", (IFormatProvider)(object)CultureInfo.InvariantCulture);
			}
		}

		private static void StartSettingsStickScrollLoop(SettingsPanelState state)
		{
			if (state != null)
			{
				UiStickScroll.StartLoop(state.OwnerRoot, state.SurfaceSlot, state.RenderRoot, () => ++state.StickScrollGeneration, () => state.StickScrollGeneration, 0.16f, 36f);
			}
		}

		private static void ProcessSettingsStickScroll(SettingsPanelState state)
		{
			object obj;
			if (state == null)
			{
				obj = null;
			}
			else
			{
				Slot ownerRoot = state.OwnerRoot;
				obj = ((ownerRoot != null) ? ((Worker)ownerRoot).World : null);
			}
			if (obj != null)
			{
				UiStickScroll.Process(((Worker)state.OwnerRoot).World, state.RenderRoot, 0.16f, 36f);
			}
		}

		private static void BuildStreamTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Stream");
			int currentResolution = NormalizeStreamResolution(RuntimeMaxStreamResolution);
			int currentFps = NormalizeStreamFps(RuntimeStreamFps);
			AddOptionRow(ui, state, "Resolution", currentResolution.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), Enumerable.ToArray<ValueTuple<string, string>>(Enumerable.Select<ValueTuple<int, string>, ValueTuple<string, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)StreamResolutionOptions, (Func<ValueTuple<int, string>, ValueTuple<string, string>>)((ValueTuple<int, string> option) => new ValueTuple<string, string>(option.Item1.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), option.Item2)))), delegate(string value)
			{
				int value2 = default(int);
				if (int.TryParse(value, (NumberStyles)7, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref value2))
				{
					value2 = NormalizeStreamResolution(value2);
					SaveConfigValue(MaxStreamResolution, value2);
					SaveConfigValue(Bitrate, RecommendedBitrateMbps(value2, currentFps));
					RequestStreamEncoderRestart(session, "stream resolution");
				}
			}, 4, 108f);
			AddOptionRow(ui, state, "FPS", currentFps.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), Enumerable.ToArray<ValueTuple<string, string>>(Enumerable.Select<ValueTuple<int, string>, ValueTuple<string, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)StreamFpsOptions, (Func<ValueTuple<int, string>, ValueTuple<string, string>>)((ValueTuple<int, string> option) => new ValueTuple<string, string>(option.Item1.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture), option.Item2)))), delegate(string value)
			{
				int value2 = default(int);
				if (int.TryParse(value, (NumberStyles)7, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref value2))
				{
					value2 = NormalizeStreamFps(value2);
					SaveConfigValue(StreamFps, value2);
					SaveConfigValue(Bitrate, RecommendedBitrateMbps(currentResolution, value2));
					RequestStreamEncoderRestart(session, "stream FPS");
				}
			}, 4, 108f);
			int num = Math.Clamp(RuntimeBitrateMbps, 1, 200);
			AddFloatSlider(ui, state, "Bitrate Mbps", num, 4f, 80f, delegate(float value)
			{
				SaveConfigValue(Bitrate, Math.Clamp((int)MathF.Round(value), 1, 200));
				RequestStreamEncoderRestart(session, "stream bitrate");
			}, commitOnReleaseOnly: true, wholeNumbers: true);
			AddSectionHeader(ui, "Encoder");
			AddOptionRow(ui, state, "Preference", RuntimeEncoderPreference, new ValueTuple<string, string>[9]
			{
				new ValueTuple<string, string>("auto", "Auto"),
				new ValueTuple<string, string>("hevc_nvenc", "HEVC NVENC"),
				new ValueTuple<string, string>("h264_nvenc", "H264 NVENC"),
				new ValueTuple<string, string>("hevc_amf", "HEVC AMF"),
				new ValueTuple<string, string>("h264_amf", "H264 AMF"),
				new ValueTuple<string, string>("hevc_qsv", "HEVC QSV"),
				new ValueTuple<string, string>("h264_qsv", "H264 QSV"),
				new ValueTuple<string, string>("libx264", "libx264"),
				new ValueTuple<string, string>("libx265", "libx265")
			}, delegate(string value)
			{
				SaveConfigValue(EncoderPreference, value);
				RequestStreamEncoderRestart(session, "encoder preference");
			});
			string current = Config?.GetValue(PreferredGpuLuid)?.Trim() ?? "";
			List<WgcCapture.GpuAdapterInfo> val = Enumerable.ToList<WgcCapture.GpuAdapterInfo>(Enumerable.Select<IGrouping<string, WgcCapture.GpuAdapterInfo>, WgcCapture.GpuAdapterInfo>(Enumerable.GroupBy<WgcCapture.GpuAdapterInfo, string>(Enumerable.Where<WgcCapture.GpuAdapterInfo>((global::System.Collections.Generic.IEnumerable<WgcCapture.GpuAdapterInfo>)WgcCapture.EnumerateAdapters(), (Func<WgcCapture.GpuAdapterInfo, bool>)((WgcCapture.GpuAdapterInfo g) => !g.IsBasicRenderDriver && !string.IsNullOrWhiteSpace(g.Name))), (Func<WgcCapture.GpuAdapterInfo, string>)((WgcCapture.GpuAdapterInfo g) => NormalizeGpuDisplayName(g.Name)), (IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase), (Func<IGrouping<string, WgcCapture.GpuAdapterInfo>, WgcCapture.GpuAdapterInfo>)((IGrouping<string, WgcCapture.GpuAdapterInfo> group) => Enumerable.First<WgcCapture.GpuAdapterInfo>((global::System.Collections.Generic.IEnumerable<WgcCapture.GpuAdapterInfo>)group))));
			List<ValueTuple<string, string>> obj = new List<ValueTuple<string, string>>();
			obj.Add(new ValueTuple<string, string>("", "Auto"));
			List<ValueTuple<string, string>> val2 = obj;
			val2.AddRange(Enumerable.Select<WgcCapture.GpuAdapterInfo, ValueTuple<string, string>>((global::System.Collections.Generic.IEnumerable<WgcCapture.GpuAdapterInfo>)val, (Func<WgcCapture.GpuAdapterInfo, ValueTuple<string, string>>)((WgcCapture.GpuAdapterInfo gpu) => new ValueTuple<string, string>("0x" + gpu.Luid.ToString("X16", (IFormatProvider)(object)CultureInfo.InvariantCulture), NormalizeGpuDisplayName(gpu.Name)))));
			AddOptionRow(ui, state, "Preferred GPU", current, val2.ToArray(), delegate(string value)
			{
				SaveConfigValue(PreferredGpuLuid, value ?? "");
				RequestStreamEncoderRestart(session, "preferred GPU");
			}, null, 220f);
		}

		private static string NormalizeGpuDisplayName(string name)
		{
			string text = (name ?? "Unnamed GPU").Trim();
			char[] array = new char[4];
			RuntimeHelpers.InitializeArray((global::System.Array)array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			return string.Join(" ", text.Split(array, (StringSplitOptions)1));
		}

		private static int NormalizeStreamResolution(int value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			return Enumerable.First<ValueTuple<int, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)Enumerable.OrderBy<ValueTuple<int, string>, int>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)StreamResolutionOptions, (Func<ValueTuple<int, string>, int>)((ValueTuple<int, string> option) => Math.Abs(option.Item1 - value)))).Item1;
		}

		private static int NormalizeStreamFps(int value)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			return Enumerable.First<ValueTuple<int, string>>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)Enumerable.OrderBy<ValueTuple<int, string>, int>((global::System.Collections.Generic.IEnumerable<ValueTuple<int, string>>)StreamFpsOptions, (Func<ValueTuple<int, string>, int>)((ValueTuple<int, string> option) => Math.Abs(option.Item1 - value)))).Item1;
		}

		private static int RecommendedBitrateMbps(int longEdge, int fps)
		{
			longEdge = NormalizeStreamResolution(longEdge);
			fps = NormalizeStreamFps(fps);
			float num = longEdge;
			float num2 = (float)longEdge * 9f / 16f;
			return Math.Clamp((int)MathF.Round(num * num2 * (float)fps * 0.11f / 1000000f), 4, 80);
		}

		private static SpriteProvider CreateRoundedSprite(Slot slot, World world, float fixedSize)
		{
			return UiPrimitiveStyles.CreateRoundedSprite(slot, world, fixedSize);
		}

		private static GradientImage ApplyPurpleBlueGradient(Image image, float fixedSize, float alpha, bool interactionTarget)
		{
			return UiPrimitiveStyles.ApplyDiagonalGradient(image, fixedSize, alpha, interactionTarget, SettingsGradientPalette);
		}

		private static void ApplyButtonGradient(Button button, bool selected)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			Image val = ((button == null) ? null : ((ContainerWorker<Component>)(object)((Component)button).Slot)?.GetComponent<Image>((Predicate<Image>)null, false));
			if (val == null)
			{
				return;
			}
			if (!selected)
			{
				GradientImage component = ((ContainerWorker<Component>)(object)((Component)button).Slot).GetComponent<GradientImage>((Predicate<GradientImage>)null, false);
				if (component != null)
				{
					((ComponentBase<Component>)(object)component).Enabled = false;
				}
				((ComponentBase<Component>)(object)val).Enabled = true;
				((SyncField<bool>)(object)((ImageBase)val).InteractionTarget).Value = true;
				((SyncField<colorX>)(object)val.Tint).Value = SettingsPanelSoft;
				if (((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Count > 0)
				{
					((SyncRef<IField<colorX>>)(object)((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[0].ColorDrive).Target = (IField<colorX>)(object)val.Tint;
					((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[0].SetColors(ref SettingsPanelSoft);
				}
			}
			else
			{
				GradientImage val2 = ApplyPurpleBlueGradient(val, selected ? 14f : 12f, selected ? 0.98f : 0.54f, interactionTarget: true);
				if (val2 != null)
				{
					((ComponentBase<Component>)(object)val2).Enabled = true;
					UiPrimitiveStyles.ConfigureGradientButtonDriver(button, 1, val2.TintTopLeft, ((colorX)(ref SettingsGradientPurple)).SetA(selected ? 0.98f : 0.54f));
					UiPrimitiveStyles.ConfigureGradientButtonDriver(button, 2, val2.TintTopRight, ((colorX)(ref SettingsGradientMid)).SetA(selected ? 0.98f : 0.54f));
					UiPrimitiveStyles.ConfigureGradientButtonDriver(button, 3, val2.TintBottomLeft, ((colorX)(ref SettingsGradientMid)).SetA(selected ? 0.98f : 0.54f));
					UiPrimitiveStyles.ConfigureGradientButtonDriver(button, 4, val2.TintBottomRight, ((colorX)(ref SettingsGradientBlue)).SetA(selected ? 0.98f : 0.54f));
				}
			}
		}

		private static void StyleBadgePill(Image image, colorX color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			UiPrimitiveStyles.StyleRoundedPill(image, color, 12f, interactionTarget: false);
		}

		private static void StyleSettingsButton(Button button, bool selected)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (button != null)
			{
				Image component = ((ContainerWorker<Component>)(object)((Component)button).Slot).GetComponent<Image>((Predicate<Image>)null, false);
				if (component != null)
				{
					((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)component).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)button).Slot, ((Worker)((Component)button).Slot).World, selected ? 14f : 12f);
					((SyncField<NineSliceSizing>)(object)((ImageBase)component).NineSliceSizing).Value = (NineSliceSizing)0;
					((SyncField<colorX>)(object)component.Tint).Value = (selected ? SettingsAccent : SettingsPanelSoft);
				}
				ApplyButtonGradient(button, selected);
				if (((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Count > 0 && !selected)
				{
					ColorDriver obj = ((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[0];
					colorX val = (selected ? SettingsAccent : SettingsPanelSoft);
					obj.SetColors(ref val);
				}
				if (button.Label != null)
				{
					button.Label.Align = (Alignment)4;
					((SyncField<colorX>)(object)button.Label.Color).Value = SettingsText;
					((SyncField<float>)(object)button.Label.Size).Value = 17f;
				}
			}
		}

		private static void UpdateToggleButton(Button button, bool enabled)
		{
			//IL_001c: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (button != null)
			{
				Image component = ((ContainerWorker<Component>)(object)((Component)button).Slot).GetComponent<Image>((Predicate<Image>)null, false);
				colorX value = (enabled ? SettingsAccent : SettingsPanelSoft);
				if (component != null)
				{
					((SyncField<colorX>)(object)component.Tint).Value = value;
					ApplyButtonGradient(button, enabled);
				}
				if (((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Count > 0)
				{
					((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[0].SetColors(ref value);
				}
				if (button.Label != null)
				{
					((SyncField<string>)(object)button.Label.Content).Value = (enabled ? "On" : "Off");
					((SyncField<colorX>)(object)button.Label.Color).Value = (enabled ? SettingsText : SettingsSubtext);
					button.Label.Align = (Alignment)4;
				}
			}
		}

		private static void StyleTextFieldSlot(Slot slot, SettingsPanelState state)
		{
			//IL_002e: 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)
			if (slot != null && state != null)
			{
				Image component = ((ContainerWorker<Component>)(object)slot).GetComponent<Image>((Predicate<Image>)null, false);
				if (component != null)
				{
					((SyncField<colorX>)(object)component.Tint).Value = new colorX(0.18f, 0.19f, 0.23f, 0.96f, (ColorProfile)1);
					((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)component).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(slot, ((Worker)state.Canvas).World, 12f);
					((SyncField<NineSliceSizing>)(object)((ImageBase)component).NineSliceSizing).Value = (NineSliceSizing)0;
				}
				Text componentInChildren = slot.GetComponentInChildren<Text>((Predicate<Text>)null, false, false);
				if (componentInChildren != null)
				{
					((SyncField<colorX>)(object)componentInChildren.Color).Value = SettingsText;
					((SyncField<float>)(object)componentInChildren.Size).Value = 16f;
					componentInChildren.Align = (Alignment)3;
					((UIComponent)componentInChildren).RectTransform.AddFixedPadding(18f, 0f, 10f, 0f);
				}
			}
		}

		private static void AddIntField(UIBuilder ui, SettingsPanelState state, string label, int value, int min, int max, Action<int> changed)
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 8f, 12f, 8f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 160f;
			ui.Style.PreferredWidth = 160f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			IntTextEditorParser parser = ui.IntegerField(min, max, 1, false);
			TextEditor textEditor = ((TextEditorParser<int>)(object)parser).TextEditor;
			StyleTextFieldSlot((textEditor != null) ? ((Component)textEditor).Slot : null, state);
			((SyncField<int>)(object)((TextEditorParser<int>)(object)parser).ParsedValue).Value = value;
			((TextEditorParser<int>)(object)parser).TextEditor.LocalEditingFinished += delegate(TextEditor editor)
			{
				int num = default(int);
				if (int.TryParse(editor.TargetString, ref num))
				{
					changed?.Invoke(Math.Clamp(num, min, max));
				}
			};
			IText obj2 = ((TextEditorParser<int>)(object)parser).TextEditor?.Text.Target;
			AddCopyButton(ui, state, (IField<string>)(object)((Text)(((obj2 is Text) ? obj2 : null)?)).Content);
			AddPasteButton(ui, state, ((TextEditorParser<int>)(object)parser).TextEditor, delegate(string pasted)
			{
				int num = default(int);
				if (int.TryParse(pasted, ref num))
				{
					num = Math.Clamp(num, min, max);
					((SyncField<int>)(object)((TextEditorParser<int>)(object)parser).ParsedValue).Value = num;
					((TextEditorParser<int>)(object)parser).TextEditor.TargetString = num.ToString((IFormatProvider)(object)CultureInfo.InvariantCulture);
					changed?.Invoke(num);
				}
			});
			ui.NestOut();
		}

		private static void AddStringField(UIBuilder ui, SettingsPanelState state, string label, string value, Action<string> changed)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 8f, 12f, 8f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 160f;
			ui.Style.PreferredWidth = 160f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 16f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			TextField field = ui.TextField(value ?? "", false, (string)null, false, default(LocaleString));
			StyleTextFieldSlot(((Component)field).Slot, state);
			field.Editor.Target.LocalEditingFinished += delegate
			{
				changed?.Invoke(field.TargetString ?? "");
			};
			AddCopyButton(ui, state, (IField<string>)(object)field.Text?.Content);
			AddPasteButton(ui, state, field.Editor.Target, delegate(string pasted)
			{
				field.TargetString = pasted ?? "";
				changed?.Invoke(field.TargetString ?? "");
			});
			ui.NestOut();
		}

		private static void AddCopyButton(UIBuilder ui, SettingsPanelState state, IField<string> source)
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 42f;
			ui.Style.PreferredWidth = 42f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			ui.Style.FlexibleHeight = -1f;
			LocaleString val = LocaleString.op_Implicit("⧉");
			Button val2 = ui.Button(ref val);
			StyleSettingsButton(val2, selected: false);
			if (val2.Label != null)
			{
				((SyncField<float>)(object)val2.Label.Size).Value = 18f;
				((SyncField<colorX>)(object)val2.Label.Color).Value = SettingsText;
			}
			((ContainerWorker<Component>)(object)((Component)val2).Slot).AttachComponent<ButtonClipboardCopyText>(true, (Action<ButtonClipboardCopyText>)null).Source.Target = source;
		}

		private static void AddPasteButton(UIBuilder ui, SettingsPanelState state, TextEditor editor, Action<string> pasted)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_00da: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 42f;
			ui.Style.PreferredWidth = 42f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			ui.Style.FlexibleHeight = -1f;
			LocaleString val = LocaleString.op_Implicit("\ud83d\udccb");
			Button val2 = ui.Button(ref val);
			StyleSettingsButton(val2, selected: false);
			if (val2.Label != null)
			{
				((SyncField<float>)(object)val2.Label.Size).Value = 16f;
				((SyncField<colorX>)(object)val2.Label.Color).Value = SettingsText;
			}
			val2.LocalPressed += (ButtonEventHandler)delegate
			{
				try
				{
					SettingsPanelState settingsPanelState = state;
					object obj;
					if (settingsPanelState == null)
					{
						obj = null;
					}
					else
					{
						Slot ownerRoot = settingsPanelState.OwnerRoot;
						if (ownerRoot == null)
						{
							obj = null;
						}
						else
						{
							World world = ((Worker)ownerRoot).World;
							if (world == null)
							{
								obj = null;
							}
							else
							{
								InputInterface inputInterface = world.InputInterface;
								obj = ((inputInterface != null) ? inputInterface.Clipboard : null);
							}
						}
					}
					IClipboardInterface val3 = (IClipboardInterface)obj;
					if (val3 != null && val3.ContainsText)
					{
						string text = val3.GetText().Result ?? "";
						if (editor != null && !((ComponentBase<Component>)(object)editor).IsDestroyed)
						{
							editor.TargetString = text;
						}
						pasted?.Invoke(text);
					}
				}
				catch (global::System.Exception ex)
				{
					Msg("[Settings] Paste failed: " + ex.Message);
				}
			};
		}

		private static void AddCheckbox(UIBuilder ui, SettingsPanelState state, string label, bool initial, Action<bool> changed)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Expected O, but got Unknown
			ui.Style.MinHeight = 54f;
			ui.Style.PreferredHeight = 54f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			((SyncField<bool>)(object)((DirectionalLayout)ui.HorizontalLayout(12f, 8f, 10f, 8f, 14f, (Alignment?)(Alignment)4)).ForceExpandHeight).Value = true;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 17f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 74f;
			ui.Style.PreferredWidth = 74f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			val2 = LocaleString.op_Implicit(initial ? "On" : "Off");
			colorX? val3 = (initial ? SettingsAccentSoft : SettingsPanelSoft);
			Button toggle = ui.Button(ref val2, ref val3);
			StyleSettingsButton(toggle, initial);
			bool lastApplied = initial;
			UpdateToggleButton(toggle, lastApplied);
			toggle.LocalPressed += (ButtonEventHandler)delegate
			{
				lastApplied = !lastApplied;
				UpdateToggleButton(toggle, lastApplied);
				changed?.Invoke(lastApplied);
			};
			ui.NestOut();
		}

		private static void AddCheckboxWithBadge(UIBuilder ui, SettingsPanelState state, string label, string badge, colorX badgeColor, bool initial, Action<bool> changed)
		{
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Expected O, but got Unknown
			ui.Style.MinHeight = 54f;
			ui.Style.PreferredHeight = 54f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)state.Canvas).World, 13f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			((SyncField<bool>)(object)((DirectionalLayout)ui.HorizontalLayout(12f, 8f, 10f, 8f, 14f, (Alignment?)(Alignment)4)).ForceExpandHeight).Value = true;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			LocaleString val2 = LocaleString.op_Implicit(label);
			Text obj = ui.Text(ref val2, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 17f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 146f;
			ui.Style.PreferredWidth = 146f;
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			Image val3 = ui.Image(ref badgeColor, false);
			StyleBadgePill(val3, badgeColor);
			ui.NestInto(((UIComponent)val3).RectTransform);
			ui.LayoutTarget = ((Component)val3).Slot;
			HorizontalLayout obj2 = ui.HorizontalLayout(0f, 0f, (Alignment?)(Alignment)4);
			((SyncField<bool>)(object)((DirectionalLayout)obj2).ForceExpandWidth).Value = true;
			((SyncField<bool>)(object)((DirectionalLayout)obj2).ForceExpandHeight).Value = true;
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			ui.Style.FlexibleWidth = 1f;
			val2 = LocaleString.op_Implicit(badge);
			Text obj3 = ui.Text(ref val2, true, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)obj3.Size).Value = 14f;
			((SyncField<colorX>)(object)obj3.Color).Value = SettingsText;
			ui.NestOut();
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 74f;
			ui.Style.PreferredWidth = 74f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			val2 = LocaleString.op_Implicit(initial ? "On" : "Off");
			colorX? val4 = (initial ? SettingsAccentSoft : SettingsPanelSoft);
			Button toggle = ui.Button(ref val2, ref val4);
			StyleSettingsButton(toggle, initial);
			bool lastApplied = initial;
			UpdateToggleButton(toggle, lastApplied);
			toggle.LocalPressed += (ButtonEventHandler)delegate
			{
				lastApplied = !lastApplied;
				UpdateToggleButton(toggle, lastApplied);
				changed?.Invoke(lastApplied);
			};
			ui.NestOut();
		}

		private static void AddViewerRow(UIBuilder ui, SettingsPanelState state, DesktopSession session, User user)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: 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_0259: 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_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0518: Unknown result type (might be due to invalid IL or missing references)
			//IL_051d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0521: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Expected O, but got Unknown
			EnsureViewerStreamOverride(session, user);
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			colorX val = new colorX(0.105f, 0.112f, 0.13f, 0.92f, (ColorProfile)1);
			Image val2 = ui.Image(ref val, false);
			SpriteProvider target = CreateRoundedSprite(((Component)val2).Slot, ((Worker)state.Canvas).World, 14f);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)target;
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val2).RectTransform);
			ui.LayoutTarget = ((Component)val2).Slot;
			ui.HorizontalLayout(10f, 8f, 10f, 8f, 10f, (Alignment?)(Alignment)3);
			ui.Style.MinWidth = 42f;
			ui.Style.PreferredWidth = 42f;
			ui.Style.MinHeight = 42f;
			ui.Style.PreferredHeight = 42f;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.FlexibleHeight = -1f;
			Slot val3 = ui.Empty("Avatar");
			UIBuilder val4 = new UIBuilder(val3, (Slot)null);
			val4.Style.MinWidth = 42f;
			val4.Style.PreferredWidth = 42f;
			val4.Style.MinHeight = 42f;
			val4.Style.PreferredHeight = 42f;
			SpriteProvider val5 = CreateRoundedSprite(val3, ((Worker)state.Canvas).World, 10f);
			Image val6 = default(Image);
			val4.SpriteMask((IAssetProvider<Sprite>)(object)val5, true, ref val6);
			((SyncField<colorX>)(object)val6.Tint).Value = new colorX(0.16f, 0.17f, 0.2f, 1f, (ColorProfile)1);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val6).NineSliceSizing).Value = (NineSliceSizing)0;
			val4.Nest();
			StaticTexture2D val7 = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)val3).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
			((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)val7).URL).Value = DefaultViewerAvatar;
			User obj = user;
			if (!string.IsNullOrWhiteSpace((obj != null) ? obj.UserID : null))
			{
				LoadViewerAvatarIcon(val3, val7, user.UserID);
			}
			((SyncField<colorX>)(object)val4.RawImage((IAssetProvider<ITexture2D>)(object)val7, true).Tint).Value = colorX.White;
			val4.NestOut();
			ui.Style.MinWidth = 0f;
			ui.Style.PreferredWidth = 0f;
			ui.Style.MinHeight = 42f;
			ui.Style.PreferredHeight = 42f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			User obj2 = user;
			LocaleString val8 = LocaleString.op_Implicit(((obj2 != null) ? obj2.UserName : null) ?? "");
			Text obj3 = ui.Text(ref val8, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj3.Size).Value = 19f;
			((SyncField<colorX>)(object)obj3.Color).Value = new colorX(0.91f, 0.92f, 0.95f, 1f, (ColorProfile)1);
			ui.Style.MinWidth = 86f;
			ui.Style.PreferredWidth = 86f;
			ui.Style.MinHeight = 28f;
			ui.Style.PreferredHeight = 28f;
			ui.Style.FlexibleWidth = -1f;
			string viewerCullingBadgeText = GetViewerCullingBadgeText(session, user);
			colorX viewerCullingBadgeColor = GetViewerCullingBadgeColor(session, user);
			Image statusBadge = ui.Image(ref viewerCullingBadgeColor, false);
			StyleBadgePill(statusBadge, viewerCullingBadgeColor);
			ui.NestInto(((UIComponent)statusBadge).RectTransform);
			ui.LayoutTarget = ((Component)statusBadge).Slot;
			ui.HorizontalLayout(0f, 0f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 28f;
			ui.Style.PreferredHeight = 28f;
			val8 = LocaleString.op_Implicit(viewerCullingBadgeText);
			Text statusLabel = ui.Text(ref val8, true, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)statusLabel.Size).Value = 12f;
			((SyncField<colorX>)(object)statusLabel.Color).Value = SettingsText;
			ui.NestOut();
			ui.Style.MinWidth = 58f;
			ui.Style.PreferredWidth = 58f;
			ui.Style.MinHeight = 34f;
			ui.Style.PreferredHeight = 34f;
			ui.Style.FlexibleWidth = -1f;
			bool isOwner = IsOwnerViewer(session, user);
			bool viewerEnabled = !isOwner && IsViewerStreamEnabled(session, user);
			val8 = LocaleString.op_Implicit("On");
			colorX? val9 = SettingsAccentSoft;
			Button toggle = ui.Button(ref val8, ref val9);
			StyleSettingsButton(toggle, selected: true);
			UpdateToggleButton(toggle, viewerEnabled);
			toggle.LocalPressed += (ButtonEventHandler)delegate
			{
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				if (isOwner)
				{
					UpdateToggleButton(toggle, enabled: false);
				}
				else
				{
					viewerEnabled = !viewerEnabled;
					SetViewerStreamEnabled(session, user, viewerEnabled);
					UpdateToggleButton(toggle, viewerEnabled);
					((SyncField<string>)(object)statusLabel.Content).Value = GetViewerCullingBadgeText(session, user);
					StyleBadgePill(statusBadge, GetViewerCullingBadgeColor(session, user));
				}
			};
			ui.NestOut();
		}

		private static void LoadViewerAvatarIcon(Slot avatarRoot, StaticTexture2D avatarTex, string userId)
		{
			<>c__DisplayClass449_0 CS$<>8__locals15 = new <>c__DisplayClass449_0();
			CS$<>8__locals15.userId = userId;
			CS$<>8__locals15.avatarRoot = avatarRoot;
			CS$<>8__locals15.avatarTex = avatarTex;
			if (CS$<>8__locals15.avatarRoot == null || ((ContainerWorker<Component>)(object)CS$<>8__locals15.avatarRoot).IsDestroyed || CS$<>8__locals15.avatarTex == null || ((ComponentBase<Component>)(object)CS$<>8__locals15.avatarTex).IsDestroyed || string.IsNullOrWhiteSpace(CS$<>8__locals15.userId))
			{
				return;
			}
			CS$<>8__locals15.world = ((Worker)CS$<>8__locals15.avatarRoot).World;
			World obj = CS$<>8__locals15.world;
			CS$<>8__locals15.engine = ((obj != null) ? obj.Engine : null);
			if (CS$<>8__locals15.world == null)
			{
				return;
			}
			Engine obj2 = CS$<>8__locals15.engine;
			object obj3;
			if (obj2 == null)
			{
				obj3 = null;
			}
			else
			{
				EngineSkyFrostInterface cloud = obj2.Cloud;
				obj3 = ((cloud != null) ? ((SkyFrostInterface)cloud).Users : null);
			}
			if (obj3 != null)
			{
				global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass449_0.<<LoadViewerAvatarIcon>b__0>d))] () =>
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass449_0.<<LoadViewerAvatarIcon>b__0>d <<LoadViewerAvatarIcon>b__0>d = default(<>c__DisplayClass449_0.<<LoadViewerAvatarIcon>b__0>d);
					<<LoadViewerAvatarIcon>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
					<<LoadViewerAvatarIcon>b__0>d.<>4__this = CS$<>8__locals15;
					<<LoadViewerAvatarIcon>b__0>d.<>1__state = -1;
					((AsyncTaskMethodBuilder)(ref <<LoadViewerAvatarIcon>b__0>d.<>t__builder)).Start<<>c__DisplayClass449_0.<<LoadViewerAvatarIcon>b__0>d>(ref <<LoadViewerAvatarIcon>b__0>d);
					return ((AsyncTaskMethodBuilder)(ref <<LoadViewerAvatarIcon>b__0>d.<>t__builder)).Task;
				}));
			}
		}

		private static void BuildViewersTab(UIBuilder ui, SettingsPanelState state, DesktopSession session)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			AddSectionHeader(ui, "Viewers");
			List<User> val = Enumerable.ToList<User>((global::System.Collections.Generic.IEnumerable<User>)Enumerable.OrderBy<User, string>(Enumerable.Where<User>((global::System.Collections.Generic.IEnumerable<User>)((Worker)state.OwnerRoot).World.AllUsers, (Func<User, bool>)((User u) => u.IsPresentInWorld)), (Func<User, string>)((User u) => u.UserName)));
			state.ViewerListSignature = GetViewerListSignature(val, session);
			if (val.Count == 0)
			{
				AddBodyText(ui, "No present users found.");
			}
			else
			{
				float minHeight = Math.Clamp((float)val.Count * 68f + 20f, 96f, 260f);
				ScrollRect scroll;
				UIBuilder ui2 = BeginRoundedScroll(ui, state, "ViewerListScroll", minHeight, (Alignment)0, out scroll);
				Enumerator<User> enumerator = val.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						User current = enumerator.Current;
						AddViewerRow(ui2, state, session, current);
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
			}
			ScheduleViewerListRefresh(state, session);
			AddSectionHeader(ui, "Culling");
			AddOptionRow(ui, state, "Mode", NormalizeViewerCullingMode(Config?.GetValue(ViewerCullingMode)), new ValueTuple<string, string>[2]
			{
				new ValueTuple<string, string>("frustum", "Frustum"),
				new ValueTuple<string, string>("distance", "Distance")
			}, delegate(string value)
			{
				state.ViewerCullingMode = NormalizeViewerCullingMode(value);
				SaveConfigValue(ViewerCullingMode, value);
				RebuildSettingsPanel(state, session);
			});
			Action val2 = default(Action);
			AddCheckbox(ui, state, "Preview culling guide", Config?.GetValue(ViewerCullingPreview) ?? false, delegate(bool value)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_0066: Expected O, but got Unknown
				state.ViewerCullingPreviewEnabled = value;
				SaveConfigValue(ViewerCullingPreview, value);
				UpdateCullingPreview(session, state);
				DesktopSession desktopSession = session;
				if (desktopSession != null)
				{
					Slot root = desktopSession.Root;
					if (root != null)
					{
						World world = ((Worker)root).World;
						if (world != null)
						{
							Action obj = val2;
							if (obj == null)
							{
								Action val3 = delegate
								{
									UpdateCullingPreview(session, state);
								};
								Action val4 = val3;
								val2 = val3;
								obj = val4;
							}
							world.RunInUpdates(1, obj);
						}
					}
				}
			});
			AddFloatSlider(ui, state, "Range", state.ViewerDistance, 1f, 10f, delegate(float value)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Expected O, but got Unknown
				//IL_007d: Expected O, but got Unknown
				state.ViewerDistance = value;
				state.ViewerFrustumDepth = value;
				SaveConfigValue(ViewerDistance, value);
				SaveConfigValue(ViewerFrustumDepth, value);
				UpdateCullingPreview(session, state);
				DesktopSession desktopSession = session;
				if (desktopSession != null)
				{
					Slot root = desktopSession.Root;
					if (root != null)
					{
						World world = ((Worker)root).World;
						if (world != null)
						{
							Action obj = val2;
							if (obj == null)
							{
								Action val3 = delegate
								{
									UpdateCullingPreview(session, state);
								};
								Action val4 = val3;
								val2 = val3;
								obj = val4;
							}
							world.RunInUpdates(1, obj);
						}
					}
				}
			});
			if (!(state.ViewerCullingMode != "distance"))
			{
				return;
			}
			AddFloatSlider(ui, state, "Frustum angle", state.ViewerFrustumAngle, 30f, 170f, delegate(float value)
			{
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_0066: Expected O, but got Unknown
				state.ViewerFrustumAngle = value;
				SaveConfigValue(ViewerFrustumWidth, value);
				UpdateCullingPreview(session, state);
				DesktopSession desktopSession = session;
				if (desktopSession != null)
				{
					Slot root = desktopSession.Root;
					if (root != null)
					{
						World world = ((Worker)root).World;
						if (world != null)
						{
							Action obj = val2;
							if (obj == null)
							{
								Action val3 = delegate
								{
									UpdateCullingPreview(session, state);
								};
								Action val4 = val3;
								val2 = val3;
								obj = val4;
							}
							world.RunInUpdates(1, obj);
						}
					}
				}
			});
		}

		private static void RequestStreamEncoderRestart(DesktopSession session, string reason)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<DesktopSession> val = Enumerable.ToList<DesktopSession>(Enumerable.Distinct<DesktopSession>(Enumerable.Select<IGrouping<int, DesktopSession>, DesktopSession>(Enumerable.GroupBy<DesktopSession, int>((global::System.Collections.Generic.IEnumerable<DesktopSession>)Enumerable.ToList<DesktopSession>(Enumerable.Where<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)ActiveSessions, (Func<DesktopSession, bool>)delegate(DesktopSession s)
				{
					if (s != null && !s.Cleaned && s.StreamId > 0)
					{
						if (session != null && s != session)
						{
							Slot root2 = s.Root;
							World obj2 = ((root2 != null) ? ((Worker)root2).World : null);
							Slot root3 = session.Root;
							return obj2 == ((root3 != null) ? ((Worker)root3).World : null);
						}
						return true;
					}
					return false;
				})), (Func<DesktopSession, int>)((DesktopSession s) => s.StreamId)), (Func<IGrouping<int, DesktopSession>, DesktopSession>)delegate(IGrouping<int, DesktopSession> group)
				{
					global::System.Collections.Generic.IEnumerator<DesktopSession> enumerator2 = ((global::System.Collections.Generic.IEnumerable<DesktopSession>)group).GetEnumerator();
					try
					{
						while (((global::System.Collections.IEnumerator)enumerator2).MoveNext())
						{
							DesktopSession current2 = enumerator2.Current;
							DesktopSession sharedStreamDriver = GetSharedStreamDriver(current2.Hwnd, current2.StreamId);
							if (sharedStreamDriver != null && Enumerable.Contains<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group, sharedStreamDriver))
							{
								return sharedStreamDriver;
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator2)?.Dispose();
					}
					return Enumerable.FirstOrDefault<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group, (Func<DesktopSession, bool>)((DesktopSession s) => s.Streamer != null)) ?? Enumerable.First<DesktopSession>((global::System.Collections.Generic.IEnumerable<DesktopSession>)group);
				})));
				Enumerator<DesktopSession> enumerator = val.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						DesktopSession current = enumerator.Current;
						int pendingResizeW = Math.Max(1, current.LastKnownW);
						int pendingResizeH = Math.Max(1, current.LastKnownH);
						current.PendingResizeW = pendingResizeW;
						current.PendingResizeH = pendingResizeH;
						Slot root = current.Root;
						double? obj;
						if (root == null)
						{
							obj = null;
						}
						else
						{
							World world = ((Worker)root).World;
							obj = ((world != null) ? new double?(world.Time.WorldTime) : ((double?)null)) + 0.05;
						}
						current.ResizeDebounceUntil = obj ?? 0.05;
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (val.Count > 0)
				{
					Msg($"[Settings] Scheduled stream encoder refresh ({reason}) for {val.Count} session(s)");
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[Settings] Failed to schedule stream encoder refresh: " + ex.Message);
			}
		}

		private static string ViewerKey(User user)
		{
			if (!string.IsNullOrWhiteSpace((user != null) ? user.UserID : null))
			{
				return user.UserID;
			}
			return ((user != null) ? user.UserName : null) ?? "";
		}

		private static bool IsOwnerViewer(DesktopSession session, User user)
		{
			string text = session?.OwnerUserId;
			if (!string.IsNullOrWhiteSpace(text))
			{
				return string.Equals(text, (user != null) ? user.UserID : null, (StringComparison)5);
			}
			return false;
		}

		private static bool IsViewerStreamEnabled(DesktopSession session, User user)
		{
			if (session == null || user == null || IsOwnerViewer(session, user))
			{
				return false;
			}
			string text = ViewerKey(user);
			if (string.IsNullOrWhiteSpace(text))
			{
				return true;
			}
			bool flag = default(bool);
			return !session.ViewerStreamEnabledByUserId.TryGetValue(text, ref flag) || flag;
		}

		private static void SetViewerStreamEnabled(DesktopSession session, User user, bool enabled)
		{
			if (session != null && user != null)
			{
				if (IsOwnerViewer(session, user))
				{
					enabled = false;
				}
				string text = ViewerKey(user);
				if (!string.IsNullOrWhiteSpace(text))
				{
					session.ViewerStreamEnabledByUserId[text] = enabled;
				}
				if (session.ViewerStreamAllowed != null && !((ComponentBase<Component>)(object)session.ViewerStreamAllowed).IsDestroyed)
				{
					((ValueOverrideBase<bool>)(object)session.ViewerStreamAllowed).SetOverride(user, enabled);
				}
			}
		}

		private static void EnsureViewerStreamOverride(DesktopSession session, User user)
		{
			if (session?.ViewerStreamAllowed != null && !((ComponentBase<Component>)(object)session.ViewerStreamAllowed).IsDestroyed && user != null)
			{
				if (IsOwnerViewer(session, user))
				{
					((ValueOverrideBase<bool>)(object)session.ViewerStreamAllowed).SetOverride(user, false);
				}
				else
				{
					((ValueOverrideBase<bool>)(object)session.ViewerStreamAllowed).SetOverride(user, IsViewerStreamEnabled(session, user));
				}
			}
		}

		private static string GetViewerCullingBadgeText(DesktopSession session, User user)
		{
			if (IsOwnerViewer(session, user))
			{
				return "Owner";
			}
			if (!IsViewerStreamEnabled(session, user))
			{
				return "Off";
			}
			if (!IsViewerInConfiguredRange(session, user))
			{
				return "Out";
			}
			return "In range";
		}

		private static colorX GetViewerCullingBadgeColor(DesktopSession session, User user)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (IsOwnerViewer(session, user))
			{
				return SettingsStatusNeutral;
			}
			if (!IsViewerStreamEnabled(session, user))
			{
				return SettingsStatusBad;
			}
			if (!IsViewerInConfiguredRange(session, user))
			{
				return SettingsStatusWarn;
			}
			return SettingsStatusGood;
		}

		private static bool IsViewerInConfiguredRange(DesktopSession session, User user)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (session?.Root == null || ((ContainerWorker<Component>)(object)session.Root).IsDestroyed || ((user != null) ? user.Root : null) == null)
				{
					return false;
				}
				Slot root = session.Root;
				float3 headPosition = user.Root.HeadPosition;
				float3 val = root.GlobalPointToLocal(ref headPosition);
				string text = NormalizeViewerCullingMode(Config?.GetValue(ViewerCullingMode));
				float num = Math.Clamp(Config?.GetValue(ViewerDistance) ?? Config?.GetValue(ViewerFrustumDepth) ?? 3f, 1f, 10f);
				float cullingPreviewOriginZ = GetCullingPreviewOriginZ(session);
				if (text == "distance")
				{
					headPosition = new float3(0f, 0f, cullingPreviewOriginZ);
					return MathX.Distance(ref val, ref headPosition) <= num;
				}
				int num2 = ((session.LastKnownW > 0) ? session.LastKnownW : MathX.RoundToInt(((SyncField<float2>)(object)session.Canvas?.Size).Value.x ?? 0f));
				int num3 = ((session.LastKnownH > 0) ? session.LastKnownH : MathX.RoundToInt(((SyncField<float2>)(object)session.Canvas?.Size).Value.y ?? 0f));
				float num4 = ((session.PanelCanvasScale > 0f) ? session.PanelCanvasScale : 0.0005f);
				if (num2 <= 0 || num3 <= 0)
				{
					return false;
				}
				float num5 = (float)num2 * num4 * 0.5f;
				float num6 = (float)num3 * num4 * 0.5f;
				float num7 = cullingPreviewOriginZ - val.z;
				if (num7 < 0f || num7 > num)
				{
					return false;
				}
				float num8 = NormalizeViewerFrustumAngle(Config?.GetValue(ViewerFrustumWidth) ?? 120f);
				float num9 = num8 * 0.5f;
				float num10 = num5 + MathF.Tan(num8 * (float)Math.PI / 360f) * num7;
				float num11 = num6 + MathF.Tan(num9 * (float)Math.PI / 360f) * num7;
				return MathF.Abs(val.x) <= num10 && MathF.Abs(val.y) <= num11;
			}
			catch
			{
				return false;
			}
		}

		private static string GetViewerListSignature(List<User> users, DesktopSession session)
		{
			if (users == null || users.Count == 0)
			{
				return "";
			}
			return string.Join("|", Enumerable.Select<User, string>((global::System.Collections.Generic.IEnumerable<User>)users, (Func<User, string>)((User user) => $"{user.UserID}:{user.UserName}:{user.IsPresentInWorld}:{GetViewerCullingBadgeText(session, user)}")));
		}

		private static void ScheduleViewerListRefresh(SettingsPanelState state, DesktopSession session)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			SettingsPanelState settingsPanelState = state;
			object obj;
			if (settingsPanelState == null)
			{
				obj = null;
			}
			else
			{
				Slot ownerRoot = settingsPanelState.OwnerRoot;
				obj = ((ownerRoot != null) ? ((Worker)ownerRoot).World : null);
			}
			if (obj == null)
			{
				return;
			}
			int generation = ++state.ViewerListRefreshGeneration;
			((Worker)state.OwnerRoot).World.RunInUpdates(300, (Action)delegate
			{
				if (state.SurfaceSlot != null && !((ContainerWorker<Component>)(object)state.SurfaceSlot).IsDestroyed && state.SurfaceSlot.ActiveSelf && state.ActiveTab == SettingsPanelTab.Viewers && state.ViewerListRefreshGeneration == generation)
				{
					if (!string.Equals(GetViewerListSignature(Enumerable.ToList<User>((global::System.Collections.Generic.IEnumerable<User>)Enumerable.OrderBy<User, string>(Enumerable.Where<User>((global::System.Collections.Generic.IEnumerable<User>)((Worker)state.OwnerRoot).World.AllUsers, (Func<User, bool>)((User u) => u.IsPresentInWorld)), (Func<User, string>)((User u) => u.UserName))), session), state.ViewerListSignature, (StringComparison)4))
					{
						RebuildSettingsPanel(state, session);
					}
					else
					{
						ScheduleViewerListRefresh(state, session);
					}
				}
			});
		}

		internal static bool ShowSetupNoticeFromDesktopClick(World world)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				EnsureDependencyRuntimeStarted();
				return false;
			}
			if (_setupNoticeDismissed)
			{
				EnsureDependencyRuntimeStarted();
				return false;
			}
			if (_setupInstallInProgress)
			{
				if (_setupPanelRoot == null || ((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
				{
					ShowSetupPanel(world, DesktopBuddyFirstRunSetup.Check());
				}
				return true;
			}
			if (_setupCompleteAwaitingClose)
			{
				if (_setupPanelRoot == null || ((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
				{
					ShowSetupPanel(world, DesktopBuddyFirstRunSetup.Check());
				}
				return true;
			}
			DesktopBuddyFirstRunSetup.SetupState setupState = DesktopBuddyFirstRunSetup.Check();
			if (!setupState.HasIssues)
			{
				EnsureDependencyRuntimeStarted();
				return false;
			}
			return ShowSetupPanel(world, setupState);
		}

		private static World GetSetupPanelWorld()
		{
			try
			{
				World userspaceWorld = Userspace.UserspaceWorld;
				object obj;
				if (userspaceWorld == null)
				{
					obj = null;
				}
				else
				{
					Engine engine = userspaceWorld.Engine;
					if (engine == null)
					{
						obj = null;
					}
					else
					{
						WorldManager worldManager = engine.WorldManager;
						obj = ((worldManager != null) ? worldManager.FocusedWorld : null);
					}
				}
				World val = (World)obj;
				if (val != null && !val.IsDestroyed && val != Userspace.UserspaceWorld)
				{
					return val;
				}
			}
			catch
			{
			}
			return null;
		}

		private static bool ShowSetupPanel(World world, DesktopBuddyFirstRunSetup.SetupState state)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: 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)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			if (world == null || world.IsDestroyed)
			{
				return false;
			}
			if (_setupPanelRoot != null && !((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
			{
				return true;
			}
			User localUser = world.LocalUser;
			object obj;
			if (localUser == null)
			{
				obj = null;
			}
			else
			{
				UserRoot root = localUser.Root;
				obj = ((root != null) ? ((Component)root).Slot : null);
			}
			if (obj == null)
			{
				Msg("[SetupPanel] Local user root is not available yet");
				return false;
			}
			Slot slot = ((Component)localUser.Root).Slot;
			_setupPanelRoot = (((slot != null) ? slot.Parent : null) ?? world.RootSlot).AddSlot("DesktopBuddy Setup", false);
			_setupPanelRoot.PersistentSelf = false;
			_setupPanelRoot.Destroyed += delegate
			{
				bool num = _setupCompleteAwaitingClose && !_setupNoticeDismissed;
				if (_setupPanelRoot != null && ((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
				{
					_setupPanelRoot = null;
				}
				_setupPanelCanvas = null;
				_setupBodyText = null;
				_setupInstallButtonSlot = null;
				_setupStatusRows.Clear();
				if (num)
				{
					Msg("[SetupPanel] Setup panel closed after completion; continuing DesktopBuddy initialization");
					_setupNoticeDismissed = true;
					_setupCompleteAwaitingClose = false;
					EnsureDependencyRuntimeStarted();
				}
			};
			((ContainerWorker<Component>)(object)_setupPanelRoot).AttachComponent<DestroyOnUserLeave>(true, (Action<DestroyOnUserLeave>)null).TargetUser.Target = localUser;
			float3 headPosition = localUser.Root.HeadPosition;
			floatQ headRotation = localUser.Root.HeadRotation;
			float3 forward = float3.Forward;
			float3 val = (ref headRotation) * (ref forward);
			Slot setupPanelRoot = _setupPanelRoot;
			forward = (ref val) * 1.05f;
			setupPanelRoot.GlobalPosition = (ref headPosition) + (ref forward);
			Slot setupPanelRoot2 = _setupPanelRoot;
			forward = float3.Up;
			setupPanelRoot2.GlobalRotation = floatQ.LookRotation(ref val, ref forward);
			_setupPanelRoot.LocalScale = float3.One;
			ConfigureSetupGrabbableRoot(_setupPanelRoot);
			CreateSetupRenderSurface(_setupPanelRoot);
			BuildSetupPanel(state);
			Msg("[SetupPanel] Showing grabbable curved setup panel");
			return true;
		}

		private static void ConfigureSetupGrabbableRoot(Slot root)
		{
			((SyncField<bool>)(object)((ContainerWorker<Component>)(object)root).AttachComponent<Grabbable>(true, (Action<Grabbable>)null).Scalable).Value = true;
		}

		private static void CreateSetupRenderSurface(Slot root)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			Slot obj = root.AddLocalSlot("DesktopBuddySetupRenderHost", false);
			obj.PersistentSelf = false;
			((ContainerWorker<Component>)(object)obj).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Slot val = obj.AddLocalSlot("SetupRender", false);
			val.PersistentSelf = false;
			((ContainerWorker<Component>)(object)val).AttachComponent<HiddenLayer>(true, (Action<HiddenLayer>)null);
			Slot obj2 = obj.AddLocalSlot("SetupCamera", false);
			obj2.PersistentSelf = false;
			obj2.LocalPosition = new float3(0f, 0f, -1f);
			RenderTextureProvider val2 = ((ContainerWorker<Component>)(object)obj2).AttachComponent<RenderTextureProvider>(true, (Action<RenderTextureProvider>)null);
			((SyncField<int2>)(object)val2.Size).Value = new int2(920, 600);
			((SyncField<TextureWrapMode>)(object)val2.WrapModeU).Value = (TextureWrapMode)1;
			((SyncField<TextureWrapMode>)(object)val2.WrapModeV).Value = (TextureWrapMode)1;
			Camera val3 = ((ContainerWorker<Component>)(object)obj2).AttachComponent<Camera>(true, (Action<Camera>)null);
			((SyncField<CameraProjection>)(object)val3.Projection).Value = (CameraProjection)1;
			((SyncField<float>)(object)val3.OrthographicSize).Value = 300f;
			((SyncField<bool>)(object)val3.UseTransformScale).Value = true;
			((SyncField<CameraClearMode>)(object)val3.Clear).Value = (CameraClearMode)1;
			((SyncField<colorX>)(object)val3.ClearColor).Value = colorX.Clear;
			((SyncField<float>)(object)val3.NearClipping).Value = 0.01f;
			((SyncField<float>)(object)val3.FarClipping).Value = 4f;
			((SyncField<bool>)(object)val3.Postprocessing).Value = false;
			((SyncField<bool>)(object)val3.RenderShadows).Value = false;
			((SyncField<bool>)(object)val3.ForwardOnly).Value = true;
			((SyncRef<IAssetProvider<RenderTexture>>)(object)val3.RenderTexture).Target = (IAssetProvider<RenderTexture>)(object)val2;
			val3.SelectiveRender.Add(val);
			Slot obj3 = val.AddLocalSlot("SetupCanvas", false);
			obj3.PersistentSelf = false;
			_setupPanelCanvas = ((ContainerWorker<Component>)(object)obj3).AttachComponent<Canvas>(true, (Action<Canvas>)null);
			((SyncField<float2>)(object)_setupPanelCanvas.Size).Value = new float2(920f, 600f);
			((Collider)_setupPanelCanvas.Collider.Target).SetTrigger();
			RefID setupCanvasId = ((Worker)_setupPanelCanvas).ReferenceID;
			DesktopCanvasIds.Add(setupCanvasId);
			((ComponentBase<Component>)(object)_setupPanelCanvas).Destroyed += delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				DesktopCanvasIds.Remove(setupCanvasId);
			};
			CurvedPlaneMesh val4 = AddSetupCurvedRenderPlane(root, "SetupCurvedMesh", 920, 600f, 0.00055f, 0f, -0.018f, (IAssetProvider<ITexture2D>)(object)val2, val3);
			AddCurvedMeshBackdropBlur(((Component)val4).Slot, val4, 64, 0.012f);
			RegisterTopBarRaycastPortal(((Component)val4).Slot, val);
		}

		private static CurvedPlaneMesh AddSetupCurvedRenderPlane(Slot parent, string name, int width, float height, float scale, float yOffset, float zOffset, IAssetProvider<ITexture2D> texture, Camera rayExit)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Slot val = parent.AddLocalSlot(name, false);
			val.PersistentSelf = false;
			val.LocalPosition = new float3(0f, yOffset, zOffset);
			float3 one = float3.One;
			val.LocalScale = (ref one) * scale;
			MeshRenderer val2 = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshRenderer>(true, (Action<MeshRenderer>)null);
			CurvedPlaneMesh val3 = ((ContainerWorker<Component>)(object)val).AttachComponent<CurvedPlaneMesh>(true, (Action<CurvedPlaneMesh>)null);
			((SyncField<float2>)(object)val3.Size).Value = new float2((float)width, height);
			((SyncField<float>)(object)val3.Curvature).Value = 0.18f;
			((SyncField<CurvatureAspectRatioCompensation>)(object)val3.AspectRatioCompensation).Value = (CurvatureAspectRatioCompensation)2;
			((SyncField<int>)(object)val3.Segments).Value = 48;
			((SyncRef<IAssetProvider<Mesh>>)(object)val2.Mesh).Target = (IAssetProvider<Mesh>)(object)val3;
			MeshCollider obj = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshCollider>(true, (Action<MeshCollider>)null);
			((SyncRef<IAssetProvider<Mesh>>)(object)((MeshBasedCollider<Mesh, MeshColliderData>)(object)obj).Mesh).Target = (IAssetProvider<Mesh>)(object)val3;
			((SyncField<MeshColliderSidedness>)(object)obj.Sidedness).Value = (MeshColliderSidedness)0;
			if (rayExit != null)
			{
				MeshUVRaycastPortal obj2 = ((ContainerWorker<Component>)(object)val).AttachComponent<MeshUVRaycastPortal>(true, (Action<MeshUVRaycastPortal>)null);
				obj2.RayExit.Target = (IUVToRayConverter)(object)rayExit;
				((SyncField<bool?>)(object)obj2.OverrideHitTriggers).Value = true;
				((SyncField<bool>)(object)obj2.RepeatUV).Value = false;
			}
			UnlitMaterial val4 = ((ContainerWorker<Component>)(object)val).AttachComponent<UnlitMaterial>(true, (Action<UnlitMaterial>)null);
			((SyncRef<IAssetProvider<ITexture2D>>)(object)val4.Texture).Target = texture;
			((SyncField<BlendMode>)(object)val4.BlendMode).Value = (BlendMode)2;
			((SyncField<float>)(object)val4.AlphaCutoff).Value = 0.01f;
			((SyncField<Sidedness>)(object)val4.Sidedness).Value = (Sidedness)1;
			((SyncField<ZWrite>)(object)val4.ZWrite).Value = (ZWrite)1;
			((SyncField<float>)(object)val4.OffsetUnits).Value = 80f;
			((SyncField<int>)(object)val4.RenderQueue).Value = 3004;
			val2.Materials.Add((IAssetProvider<Material>)(object)val4);
			return val3;
		}

		private static void BuildSetupPanel(DesktopBuddyFirstRunSetup.SetupState state)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			if (_setupPanelCanvas == null || ((ComponentBase<Component>)(object)_setupPanelCanvas).IsDestroyed)
			{
				return;
			}
			_setupBodyText = null;
			_setupInstallButtonSlot = null;
			_setupStatusRows.Clear();
			((Component)_setupPanelCanvas).Slot.DestroyChildren(false, true, false, (Predicate<Slot>)null);
			UIBuilder val = new UIBuilder(_setupPanelCanvas);
			ConfigureSetupCanvasStyle(val);
			Image val2 = val.Image(ref SettingsBg, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val2).Slot, ((Worker)val.Root).World, 22f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			val.NestInto(((UIComponent)val2).RectTransform);
			val.LayoutTarget = ((Component)val2).Slot;
			val.VerticalLayout(10f, 20f, 24f, 20f, 24f, (Alignment?)(Alignment)0, (bool?)null, (bool?)null);
			AddSetupHeader(val);
			AddSetupBodyText(val, GetSetupPanelMessage(state));
			global::System.Collections.Generic.IEnumerator<DesktopBuddyFirstRunSetup.SetupItem> enumerator = ((global::System.Collections.Generic.IEnumerable<DesktopBuddyFirstRunSetup.SetupItem>)state.Items).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					DesktopBuddyFirstRunSetup.SetupItem current = enumerator.Current;
					AddSetupStatusRow(val, current);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			val.Style.FlexibleHeight = 1f;
			val.Empty("Spacer");
			AddSetupActions(val, state);
			val.NestOut();
		}

		private static void ConfigureSetupCanvasStyle(UIBuilder ui)
		{
			ui.Style.MinWidth = 920f;
			ui.Style.PreferredWidth = 920f;
			ui.Style.MinHeight = 600f;
			ui.Style.PreferredHeight = 600f;
			ui.Style.FlexibleWidth = 0f;
			ui.Style.FlexibleHeight = 0f;
		}

		private static void AddSetupHeader(UIBuilder ui)
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			Slot val = ui.Empty("Header");
			ui.NestInto(val);
			ui.LayoutTarget = val;
			ui.HorizontalLayout(12f, 0f, (Alignment?)(Alignment)3);
			ui.Style.MinWidth = 6f;
			ui.Style.PreferredWidth = 6f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			ui.Style.FlexibleWidth = -1f;
			Image val2 = ui.Image(ref SettingsAccent, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val2).Slot, ((Worker)ui.Root).World, 6f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			ApplyPurpleBlueGradient(val2, 6f, 1f, interactionTarget: false);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 38f;
			ui.Style.PreferredHeight = 38f;
			LocaleString val3 = LocaleString.op_Implicit("DesktopBuddy Setup");
			Text obj = ui.Text(ref val3, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 30f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsText;
			ui.NestOut();
		}

		private static void AddSetupBodyText(UIBuilder ui, string text)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 48f;
			ui.Style.PreferredHeight = 48f;
			ui.Style.FlexibleWidth = 1f;
			LocaleString val = LocaleString.op_Implicit(text ?? "");
			Text obj = ui.Text(ref val, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)obj.Size).Value = 17f;
			((SyncField<colorX>)(object)obj.Color).Value = SettingsSubtext;
			_setupBodyText = obj;
		}

		private static void AddSetupStatusRow(UIBuilder ui, DesktopBuddyFirstRunSetup.SetupItem item)
		{
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinHeight = 58f;
			ui.Style.PreferredHeight = 58f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = -1f;
			Image val = ui.Image(ref SettingsPanel, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)val).Slot, ((Worker)ui.Root).World, 14f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val).RectTransform);
			ui.LayoutTarget = ((Component)val).Slot;
			ui.HorizontalLayout(12f, 8f, 12f, 8f, 14f, (Alignment?)(Alignment)4);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 40f;
			ui.Style.PreferredHeight = 40f;
			Slot val2 = ui.Empty("Text");
			ui.NestInto(val2);
			ui.LayoutTarget = val2;
			ui.VerticalLayout(2f, 0f, (Alignment?)(Alignment)3, (bool?)null, (bool?)null);
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 24f;
			ui.Style.PreferredHeight = 24f;
			LocaleString val3 = LocaleString.op_Implicit(item.Name ?? "");
			Text val4 = ui.Text(ref val3, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)val4.Size).Value = 17f;
			((SyncField<colorX>)(object)val4.Color).Value = SettingsText;
			ui.Style.MinHeight = 22f;
			ui.Style.PreferredHeight = 22f;
			val3 = LocaleString.op_Implicit(item.Detail ?? "");
			Text val5 = ui.Text(ref val3, true, (Alignment?)(Alignment)3, true, (string)null);
			((SyncField<float>)(object)val5.Size).Value = 13f;
			((SyncField<colorX>)(object)val5.Color).Value = SettingsSubtext;
			ui.NestOut();
			ui.Style.FlexibleWidth = -1f;
			ui.Style.MinWidth = 112f;
			ui.Style.PreferredWidth = 112f;
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			colorX color = (item.IsOk ? SettingsStatusGood : SettingsStatusBad);
			Image val6 = ui.Image(ref color, false);
			ApplyFixedLayout(((Component)val6).Slot, 112f, 30f);
			StyleBadgePill(val6, color);
			ui.NestInto(((UIComponent)val6).RectTransform);
			ui.LayoutTarget = ((Component)val6).Slot;
			HorizontalLayout obj = ui.HorizontalLayout(0f, 0f, (Alignment?)(Alignment)4);
			((SyncField<bool>)(object)((DirectionalLayout)obj).ForceExpandWidth).Value = true;
			((SyncField<bool>)(object)((DirectionalLayout)obj).ForceExpandHeight).Value = true;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.MinHeight = 30f;
			ui.Style.PreferredHeight = 30f;
			val3 = LocaleString.op_Implicit(item.Status ?? "");
			Text val7 = ui.Text(ref val3, true, (Alignment?)(Alignment)4, true, (string)null);
			((SyncField<float>)(object)val7.Size).Value = 13f;
			((SyncField<colorX>)(object)val7.Color).Value = SettingsText;
			ui.NestOut();
			ui.NestOut();
			_setupStatusRows.Add(new SetupStatusRowRefs
			{
				Name = val4,
				Detail = val5,
				Status = val7,
				Badge = val6
			});
		}

		private static void ApplyFixedLayout(Slot slot, float width, float height)
		{
			if (slot != null)
			{
				LayoutElement obj = ((ContainerWorker<Component>)(object)slot).GetComponent<LayoutElement>((Predicate<LayoutElement>)null, false) ?? ((ContainerWorker<Component>)(object)slot).AttachComponent<LayoutElement>(true, (Action<LayoutElement>)null);
				((SyncField<float>)(object)obj.MinWidth).Value = width;
				((SyncField<float>)(object)obj.PreferredWidth).Value = width;
				((SyncField<float>)(object)obj.FlexibleWidth).Value = -1f;
				((SyncField<float>)(object)obj.MinHeight).Value = height;
				((SyncField<float>)(object)obj.PreferredHeight).Value = height;
				((SyncField<float>)(object)obj.FlexibleHeight).Value = -1f;
			}
		}

		private static void AddSetupActions(UIBuilder ui, DesktopBuddyFirstRunSetup.SetupState state)
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			ui.Style.MinHeight = 40f;
			ui.Style.PreferredHeight = 40f;
			ui.Style.FlexibleWidth = 1f;
			Slot val = ui.Empty("Actions");
			ui.NestInto(val);
			ui.LayoutTarget = val;
			ui.HorizontalLayout(12f, 0f, (Alignment?)(Alignment)5);
			object obj = <>O.<5>__CloseSetupPanel;
			if (obj == null)
			{
				Action val2 = CloseSetupPanel;
				<>O.<5>__CloseSetupPanel = val2;
				obj = (object)val2;
			}
			AddSetupButton(ui, "Close", primary: false, (Action)obj);
			if (state.HasRequiredActions && !_setupCompleteAwaitingClose && !_setupInstallInProgress)
			{
				Button obj2 = AddSetupButton(ui, "Install", primary: true, (Action)delegate
				{
					InstallSetupActions(state);
				});
				_setupInstallButtonSlot = ((obj2 != null) ? ((Component)obj2).Slot : null);
			}
			ui.NestOut();
		}

		private static string GetSetupPanelMessage(DesktopBuddyFirstRunSetup.SetupState state)
		{
			if (_setupInstallInProgress)
			{
				return "Installing required Windows setup.";
			}
			if (!state.HasIssues)
			{
				if (!_setupCompleteAwaitingClose)
				{
					return "DesktopBuddy setup is complete.";
				}
				return "Setup complete. Close to start DesktopBuddy.";
			}
			bool flag = Enumerable.Any<DesktopBuddyFirstRunSetup.SetupItem>((global::System.Collections.Generic.IEnumerable<DesktopBuddyFirstRunSetup.SetupItem>)state.Items, (Func<DesktopBuddyFirstRunSetup.SetupItem, bool>)((DesktopBuddyFirstRunSetup.SetupItem item) => !item.IsOk && !item.RequiresAdminAction));
			if (state.HasRequiredActions && flag)
			{
				return "Install Windows setup. Restore missing package files separately.";
			}
			if (state.HasRequiredActions)
			{
				return "Install required Windows setup.";
			}
			return "Package files are missing. DesktopBuddy will still load.";
		}

		private static Button AddSetupButton(UIBuilder ui, string label, bool primary, Action pressed)
		{
			//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)
			//IL_0085: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			ui.Style.MinWidth = (primary ? 126f : 108f);
			ui.Style.PreferredWidth = (primary ? 126f : 108f);
			ui.Style.MinHeight = 32f;
			ui.Style.PreferredHeight = 32f;
			ui.Style.FlexibleWidth = -1f;
			LocaleString val = LocaleString.op_Implicit(label);
			colorX? val2 = (primary ? SettingsAccent : SettingsPanelSoft);
			Button obj = ui.Button(ref val, ref val2);
			StyleSettingsButton(obj, primary);
			obj.LocalPressed += (ButtonEventHandler)delegate
			{
				Action obj2 = pressed;
				if (obj2 != null)
				{
					obj2.Invoke();
				}
			};
			return obj;
		}

		private static void InstallSetupActions(DesktopBuddyFirstRunSetup.SetupState state)
		{
			if (_setupInstallInProgress || state == null || !state.HasRequiredActions)
			{
				return;
			}
			Msg("[SetupPanel] Install pressed");
			_setupInstallInProgress = true;
			_setupCompleteAwaitingClose = false;
			_setupInstallStartedUtc = global::System.DateTime.UtcNow;
			UpdateSetupPanelState(state);
			DesktopBuddyFirstRunSetup.SetupAction[] actions = Enumerable.ToArray<DesktopBuddyFirstRunSetup.SetupAction>((global::System.Collections.Generic.IEnumerable<DesktopBuddyFirstRunSetup.SetupAction>)state.RequiredActions);
			try
			{
				Process val = DesktopBuddyFirstRunSetup.StartElevatedSetup((global::System.Collections.Generic.IReadOnlyCollection<DesktopBuddyFirstRunSetup.SetupAction>)(object)actions);
				if (val == null)
				{
					_setupInstallInProgress = false;
					DesktopBuddyFirstRunSetup.SetupState setupState = DesktopBuddyFirstRunSetup.Check();
					if (!setupState.HasIssues)
					{
						ShowSetupCompletePanel();
					}
					else
					{
						UpdateSetupPanelState(setupState);
					}
					return;
				}
				try
				{
					if (val != null)
					{
						((Component)val).Dispose();
					}
				}
				catch
				{
				}
			}
			catch (global::System.Exception ex)
			{
				Msg("[SetupPanel] Install failed: " + ex.Message);
				_setupInstallInProgress = false;
				UpdateSetupPanelState(DesktopBuddyFirstRunSetup.Check());
				return;
			}
			ScheduleSetupInstallPoll();
		}

		private static void ScheduleSetupInstallPoll()
		{
			//IL_0045: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			Slot setupPanelRoot = _setupPanelRoot;
			World val = ((setupPanelRoot != null) ? ((Worker)setupPanelRoot).World : null) ?? GetSetupPanelWorld();
			if (val != null && !val.IsDestroyed)
			{
				object obj = <>O.<6>__PollSetupInstall;
				if (obj == null)
				{
					Action val2 = PollSetupInstall;
					<>O.<6>__PollSetupInstall = val2;
					obj = (object)val2;
				}
				val.RunInUpdates(120, (Action)obj);
			}
		}

		private static void PollSetupInstall()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			if (_setupInstallInProgress)
			{
				DesktopBuddyFirstRunSetup.SetupState setupState = DesktopBuddyFirstRunSetup.Check();
				if (!setupState.HasIssues)
				{
					_setupInstallInProgress = false;
					ShowSetupCompletePanel();
				}
				else if (global::System.DateTime.UtcNow - _setupInstallStartedUtc > TimeSpan.FromMinutes(3L))
				{
					Msg("[SetupPanel] Install did not complete; showing current setup status");
					_setupInstallInProgress = false;
					UpdateSetupPanelState(setupState);
				}
				else
				{
					UpdateSetupBodyText(setupState);
					ScheduleSetupInstallPoll();
				}
			}
		}

		private static void UpdateSetupPanelState(DesktopBuddyFirstRunSetup.SetupState state)
		{
			if (_setupPanelCanvas == null || ((ComponentBase<Component>)(object)_setupPanelCanvas).IsDestroyed || state == null)
			{
				return;
			}
			if (_setupStatusRows.Count != ((global::System.Collections.Generic.IReadOnlyCollection<DesktopBuddyFirstRunSetup.SetupItem>)state.Items).Count)
			{
				BuildSetupPanel(state);
				return;
			}
			UpdateSetupBodyText(state);
			for (int i = 0; i < ((global::System.Collections.Generic.IReadOnlyCollection<DesktopBuddyFirstRunSetup.SetupItem>)state.Items).Count; i++)
			{
				UpdateSetupStatusRow(_setupStatusRows[i], state.Items[i]);
			}
			if (_setupInstallButtonSlot != null && !((ContainerWorker<Component>)(object)_setupInstallButtonSlot).IsDestroyed)
			{
				_setupInstallButtonSlot.ActiveSelf = state.HasRequiredActions && !_setupInstallInProgress && !_setupCompleteAwaitingClose;
			}
		}

		private static void UpdateSetupBodyText(DesktopBuddyFirstRunSetup.SetupState state)
		{
			if (_setupBodyText != null && !((ComponentBase<Component>)(object)_setupBodyText).IsDestroyed)
			{
				((SyncField<string>)(object)_setupBodyText.Content).Value = GetSetupPanelMessage(state);
			}
		}

		private static void UpdateSetupStatusRow(SetupStatusRowRefs row, DesktopBuddyFirstRunSetup.SetupItem item)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			if (row != null && item != null)
			{
				if (row.Name != null && !((ComponentBase<Component>)(object)row.Name).IsDestroyed)
				{
					((SyncField<string>)(object)row.Name.Content).Value = item.Name ?? "";
				}
				if (row.Detail != null && !((ComponentBase<Component>)(object)row.Detail).IsDestroyed)
				{
					((SyncField<string>)(object)row.Detail.Content).Value = item.Detail ?? "";
				}
				if (row.Status != null && !((ComponentBase<Component>)(object)row.Status).IsDestroyed)
				{
					((SyncField<string>)(object)row.Status.Content).Value = item.Status ?? "";
				}
				if (row.Badge != null && !((ComponentBase<Component>)(object)row.Badge).IsDestroyed)
				{
					colorX val = (item.IsOk ? SettingsStatusGood : SettingsStatusBad);
					((SyncField<colorX>)(object)row.Badge.Tint).Value = val;
					StyleBadgePill(row.Badge, val);
				}
			}
		}

		private static void ShowSetupCompletePanel()
		{
			Msg("[SetupPanel] Local setup complete; waiting for close");
			_setupInstallInProgress = false;
			_setupCompleteAwaitingClose = true;
			UpdateSetupPanelState(DesktopBuddyFirstRunSetup.Check());
		}

		private static void CloseSetupPanel()
		{
			Msg("[SetupPanel] Setup notice closed");
			if (_setupCompleteAwaitingClose)
			{
				if (_setupPanelRoot != null && !((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
				{
					_setupPanelRoot.Destroy();
					return;
				}
				_setupNoticeDismissed = true;
				_setupCompleteAwaitingClose = false;
				EnsureDependencyRuntimeStarted();
				return;
			}
			_setupNoticeDismissed = true;
			_setupCompleteAwaitingClose = false;
			if (_setupPanelRoot != null && !((ContainerWorker<Component>)(object)_setupPanelRoot).IsDestroyed)
			{
				_setupPanelRoot.Destroy();
			}
			EnsureDependencyRuntimeStarted();
		}

		static DesktopBuddyMod()
		{
			//IL_06eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0702: Expected O, but got Unknown
			//IL_072f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0734: Unknown result type (might be due to invalid IL or missing references)
			//IL_074e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0753: Unknown result type (might be due to invalid IL or missing references)
			//IL_076d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0772: Unknown result type (might be due to invalid IL or missing references)
			//IL_078c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0791: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_07cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0808: Unknown result type (might be due to invalid IL or missing references)
			//IL_080d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0812: Unknown result type (might be due to invalid IL or missing references)
			//IL_0817: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0840: Unknown result type (might be due to invalid IL or missing references)
			//IL_085a: Unknown result type (might be due to invalid IL or missing references)
			//IL_085f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0888: 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_08a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0904: Unknown result type (might be due to invalid IL or missing references)
			//IL_0909: Unknown result type (might be due to invalid IL or missing references)
			//IL_0923: Unknown result type (might be due to invalid IL or missing references)
			//IL_0928: Unknown result type (might be due to invalid IL or missing references)
			//IL_0942: Unknown result type (might be due to invalid IL or missing references)
			//IL_0947: Unknown result type (might be due to invalid IL or missing references)
			//IL_0951: Unknown result type (might be due to invalid IL or missing references)
			//IL_095b: Expected O, but got Unknown
			//IL_096e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0973: Unknown result type (might be due to invalid IL or missing references)
			//IL_0985: Unknown result type (might be due to invalid IL or missing references)
			//IL_098a: Unknown result type (might be due to invalid IL or missing references)
			//IL_099c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_09b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_09fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a30: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a35: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a46: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a61: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a72: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a95: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ace: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> obj = new HashSet<string>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);
			obj.Add("FFmpeg.AutoGen");
			obj.Add("Microsoft.Windows.SDK.NET");
			obj.Add("WinRT.Runtime");
			DesktopBuddyManagedDependencies = obj;
			Perf = new PerfTimer();
			_runtimeBitrateMbps = 10;
			_runtimeStreamFps = 60;
			_runtimeMaxStreamResolution = 2560;
			_runtimeEncoderPreference = "auto";
			SpatialAudioEnabled = new DesktopBuddyConfigKey<bool>("spatialAudio", "Enable spatial in-game audio (redirects window audio to VB-Cable). When off, use Windows volume slider instead.", () => false);
			CheckForUpdates = new DesktopBuddyConfigKey<bool>("checkForUpdates", "Check for updates and show a notification when a new version is available on startup.", () => true);
			ShowContextMenuItem = new DesktopBuddyConfigKey<bool>("showContextMenuItem", "Show DesktopBuddy in the Resonite context menu.", () => true);
			ThrowToDestroy = new DesktopBuddyConfigKey<bool>("throwToDestroy", "Destroy DesktopBuddy panels when thrown quickly.", () => true);
			SpawnNewWindowsInGame = new DesktopBuddyConfigKey<bool>("spawnNewWindowsInGame", "Automatically spawn DesktopBuddy panels for new standalone windows from the same process.", () => true);
			SpawnNewWindowsPrivate = new DesktopBuddyConfigKey<bool>("spawnNewWindowsPrivate", "Automatically spawned new-window panels start private.", () => true);
			NewWindowsStartPrivate = new DesktopBuddyConfigKey<bool>("newWindowsStartPrivate", "New DesktopBuddy panels you spawn (monitors, windows, desktop) start in Private mode.", () => false);
			DynamicLightsEnabled = new DesktopBuddyConfigKey<bool>("dynamicLights", "Cast a dynamic in-game light that matches the captured screen's average color.", () => false);
			Bitrate = new DesktopBuddyConfigKey<int>("bitrate", "Video encoding bitrate in Mbps.", () => 10);
			StreamFps = new DesktopBuddyConfigKey<int>("streamFps", "Nominal stream FPS for encoder timing. Capture remains event-driven and is not frame-capped.", () => 60);
			MaxStreamResolution = new DesktopBuddyConfigKey<int>("maxStreamResolution", "Maximum encoded stream long-edge resolution. 2560 is 2K/QHD.", () => 2560);
			UseMediaMtx = new DesktopBuddyConfigKey<bool>("useMediaMtx", "Use an external MediaMTX server for streaming instead of the built-in Cloudflare HTTP stream.", () => false);
			MediaMtxHost = new DesktopBuddyConfigKey<string>("mediaMtxHost", "MediaMTX server address (IP or hostname).", () => "");
			MediaMtxPort = new DesktopBuddyConfigKey<int>("mediaMtxPort", "MediaMTX RTSP port.", () => 8554);
			MediaMtxStreamName = new DesktopBuddyConfigKey<string>("mediaMtxStreamName", "MediaMTX stream name (path component of the RTSP URL). Leave blank to auto-generate a random name per session.", () => "");
			StreamNetworkMode = new DesktopBuddyConfigKey<string>("streamNetworkMode", "Built-in stream access mode: cloudflare or port_forward.", () => "cloudflare");
			PortForwardHostMode = new DesktopBuddyConfigKey<string>("portForwardHostMode", "Port-forward host mode: auto or manual.", () => "auto");
			PortForwardAutoIpMode = new DesktopBuddyConfigKey<string>("portForwardAutoIpMode", "Auto port-forward host IP source. External public IPv4 is always used.", () => "external");
			PortForwardHost = new DesktopBuddyConfigKey<string>("portForwardHost", "Manual public hostname or IP for port-forwarded built-in streams.", () => "");
			PortForwardUseNat = new DesktopBuddyConfigKey<bool>("portForwardUseNat", "Automatically create a UPnP/NAT TCP port mapping for the built-in stream port.", () => false);
			PanelCurvePreferences = new DesktopBuddyConfigKey<string>("panelCurvePreferences", "Saved DesktopBuddy panel curve values, keyed by application executable path or shared desktop capture.", () => "");
			LinuxSharedSources = new DesktopBuddyConfigKey<string>("linuxSharedSources", "Saved Linux desktop/window sources for instant re-share, with their restore tokens and icons.", () => "");
			ViewerCullingMode = new DesktopBuddyConfigKey<string>("viewerCullingMode", "Viewer culling mode for remote streams: frustum or distance.", () => "frustum");
			ViewerCullingPreview = new DesktopBuddyConfigKey<bool>("viewerCullingPreview", "Show the viewer culling preview guide on DesktopBuddy panels.", () => false);
			ViewerFrustumWidth = new DesktopBuddyConfigKey<float>("viewerFrustumWidth", "Viewer frustum culling preview angle in degrees.", () => 120f);
			ViewerFrustumDepth = new DesktopBuddyConfigKey<float>("viewerFrustumDepth", "Viewer frustum culling depth in meters.", () => 3f);
			ViewerDistance = new DesktopBuddyConfigKey<float>("viewerDistance", "Viewer distance culling radius in meters.", () => 3f);
			EncoderPreference = new DesktopBuddyConfigKey<string>("encoderPreference", "Explicit stream encoder preference, or auto.", () => "auto");
			PreferredGpuLuid = new DesktopBuddyConfigKey<string>("preferredGpuLuid", "Preferred DXGI adapter LUID for DesktopBuddy capture/encoding, or blank for auto.", () => "");
			StreamAudioOutputVolume = new DesktopBuddyConfigKey<float>("streamAudioOutputVolume", "Default local stream AudioOutput volume. 0 means viewers start muted and opt in.", () => 0f);
			StreamAudioGlobalMode = new DesktopBuddyConfigKey<string>("streamAudioGlobalMode", "Stream AudioOutput global mode: auto, global, or positional.", () => "positional");
			StreamAudioSpatialize = new DesktopBuddyConfigKey<bool>("streamAudioSpatialize", "Enable stream AudioOutput spatialization.", () => true);
			StreamAudioSpatialBlend = new DesktopBuddyConfigKey<float>("streamAudioSpatialBlend", "Stream AudioOutput spatial blend.", () => 1f);
			StreamAudioDistanceSpace = new DesktopBuddyConfigKey<string>("streamAudioDistanceSpace", "Stream AudioOutput distance space: local or global.", () => "global");
			StreamAudioDopplerLevel = new DesktopBuddyConfigKey<float>("streamAudioDopplerLevel", "Stream AudioOutput doppler level.", () => 0f);
			StreamAudioPitch = new DesktopBuddyConfigKey<float>("streamAudioPitch", "Stream AudioOutput pitch.", () => 1f);
			StreamAudioIgnoreAudioEffects = new DesktopBuddyConfigKey<bool>("streamAudioIgnoreAudioEffects", "Bypass Resonite audio effects for stream playback.", () => true);
			StreamAudioTypeGroup = new DesktopBuddyConfigKey<string>("streamAudioTypeGroup", "Stream AudioOutput type group: multimedia, sound_effect, voice, or ui.", () => "multimedia");
			StreamAudioRolloffMode = new DesktopBuddyConfigKey<string>("streamAudioRolloffMode", "Stream AudioOutput rolloff mode: logarithmic_fade_off or linear.", () => "linear");
			StreamAudioMinDistance = new DesktopBuddyConfigKey<float>("streamAudioMinDistance", "Stream AudioOutput minimum distance.", () => 1f);
			StreamAudioMaxDistance = new DesktopBuddyConfigKey<float>("streamAudioMaxDistance", "Stream AudioOutput maximum distance.", () => 30f);
			StreamAudioSpatializationStartDistance = new DesktopBuddyConfigKey<float>("streamAudioSpatializationStartDistance", "Stream AudioOutput spatialization start distance.", () => 0.01f);
			StreamAudioSpatializationTransitionRange = new DesktopBuddyConfigKey<float>("streamAudioSpatializationTransitionRange", "Stream AudioOutput spatialization transition range.", () => 0.01f);
			StreamAudioPriority = new DesktopBuddyConfigKey<int>("streamAudioPriority", "Stream AudioOutput priority.", () => 128);
			StreamAudioMinScale = new DesktopBuddyConfigKey<float>("streamAudioMinScale", "Stream AudioOutput local-distance minimum scale clamp.", () => 0f);
			StreamAudioMaxScale = new DesktopBuddyConfigKey<float>("streamAudioMaxScale", "Stream AudioOutput local-distance maximum scale clamp.", () => 1000f);
			ExternalIpGate = new object();
			NatMappingGate = new object();
			ExternalIpClient = new HttpClient
			{
				Timeout = TimeSpan.FromSeconds(2L)
			};
			AdaptiveLightSampleIntervalTicks = Stopwatch.Frequency / 10;
			_scheduledWorlds = new HashSet<World>();
			SettingsBg = new colorX(0.055f, 0.06f, 0.072f, 0.84f, (ColorProfile)1);
			SettingsPanel = new colorX(0.085f, 0.095f, 0.115f, 0.94f, (ColorProfile)1);
			SettingsPanelSoft = new colorX(0.115f, 0.125f, 0.15f, 0.94f, (ColorProfile)1);
			SettingsAccent = new colorX(0.16f, 0.42f, 0.48f, 0.98f, (ColorProfile)1);
			SettingsAccentSoft = new colorX(0.13f, 0.24f, 0.28f, 0.96f, (ColorProfile)1);
			SettingsGradientPurple = new colorX(0.68f, 0.08f, 1f, 0.98f, (ColorProfile)1);
			SettingsGradientBlue = new colorX(0.05f, 0.5f, 1f, 0.98f, (ColorProfile)1);
			SettingsGradientMid = new colorX(0.35f, 0.22f, 0.95f, 0.98f, (ColorProfile)1);
			SettingsGradientPalette = new UiGradientPalette(SettingsGradientPurple, SettingsGradientMid, SettingsGradientBlue);
			SettingsScrollbarStyle = new UiScrollbarStyle(new colorX(0.07f, 0.078f, 0.095f, 0.72f, (ColorProfile)1), new colorX(0.02f, 0.024f, 0.032f, 0.55f, (ColorProfile)1), SettingsAccentSoft, SettingsGradientPalette);
			SettingsExperimentalOrange = new colorX(1f, 0.48f, 0.08f, 0.98f, (ColorProfile)1);
			SettingsStatusGood = new colorX(0.12f, 0.58f, 0.28f, 0.98f, (ColorProfile)1);
			SettingsStatusWarn = new colorX(1f, 0.5f, 0.08f, 0.98f, (ColorProfile)1);
			SettingsStatusBad = new colorX(0.72f, 0.1f, 0.16f, 0.98f, (ColorProfile)1);
			SettingsStatusNeutral = new colorX(0.26f, 0.3f, 0.38f, 0.98f, (ColorProfile)1);
			SettingsText = new colorX(0.93f, 0.94f, 0.97f, 1f, (ColorProfile)1);
			SettingsSubtext = new colorX(0.68f, 0.72f, 0.78f, 1f, (ColorProfile)1);
			DefaultViewerAvatar = new Uri("resdb:///bb7d7f1414e0c0a44b4684ecd2a5dc2086c18b3f70c9ed53d467fe96af94e9a9.png");
			SettingsTabs = new ValueTuple<SettingsPanelTab, string, string>[8]
			{
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Viewers, "Viewers", "\ud83d\udc65"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.General, "General", "⚙"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Stream, "Stream", "\ud83d\udce1"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Network, "Network", "☁"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Devices, "Devices", "\ud83c\udfa5"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Audio, "Audio", "\ud83d\udd0a"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.Debug, "Debug", "\ud83e\uddf0"),
				new ValueTuple<SettingsPanelTab, string, string>(SettingsPanelTab.UpdateInfo, "Info", "ℹ")
			};
			StreamResolutionOptions = new ValueTuple<int, string>[4]
			{
				new ValueTuple<int, string>(1280, "720p"),
				new ValueTuple<int, string>(1920, "1080p"),
				new ValueTuple<int, string>(2560, "1440p"),
				new ValueTuple<int, string>(3840, "4K")
			};
			StreamFpsOptions = new ValueTuple<int, string>[4]
			{
				new ValueTuple<int, string>(30, "30"),
				new ValueTuple<int, string>(60, "60"),
				new ValueTuple<int, string>(90, "90"),
				new ValueTuple<int, string>(120, "120")
			};
			_setupStatusRows = new List<SetupStatusRowRefs>();
		}
	}
	internal static class DesktopBuddyRuntimePaths
	{
		internal const string DirectoryName = "DesktopBuddyRuntime";

		private const string RuntimePackageDirectoryName = "DevL0rd-DesktopBuddyRuntime";

		private const string PluginDirectoryName = "DesktopBuddy";

		internal static string GetDirectory()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			string text = FindBepInExPluginsRoot();
			if (string.IsNullOrWhiteSpace(text))
			{
				throw new DirectoryNotFoundException("DesktopBuddy requires the Gale-style BepInEx\\plugins package layout.");
			}
			return Path.GetFullPath(Path.Combine(text, "DevL0rd-DesktopBuddyRuntime", "DesktopBuddy", "DesktopBuddyRuntime"));
		}

		internal static string FindFile(string fileName)
		{
			return Path.GetFullPath(Path.Combine(GetDirectory(), fileName));
		}

		private static string FindBepInExPluginsRoot()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			for (DirectoryInfo val = new DirectoryInfo(Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? ""); val != null; val = val.Parent)
			{
				if (((FileSystemInfo)val).Name.Equals("plugins", (StringComparison)5))
				{
					DirectoryInfo parent = val.Parent;
					if (parent != null && ((FileSystemInfo)parent).Name.Equals("BepInEx", (StringComparison)5))
					{
						return ((FileSystemInfo)val).FullName;
					}
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(EyeManager), "RaycastFilter")]
	internal static class EyeManagerLocalLookTargetFix
	{
		private static void Postfix(ICollider c, ref bool __result)
		{
			if (__result && c != null)
			{
				Slot slot = ((IComponent)c).Slot;
				if (((slot != null) ? new bool?(((Worker)slot).IsLocalElement) : ((bool?)null)) == true)
				{
					__result = false;
				}
			}
		}
	}
	internal static class DesktopBuddyPlatform
	{
		private static bool? _isLinux;

		internal static bool IsLinux
		{
			get
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				bool valueOrDefault = _isLinux == true;
				if (!_isLinux.HasValue)
				{
					valueOrDefault = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
					_isLinux = valueOrDefault;
				}
				return _isLinux.Value;
			}
		}

		internal static string RuntimeLabel
		{
			get
			{
				if (!IsLinux)
				{
					return RuntimeInformation.OSDescription;
				}
				return "Linux";
			}
		}
	}
	internal static class RuntimeStore
	{
		internal static readonly List<DesktopSession> ActiveSessions = new List<DesktopSession>();

		internal static readonly HashSet<RefID> DesktopCanvasIds = new HashSet<RefID>();

		internal static readonly object TopBarRaycastGate = new object();

		internal static readonly Dictionary<RefID, Slot> TopBarRaycastTargets = new Dictionary<RefID, Slot>();

		internal static BuiltInStreamServer StreamServer;

		internal static string TunnelUrl;

		internal static Process TunnelProcess;

		internal static string CloudflaredPath;

		internal static volatile bool TunnelRestarting;

		internal static VirtualCamera VCam;

		internal static VirtualMic VMic;

		internal static SharedTextureBridgeChannel TextureBridgeChannel;

		internal static bool TextureBridgeOpened;

		internal static readonly HashSet<DesktopTextureProvider> OurProviders = new HashSet<DesktopTextureProvider>();

		internal static Thread WindowPollerThread;

		internal static volatile bool WindowPollerRunning;

		internal static readonly ConcurrentQueue<WindowEvent> WindowEvents = new ConcurrentQueue<WindowEvent>();

		internal static readonly HashSet<nint> AutoSpawnSeenWindows = new HashSet<nint>();

		internal static bool AutoSpawnWindowBaselineInitialized;

		internal static string LatestVersion;

		internal static string RemoteVersion;

		internal static string RemoteSha;

		internal static string RemoteChangelog;

		internal static string UpdateCheckError;

		internal static global::System.DateTime LastUpdateCheckUtc;

		internal static volatile bool UpdateCheckInProgress;

		internal static bool UpdateShown;

		internal static volatile bool SettingsConfigDirty;
	}
	internal struct WindowEvent
	{
		public DesktopSession Session;

		public nint WindowHwnd;

		public string Title;

		public WindowEventType EventType;
	}
	internal enum WindowEventType
	{
		NewTopLevelWindow,
		TitleChanged
	}
	public class DesktopAudioSource : Component, IWorldAudioDataSource, IAudioDataSource, IWorldElement
	{
		private AudioCapture _audioCapture;

		private long _readPos;

		public bool IsActive
		{
			get
			{
				if (((ComponentBase<Component>)this).Enabled)
				{
					return _audioCapture != null;
				}
				return false;
			}
		}

		public int ChannelCount => 2;

		public void SetAudioCapture(AudioCapture capture)
		{
			_audioCapture = capture;
			_readPos = capture?.WritePosition ?? 0;
			Log.Msg($"[DesktopAudioSource] AudioCapture set, readPos synced to {_readPos}");
		}

		public void Read<S>(global::System.Span<S> buffer, AudioSimulator system) where S : unmanaged, IAudioSample<S>
		{
			AudioCapture audioCapture = _audioCapture;
			if (audioCapture == null)
			{
				buffer.Clear();
				return;
			}
			int num = buffer.Length * 2;
			if (num <= 2048)
			{
				global::System.Span<float> span = stackalloc float[num];
				int readCount = audioCapture.ReadSamples(span, ref _readPos);
				FillBuffer(buffer, span, readCount);
			}
			else
			{
				float[] array = new float[num];
				int num2 = audioCapture.ReadSamples(array, num, ref _readPos);
				FillBuffer(buffer, MemoryExtensions.AsSpan<float>(array, 0, (num2 > 0) ? num2 : 0), num2);
			}
		}

		private static void FillBuffer<S>(global::System.Span<S> buffer, global::System.Span<float> samples, int readCount) where S : unmanaged, IAudioSample<S>
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			int num = readCount / 2;
			if (typeof(S) == typeof(StereoSample))
			{
				global::System.Span<StereoSample> span = MemoryMarshal.Cast<S, StereoSample>(buffer);
				for (int i = 0; i < num && i < span.Length; i++)
				{
					span[i] = new StereoSample(samples[i * 2], samples[i * 2 + 1]);
				}
				for (int j = num; j < span.Length; j++)
				{
					span[j] = default(StereoSample);
				}
			}
			else if (typeof(S) == typeof(MonoSample))
			{
				global::System.Span<MonoSample> span2 = MemoryMarshal.Cast<S, MonoSample>(buffer);
				for (int k = 0; k < num && k < span2.Length; k++)
				{
					span2[k] = new MonoSample((samples[k * 2] + samples[k * 2 + 1]) * 0.5f);
				}
				for (int l = num; l < span2.Length; l++)
				{
					span2[l] = default(MonoSample);
				}
			}
			else
			{
				buffer.Clear();
			}
		}
	}
	public sealed class DesktopStreamer : global::System.IDisposable
	{
		private readonly nint _hwnd;

		private readonly nint _monitorHandle;

		private IDesktopCaptureBackend _backend;

		private int _disposed;

		public nint MonitorHandle => _monitorHandle;

		[field: CompilerGenerated]
		public int Width
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public int Height
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public bool IsValid => _backend?.IsValid ?? false;

		public object D3dContextLock => _backend?.D3dContextLock;

		public nint D3dDevice => _backend?.D3dDevice ?? global::System.IntPtr.Zero;

		public nint D3dContext => _backend?.D3dContext ?? global::System.IntPtr.Zero;

		public nint SharedTexture => _backend?.SharedTexture ?? global::System.IntPtr.Zero;

		public nint SharedTextureHandle => _backend?.SharedTextureHandle ?? global::System.IntPtr.Zero;

		public int SharedTextureWidth => _backend?.SharedTextureWidth ?? 0;

		public int SharedTextureHeight => _backend?.SharedTextureHeight ?? 0;

		public bool HasCurrentSharedFrame => _backend?.HasCurrentSharedFrame ?? false;

		public bool IsResizeRecreatePending => _backend?.IsResizeRecreatePending ?? false;

		public uint LinuxPipeWireNodeId
		{
			get
			{
				if (!(_backend is ILinuxPipeWireSelection linuxPipeWireSelection))
				{
					return 0u;
				}
				return linuxPipeWireSelection.PipeWireNodeId;
			}
		}

		public ulong LinuxInputSessionId
		{
			get
			{
				if (!(_backend is ILinuxPipeWireSelection linuxPipeWireSelection))
				{
					return 0uL;
				}
				return linuxPipeWireSelection.InputSessionId;
			}
		}

		public Action<nint, nint, int, int> OnGpuFrame
		{
			get
			{
				return _backend?.OnGpuFrame;
			}
			set
			{
				if (_backend != null)
				{
					_backend.OnGpuFrame = value;
				}
			}
		}

		public DesktopStreamer(nint hwnd, nint monitorHandle = 0)
		{
			_hwnd = hwnd;
			_monitorHandle = monitorHandle;
		}

		public bool TryInitialCapture()
		{
			_backend = CreateBackend();
			Log.Msg($"[DesktopStreamer] Initial capture starting backend={((MemberInfo)((object)_backend).GetType()).Name} hwnd={_hwnd} monitor=0x{_monitorHandle:X}");
			if (!_backend.TryInitialCapture())
			{
				Log.Msg($"[DesktopStreamer] Initial capture failed hwnd={_hwnd} monitor=0x{_monitorHandle:X}");
				((global::System.IDisposable)_backend).Dispose();
				_backend = null;
				return false;
			}
			Width = _backend.Width;
			Height = _backend.Height;
			Log.Msg($"[DesktopStreamer] Capture initialized ({Width}x{Height})");
			return true;
		}

		private IDesktopCaptureBackend CreateBackend()
		{
			if (!DesktopBuddyPlatform.IsLinux)
			{
				return new WgcCaptureBackend(_hwnd, _monitorHandle);
			}
			return new LinuxPortalCaptureBackend();
		}

		public void RecreatePoolIfNeeded()
		{
			if (_backend != null)
			{
				_backend.RecreatePoolIfNeeded();
				Width = _backend.Width;
				Height = _backend.Height;
			}
		}

		public void FlushD3dContext()
		{
			_backend?.FlushD3dContext();
		}

		public void StopCapture()
		{
			_backend?.StopCapture();
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref _disposed, 1) == 0)
			{
				((global::System.IDisposable)_backend)?.Dispose();
				_backend = null;
			}
		}
	}
	[HarmonyPatch(typeof(DesktopTextureProvider), "UpdateAsset")]
	internal static class DesktopTextureProviderPatch
	{
		private static FieldInfo _assetField;

		private static PropertyInfo _assetMgrProp;

		private static MethodInfo _initMethod;

		private static MethodInfo _onCreatedMethod;

		private static bool _reflectionCached;

		private static bool _reflectionValid;

		private static bool Prefix(DesktopTextureProvider __instance)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			if (!DesktopBuddyMod.OurProviders.Contains(__instance))
			{
				return true;
			}
			if (((SyncField<int>)(object)__instance.DisplayIndex).Value == -2147483648)
			{
				return false;
			}
			try
			{
				if (!_reflectionCached)
				{
					CacheReflection();
					_reflectionCached = true;
				}
				if (!_reflectionValid)
				{
					return true;
				}
				object value = _assetField.GetValue((object)__instance);
				DesktopTexture val = (DesktopTexture)((value is DesktopTexture) ? value : null);
				if (val == null)
				{
					val = new DesktopTexture();
					PropertyInfo assetMgrProp = _assetMgrProp;
					object obj = ((assetMgrProp != null) ? assetMgrProp.GetValue((object)__instance) : null);
					if (obj != null)
					{
						MethodInfo initMethod = _initMethod;
						if (initMethod != null)
						{
							((MethodBase)initMethod).Invoke((object)val, new object[1] { obj });
						}
					}
					else
					{
						Log.Msg("[DesktopTextureProviderPatch] WARNING: AssetManager is null");
					}
					_assetField.SetValue((object)__instance, (object)val);
				}
				Action val2 = (Action)global::System.Delegate.CreateDelegate(typeof(Action), (object)__instance, _onCreatedMethod);
				val.Update(((SyncField<int>)(object)__instance.DisplayIndex).Value, val2);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[DesktopTextureProviderPatch] Error: {ex}");
				return true;
			}
			return false;
		}

		internal static void PrewarmReflection()
		{
			if (!_reflectionCached)
			{
				CacheReflection();
				_reflectionCached = true;
			}
		}

		private static void CacheReflection()
		{
			global::System.Type typeFromHandle = typeof(DesktopTextureProvider);
			_assetField = typeFromHandle.GetField("_desktopTex", (BindingFlags)36);
			global::System.Type type = typeFromHandle;
			while (type != (global::System.Type)null && _assetMgrProp == (PropertyInfo)null)
			{
				_assetMgrProp = type.GetProperty("AssetManager", (BindingFlags)54);
				type = type.BaseType;
			}
			_initMethod = typeof(DesktopTexture).GetMethod("InitializeDynamic", (BindingFlags)20);
			_onCreatedMethod = typeFromHandle.GetMethod("OnTextureCreated", (BindingFlags)36);
			_reflectionValid = _assetField != (FieldInfo)null && _onCreatedMethod != (MethodInfo)null;
			Log.Msg($"[DesktopTextureProviderPatch] Reflection cached: assetField={_assetField != (FieldInfo)null} assetMgr={_assetMgrProp != (PropertyInfo)null} init={_initMethod != (MethodInfo)null} onCreated={_onCreatedMethod != (MethodInfo)null}");
		}
	}
	internal interface IDesktopCaptureBackend : global::System.IDisposable
	{
		int Width { get; }

		int Height { get; }

		bool IsValid { get; }

		object D3dContextLock { get; }

		nint D3dDevice { get; }

		nint D3dContext { get; }

		nint SharedTexture { get; }

		nint SharedTextureHandle { get; }

		int SharedTextureWidth { get; }

		int SharedTextureHeight { get; }

		bool HasCurrentSharedFrame { get; }

		bool IsResizeRecreatePending { get; }

		Action<nint, nint, int, int> OnGpuFrame { get; set; }

		bool TryInitialCapture();

		void RecreatePoolIfNeeded();

		void FlushD3dContext();

		void StopCapture();
	}
	internal sealed class LinuxNativeBridge : global::System.IDisposable
	{
		private unsafe delegate* unmanaged[Cdecl]<uint, ulong*, int> _startNode;

		private unsafe delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int> _pollFrame;

		private unsafe delegate* unmanaged[Cdecl]<ulong, void> _stopCapture;

		private unsafe delegate* unmanaged[Cdecl]<ulong, int> _captureAlive;

		private unsafe delegate* unmanaged[Cdecl]<DbLinuxFrame*, byte*, nuint, int> _copyAndCloseFrame;

		private unsafe delegate* unmanaged[Cdecl]<DbLinuxFrame*, void> _closeFrame;

		private unsafe delegate* unmanaged[Cdecl]<ulong*, int> _audioStart;

		private unsafe delegate* unmanaged[Cdecl]<ulong, float*, int, int> _audioPoll;

		private unsafe delegate* unmanaged[Cdecl]<ulong, void> _audioStop;

		private unsafe delegate* unmanaged[Cdecl]<uint, int, int, int, uint, byte*, nuint, byte*, nuint, int, int, int, ulong*, int> _streamStart;

		private unsafe delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int> _streamPushFrame;

		private unsafe delegate* unmanaged[Cdecl]<ulong, float*, int, int> _streamPushAudio;

		private unsafe delegate* unmanaged[Cdecl]<ulong, byte*, int, long*, int*, long, int*, int*, int> _streamRead;

		private unsafe delegate* unmanaged[Cdecl]<ulong, DbLinuxStreamInfo*, int> _streamInfo;

		private unsafe delegate* unmanaged[Cdecl]<ulong, void> _streamStop;

		private unsafe delegate* unmanaged[Cdecl]<nint> _streamLastError;

		private unsafe delegate* unmanaged[Cdecl]<int, int, int> _vcamOpen;

		private unsafe delegate* unmanaged[Cdecl]<int, byte*, int, int> _vcamWrite;

		private unsafe delegate* unmanaged[Cdecl]<int, void> _vcamClose;

		private unsafe delegate* unmanaged[Cdecl]<byte*, nuint, ulong*, DbLinuxSelection*, int> _inputStart;

		private unsafe delegate* unmanaged[Cdecl]<ulong, double, double, void> _inputMotion;

		private unsafe delegate* unmanaged[Cdecl]<ulong, uint, double, double, int> _inputTouchDown;

		private unsafe delegate* unmanaged[Cdecl]<ulong, uint, double, double, void> _inputTouchMotion;

		private unsafe delegate* unmanaged[Cdecl]<ulong, uint, void> _inputTouchUp;

		private unsafe delegate* unmanaged[Cdecl]<ulong, int, void> _inputScroll;

		private unsafe delegate* unmanaged[Cdecl]<ulong, int, int, void> _inputKey;

		private unsafe delegate* unmanaged[Cdecl]<ulong, void> _inputStop;

		private unsafe delegate* unmanaged[Cdecl]<nint> _inputLastError;

		private nint _module;

		private nint _streamModule;

		private bool _disposed;

		private bool IsLoaded => _module != (nint)global::System.IntPtr.Zero;

		internal unsafe bool TryLoad()
		{
			if (IsLoaded)
			{
				return true;
			}
			string text = ResolveNativePath();
			if (string.IsNullOrWhiteSpace(text) || !File.Exists(text))
			{
				Log.Msg("[LinuxNativeBridge] Native library not found: " + (text ?? "(null)"));
				return false;
			}
			try
			{
				_module = NativeLibrary.Load(text);
				_startNode = (delegate* unmanaged[Cdecl]<uint, ulong*, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_capture_start_node");
				_pollFrame = (delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_capture_poll");
				_stopCapture = (delegate* unmanaged[Cdecl]<ulong, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_capture_stop");
				_captureAlive = (delegate* unmanaged[Cdecl]<ulong, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_capture_alive");
				_copyAndCloseFrame = (delegate* unmanaged[Cdecl]<DbLinuxFrame*, byte*, nuint, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_frame_copy_and_close");
				_closeFrame = (delegate* unmanaged[Cdecl]<DbLinuxFrame*, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_frame_close");
				_audioStart = (delegate* unmanaged[Cdecl]<ulong*, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_audio_start");
				_audioPoll = (delegate* unmanaged[Cdecl]<ulong, float*, int, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_audio_poll");
				_audioStop = (delegate* unmanaged[Cdecl]<ulong, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_audio_stop");
				_inputStart = (delegate* unmanaged[Cdecl]<byte*, nuint, ulong*, DbLinuxSelection*, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_start");
				_inputMotion = (delegate* unmanaged[Cdecl]<ulong, double, double, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_motion");
				_inputTouchDown = (delegate* unmanaged[Cdecl]<ulong, uint, double, double, int>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_touch_down");
				_inputTouchMotion = (delegate* unmanaged[Cdecl]<ulong, uint, double, double, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_touch_motion");
				_inputTouchUp = (delegate* unmanaged[Cdecl]<ulong, uint, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_touch_up");
				_inputScroll = (delegate* unmanaged[Cdecl]<ulong, int, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_scroll");
				_inputKey = (delegate* unmanaged[Cdecl]<ulong, int, int, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_key");
				_inputStop = (delegate* unmanaged[Cdecl]<ulong, void>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_stop");
				_inputLastError = (delegate* unmanaged[Cdecl]<nint>)NativeLibrary.GetExport((global::System.IntPtr)_module, "db_linux_input_last_error");
				Log.Msg("[LinuxNativeBridge] Loaded " + text);
				return true;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[LinuxNativeBridge] Load failed path=" + text + ": " + ex.Message);
				if (_module != (nint)global::System.IntPtr.Zero)
				{
					NativeLibrary.Free((global::System.IntPtr)_module);
					_module = global::System.IntPtr.Zero;
				}
				_startNode = null;
				_pollFrame = null;
				_stopCapture = null;
				_captureAlive = null;
				_copyAndCloseFrame = null;
				_closeFrame = null;
				_audioStart = null;
				_audioPoll = null;
				_audioStop = null;
				_inputStart = null;
				_inputMotion = null;
				_inputTouchDown = null;
				_inputTouchMotion = null;
				_inputTouchUp = null;
				_inputScroll = null;
				_inputKey = null;
				_inputStop = null;
				_inputLastError = null;
				return false;
			}
		}

		internal unsafe ulong SessionStart(string restoreToken, out DbLinuxSelection selection, out string newRestoreToken, out bool isMonitor)
		{
			selection = default(DbLinuxSelection);
			newRestoreToken = null;
			isMonitor = false;
			if (!TryLoad() || _inputStart == (delegate* unmanaged[Cdecl]<byte*, nuint, ulong*, DbLinuxSelection*, int>)null)
			{
				return 0uL;
			}
			byte[] array = (string.IsNullOrEmpty(restoreToken) ? null : Encoding.UTF8.GetBytes(restoreToken));
			ulong num = 0uL;
			fixed (DbLinuxSelection* ptr = &selection)
			{
				fixed (byte* ptr2 = array)
				{
					_inputStart(ptr2, (nuint)(int)((array != null) ? ((uint)array.Length) : 0u), &num, ptr);
				}
			}
			if (num != 0L)
			{
				if (selection.RestoreTokenLen != 0)
				{
					int num2 = (int)Math.Min(selection.RestoreTokenLen, 256u);
					fixed (byte* restoreToken2 = selection.RestoreToken)
					{
						newRestoreToken = Encoding.UTF8.GetString(restoreToken2, num2);
					}
				}
				isMonitor = selection.IsMonitor != 0;
			}
			return num;
		}

		internal unsafe string GetInputLastError()
		{
			if (_inputLastError == (delegate* unmanaged[Cdecl]<nint>)null)
			{
				return null;
			}
			try
			{
				nint num = _inputLastError();
				return (num == (nint)global::System.IntPtr.Zero) ? null : Marshal.PtrToStringAnsi((global::System.IntPtr)num);
			}
			catch
			{
				return null;
			}
		}

		internal unsafe void InputMotion(ulong sessionId, double u, double v)
		{
			if (_inputMotion != (delegate* unmanaged[Cdecl]<ulong, double, double, void>)null && sessionId != 0L)
			{
				_inputMotion(sessionId, u, v);
			}
		}

		internal unsafe int TouchDown(ulong sessionId, uint slot, double u, double v)
		{
			if (_inputTouchDown == (delegate* unmanaged[Cdecl]<ulong, uint, double, double, int>)null || sessionId == 0L)
			{
				return -2;
			}
			return _inputTouchDown(sessionId, slot, u, v);
		}

		internal unsafe void TouchMotion(ulong sessionId, uint slot, double u, double v)
		{
			if (_inputTouchMotion != (delegate* unmanaged[Cdecl]<ulong, uint, double, double, void>)null && sessionId != 0L)
			{
				_inputTouchMotion(sessionId, slot, u, v);
			}
		}

		internal unsafe void TouchUp(ulong sessionId, uint slot)
		{
			if (_inputTouchUp != (delegate* unmanaged[Cdecl]<ulong, uint, void>)null && sessionId != 0L)
			{
				_inputTouchUp(sessionId, slot);
			}
		}

		internal unsafe void InputScroll(ulong sessionId, int steps)
		{
			if (_inputScroll != (delegate* unmanaged[Cdecl]<ulong, int, void>)null && sessionId != 0L)
			{
				_inputScroll(sessionId, steps);
			}
		}

		internal unsafe void InputKey(ulong sessionId, int keysym, bool pressed)
		{
			if (_inputKey != (delegate* unmanaged[Cdecl]<ulong, int, int, void>)null && sessionId != 0L)
			{
				_inputKey(sessionId, keysym, pressed ? 1 : 0);
			}
		}

		internal unsafe void InputStop(ulong sessionId)
		{
			if (_inputStop != (delegate* unmanaged[Cdecl]<ulong, void>)null && sessionId != 0L)
			{
				_inputStop(sessionId);
			}
		}

		internal unsafe int StartCapture(uint nodeId, out ulong captureId)
		{
			captureId = 0uL;
			if (!TryLoad() || _startNode == (delegate* unmanaged[Cdecl]<uint, ulong*, int>)null)
			{
				return -1;
			}
			ulong num = 0uL;
			int result = _startNode(nodeId, &num);
			captureId = num;
			return result;
		}

		internal unsafe int PollFrame(ulong captureId, out DbLinuxFrame frame)
		{
			frame = default(DbLinuxFrame);
			if (!TryLoad() || _pollFrame == (delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int>)null || captureId == 0L)
			{
				return -1;
			}
			DbLinuxFrame dbLinuxFrame = default(DbLinuxFrame);
			int result = _pollFrame(captureId, &dbLinuxFrame);
			frame = dbLinuxFrame;
			return result;
		}

		internal unsafe void StopCapture(ulong captureId)
		{
			if (_stopCapture != (delegate* unmanaged[Cdecl]<ulong, void>)null && captureId != 0L)
			{
				_stopCapture(captureId);
			}
		}

		internal unsafe bool IsCaptureAlive(ulong captureId)
		{
			if (!TryLoad() || _captureAlive == (delegate* unmanaged[Cdecl]<ulong, int>)null || captureId == 0L)
			{
				return true;
			}
			return _captureAlive(captureId) != 0;
		}

		internal unsafe int CopyAndCloseFrame(DbLinuxFrame frame, byte[] destination)
		{
			if (!TryLoad() || _copyAndCloseFrame == (delegate* unmanaged[Cdecl]<DbLinuxFrame*, byte*, nuint, int>)null || destination == null || destination.Length == 0)
			{
				return -1;
			}
			fixed (byte* ptr = destination)
			{
				return _copyAndCloseFrame(&frame, ptr, (nuint)destination.LongLength);
			}
		}

		internal unsafe void CloseFrame(DbLinuxFrame frame)
		{
			if (_closeFrame != (delegate* unmanaged[Cdecl]<DbLinuxFrame*, void>)null && frame.Fd >= 0)
			{
				_closeFrame(&frame);
			}
		}

		internal unsafe int StartStream(uint nodeId, int fps, int bitrateMbps, int maxResolution, uint adapterVendorId, string encoderPreference, string rtspUrl, bool audioEnabled, int audioSampleRate, int audioChannels, out ulong streamId)
		{
			streamId = 0uL;
			if (!TryLoadStream() || _streamStart == (delegate* unmanaged[Cdecl]<uint, int, int, int, uint, byte*, nuint, byte*, nuint, int, int, int, ulong*, int>)null)
			{
				return -1;
			}
			byte[] array = (string.IsNullOrEmpty(encoderPreference) ? Encoding.UTF8.GetBytes("auto") : Encoding.UTF8.GetBytes(encoderPreference));
			byte[] array2 = (string.IsNullOrEmpty(rtspUrl) ? global::System.Array.Empty<byte>() : Encoding.UTF8.GetBytes(rtspUrl));
			fixed (byte* ptr = array)
			{
				fixed (byte* ptr2 = array2)
				{
					ulong num = 0uL;
					int result = _streamStart(nodeId, fps, bitrateMbps, maxResolution, adapterVendorId, ptr, (nuint)array.LongLength, ptr2, (nuint)array2.LongLength, audioEnabled ? 1 : 0, audioSampleRate, audioChannels, &num);
					streamId = num;
					return result;
				}
			}
		}

		internal unsafe int StartAudioCapture(out ulong captureId)
		{
			captureId = 0uL;
			if (!TryLoad() || _audioStart == (delegate* unmanaged[Cdecl]<ulong*, int>)null)
			{
				return -1;
			}
			ulong num = 0uL;
			int result = _audioStart(&num);
			captureId = num;
			return result;
		}

		internal unsafe int PollAudio(ulong captureId, float[] buffer)
		{
			if (!TryLoad() || _audioPoll == (delegate* unmanaged[Cdecl]<ulong, float*, int, int>)null || captureId == 0L || buffer == null || buffer.Length == 0)
			{
				return 0;
			}
			fixed (float* ptr = buffer)
			{
				return _audioPoll(captureId, ptr, buffer.Length);
			}
		}

		internal unsafe void StopAudioCapture(ulong captureId)
		{
			if (_audioStop != (delegate* unmanaged[Cdecl]<ulong, void>)null && captureId != 0L)
			{
				_audioStop(captureId);
			}
		}

		internal unsafe int PushStreamAudio(ulong streamId, float[] buffer, int frameCount)
		{
			if (!TryLoadStream() || _streamPushAudio == (delegate* unmanaged[Cdecl]<ulong, float*, int, int>)null || streamId == 0L || buffer == null || frameCount <= 0)
			{
				return -1;
			}
			fixed (float* ptr = buffer)
			{
				return _streamPushAudio(streamId, ptr, frameCount);
			}
		}

		internal unsafe int ReadStream(ulong streamId, byte[] destination, ref long readPos, ref bool aligned, long minimumKeyframePos, out bool keyframeAligned)
		{
			keyframeAligned = aligned;
			if (!TryLoadStream() || _streamRead == (delegate* unmanaged[Cdecl]<ulong, byte*, int, long*, int*, long, int*, int*, int>)null || streamId == 0L || destination == null || destination.Length == 0)
			{
				return 0;
			}
			int num = (aligned ? 1 : 0);
			int num2 = (keyframeAligned ? 1 : 0);
			int result = 0;
			long num3 = readPos;
			fixed (byte* ptr = destination)
			{
				int num4 = _streamRead(streamId, ptr, destination.Length, &num3, &num, minimumKeyframePos, &num2, &result);
				readPos = num3;
				aligned = num != 0;
				keyframeAligned = num2 != 0;
				if (num4 != 0)
				{
					return 0;
				}
				return result;
			}
		}

		internal unsafe int PushStreamFrame(ulong streamId, DbLinuxFrame frame)
		{
			if (!TryLoadStream() || _streamPushFrame == (delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int>)null || streamId == 0L || frame.Fd < 0)
			{
				return -1;
			}
			return _streamPushFrame(streamId, &frame);
		}

		internal unsafe DbLinuxStreamInfo GetStreamInfo(ulong streamId)
		{
			DbLinuxStreamInfo result = default(DbLinuxStreamInfo);
			if (!TryLoadStream() || _streamInfo == (delegate* unmanaged[Cdecl]<ulong, DbLinuxStreamInfo*, int>)null || streamId == 0L)
			{
				return result;
			}
			_streamInfo(streamId, &result);
			return result;
		}

		internal unsafe void StopStream(ulong streamId)
		{
			if (_streamStop != (delegate* unmanaged[Cdecl]<ulong, void>)null && streamId != 0L)
			{
				_streamStop(streamId);
			}
		}

		private unsafe bool TryLoadStream()
		{
			if (_streamModule != (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			string text = ResolveSiblingNativePath("libdesktopbuddy_linux_stream.so");
			if (string.IsNullOrWhiteSpace(text) || !File.Exists(text))
			{
				Log.Msg("[LinuxNativeBridge] Stream library not found: " + (text ?? "(null)"));
				return false;
			}
			try
			{
				_streamModule = NativeLibrary.Load(text);
				_streamStart = (delegate* unmanaged[Cdecl]<uint, int, int, int, uint, byte*, nuint, byte*, nuint, int, int, int, ulong*, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_start");
				_streamPushFrame = (delegate* unmanaged[Cdecl]<ulong, DbLinuxFrame*, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_push_frame");
				_streamPushAudio = (delegate* unmanaged[Cdecl]<ulong, float*, int, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_push_audio");
				_streamRead = (delegate* unmanaged[Cdecl]<ulong, byte*, int, long*, int*, long, int*, int*, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_read");
				_streamInfo = (delegate* unmanaged[Cdecl]<ulong, DbLinuxStreamInfo*, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_info");
				_streamStop = (delegate* unmanaged[Cdecl]<ulong, void>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_stop");
				_streamLastError = (delegate* unmanaged[Cdecl]<nint>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_stream_last_error");
				_vcamOpen = (delegate* unmanaged[Cdecl]<int, int, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_vcam_open");
				_vcamWrite = (delegate* unmanaged[Cdecl]<int, byte*, int, int>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_vcam_write");
				_vcamClose = (delegate* unmanaged[Cdecl]<int, void>)NativeLibrary.GetExport((global::System.IntPtr)_streamModule, "db_linux_vcam_close");
				Log.Msg("[LinuxNativeBridge] Loaded stream library " + text);
				return true;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[LinuxNativeBridge] Stream library load failed path=" + text + ": " + ex.Message);
				if (_streamModule != (nint)global::System.IntPtr.Zero)
				{
					NativeLibrary.Free((global::System.IntPtr)_streamModule);
					_streamModule = global::System.IntPtr.Zero;
				}
				_streamStart = null;
				_streamPushFrame = null;
				_streamPushAudio = null;
				_streamRead = null;
				_streamInfo = null;
				_streamStop = null;
				_streamLastError = null;
				_vcamOpen = null;
				_vcamWrite = null;
				_vcamClose = null;
				return false;
			}
		}

		internal unsafe int VcamOpen(int width, int height)
		{
			if (!TryLoadStream() || _vcamOpen == (delegate* unmanaged[Cdecl]<int, int, int>)null)
			{
				return -1;
			}
			return _vcamOpen(width, height);
		}

		internal unsafe int VcamWrite(int fd, byte[] data, int length)
		{
			if (_vcamWrite == (delegate* unmanaged[Cdecl]<int, byte*, int, int>)null || fd < 0 || data == null || length <= 0)
			{
				return -1;
			}
			fixed (byte* ptr = data)
			{
				return _vcamWrite(fd, ptr, length);
			}
		}

		internal unsafe void VcamClose(int fd)
		{
			if (_vcamClose != (delegate* unmanaged[Cdecl]<int, void>)null && fd >= 0)
			{
				_vcamClose(fd);
			}
		}

		internal unsafe string GetStreamLastError()
		{
			if (_streamLastError == (delegate* unmanaged[Cdecl]<nint>)null)
			{
				return null;
			}
			try
			{
				nint num = _streamLastError();
				return (num == (nint)global::System.IntPtr.Zero) ? null : Marshal.PtrToStringAnsi((global::System.IntPtr)num);
			}
			catch
			{
				return null;
			}
		}

		private static string ResolveNativePath()
		{
			string environmentVariable = Environment.GetEnvironmentVariable("DESKTOPBUDDY_LINUX_NATIVE");
			if (!string.IsNullOrWhiteSpace(environmentVariable))
			{
				return environmentVariable;
			}
			string text = Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? string.Empty;
			string text2 = Path.Combine(text, "libdesktopbuddy_linux_native.so");
			if (File.Exists(text2))
			{
				return text2;
			}
			try
			{
				return DesktopBuddyRuntimePaths.FindFile("libdesktopbuddy_linux_native.so");
			}
			catch
			{
				return Path.Combine(text, "DesktopBuddyRuntime", "libdesktopbuddy_linux_native.so");
			}
		}

		private static string ResolveSiblingNativePath(string fileName)
		{
			string environmentVariable = Environment.GetEnvironmentVariable("DESKTOPBUDDY_LINUX_STREAM");
			if (fileName == "libdesktopbuddy_linux_stream.so" && !string.IsNullOrWhiteSpace(environmentVariable))
			{
				return environmentVariable;
			}
			string directoryName = Path.GetDirectoryName(ResolveNativePath());
			if (!string.IsNullOrWhiteSpace(directoryName))
			{
				string text = Path.Combine(directoryName, fileName);
				if (File.Exists(text))
				{
					return text;
				}
			}
			string text2 = Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? string.Empty;
			string text3 = Path.Combine(text2, fileName);
			if (File.Exists(text3))
			{
				return text3;
			}
			try
			{
				return DesktopBuddyRuntimePaths.FindFile(fileName);
			}
			catch
			{
				return Path.Combine(text2, "DesktopBuddyRuntime", fileName);
			}
		}

		public unsafe void Dispose()
		{
			if (!_disposed)
			{
				_disposed = true;
				_startNode = null;
				_pollFrame = null;
				_stopCapture = null;
				_captureAlive = null;
				_copyAndCloseFrame = null;
				_closeFrame = null;
				_audioStart = null;
				_audioPoll = null;
				_audioStop = null;
				_inputStart = null;
				_inputMotion = null;
				_inputTouchDown = null;
				_inputTouchMotion = null;
				_inputTouchUp = null;
				_inputScroll = null;
				_inputKey = null;
				_inputStop = null;
				_inputLastError = null;
				_streamStart = null;
				_streamPushFrame = null;
				_streamPushAudio = null;
				_streamRead = null;
				_streamInfo = null;
				_streamStop = null;
				_streamLastError = null;
				_vcamOpen = null;
				_vcamWrite = null;
				_vcamClose = null;
				if (_streamModule != (nint)global::System.IntPtr.Zero)
				{
					NativeLibrary.Free((global::System.IntPtr)_streamModule);
					_streamModule = global::System.IntPtr.Zero;
				}
				if (_module != (nint)global::System.IntPtr.Zero)
				{
					NativeLibrary.Free((global::System.IntPtr)_module);
					_module = global::System.IntPtr.Zero;
				}
			}
		}
	}
	internal struct DbLinuxSelection
	{
		public uint NodeId;

		public uint Width;

		public uint Height;

		public uint IsMonitor;

		public uint RestoreTokenLen;

		[FixedBuffer(typeof(byte), 256)]
		public unsafe fixed byte RestoreToken[256];
	}
	internal struct DbLinuxFrame
	{
		public int Status;

		public int Fd;

		public uint Width;

		public uint Height;

		public uint Fourcc;

		public uint Offset;

		public int Stride;
	}
	internal struct DbLinuxStreamInfo
	{
		public int Running;

		public int Broken;

		public int Width;

		public int Height;

		public long WritePos;

		public long KeyframePos;

		public long Frames;
	}
	internal interface ILinuxPipeWireSelection
	{
		uint PipeWireNodeId { get; }

		ulong InputSessionId { get; }
	}
	internal sealed class LinuxPortalCaptureBackend : IDesktopCaptureBackend, global::System.IDisposable, ILinuxPipeWireSelection
	{
		private bool _running;

		[field: CompilerGenerated]
		public int Width
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public int Height
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public uint PipeWireNodeId
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public ulong InputSessionId
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public bool IsValid => _running;

		public object D3dContextLock => null;

		public nint D3dDevice => global::System.IntPtr.Zero;

		public nint D3dContext => global::System.IntPtr.Zero;

		public nint SharedTexture => global::System.IntPtr.Zero;

		public nint SharedTextureHandle => global::System.IntPtr.Zero;

		public int SharedTextureWidth => 0;

		public int SharedTextureHeight => 0;

		public bool HasCurrentSharedFrame => false;

		public bool IsResizeRecreatePending => false;

		[field: CompilerGenerated]
		public Action<nint, nint, int, int> OnGpuFrame
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		public bool TryInitialCapture()
		{
			if (!LinuxPortalSelectionStore.TryConsume(out var selection))
			{
				Log.Msg("[LinuxPortalCapture] No selected PipeWire stream is pending");
				return false;
			}
			PipeWireNodeId = selection.NodeId;
			InputSessionId = selection.InputSessionId;
			Width = ((selection.Width > 0) ? selection.Width : 1280);
			Height = ((selection.Height > 0) ? selection.Height : 720);
			_running = true;
			Log.Msg($"[LinuxPortalCapture] Using selected PipeWire node={PipeWireNodeId} size={Width}x{Height} inputSession={InputSessionId}");
			return true;
		}

		public void RecreatePoolIfNeeded()
		{
		}

		public void FlushD3dContext()
		{
		}

		public void StopCapture()
		{
			_running = false;
		}

		public void Dispose()
		{
			_running = false;
		}
	}
	internal readonly struct LinuxPortalSelection
	{
		public readonly uint NodeId;

		public readonly int Width;

		public readonly int Height;

		public readonly ulong InputSessionId;

		public LinuxPortalSelection(uint nodeId, int width, int height, ulong inputSessionId = 0uL)
		{
			NodeId = nodeId;
			Width = width;
			Height = height;
			InputSessionId = inputSessionId;
		}
	}
	internal static class LinuxPortalSelectionStore
	{
		private static readonly object Lock = new object();

		private static LinuxPortalSelection? _pending;

		internal static void Set(LinuxPortalSelection selection)
		{
			lock (Lock)
			{
				_pending = selection;
			}
		}

		internal static bool TryConsume(out LinuxPortalSelection selection)
		{
			lock (Lock)
			{
				if (_pending.HasValue)
				{
					selection = _pending.Value;
					_pending = null;
					return true;
				}
			}
			selection = default(LinuxPortalSelection);
			return false;
		}
	}
	internal sealed class SharedTextureBridgeChannel : global::System.IDisposable
	{
		private Messenger _messenger;

		private readonly object _slotStateLock = new object();

		private readonly HashSet<int> _usedSlots = new HashSet<int>();

		private readonly bool[] _slotStopping = new bool[4096];

		private readonly int[] _slotGenerations = new int[4096];

		private readonly bool[] _slotRunning = new bool[4096];

		private readonly int[] _slotWidths = new int[4096];

		private readonly int[] _slotHeights = new int[4096];

		private bool _disposed;

		internal bool IsOpen
		{
			get
			{
				if (_messenger != null)
				{
					return !_disposed;
				}
				return false;
			}
		}

		internal void Open()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if (_messenger == null)
			{
				Messenger.OnWarning += OnWarning;
				Messenger.OnFailure += OnFailure;
				_messenger = new Messenger(SharedTextureBridgeProtocol.OwnerId, true, SharedTextureBridgeProtocol.QueueName, (IMemoryPackerEntityPool)(object)SimpleMemoryPackerPool.Instance, 1048576L);
				RegisterMessages();
				Log.Msg("[SharedTextureBridgeChannel] Opened InterprocessLib queue: " + SharedTextureBridgeProtocol.QueueName);
			}
		}

		private void RegisterMessages()
		{
			_messenger.ReceiveObject<SharedTextureStartMessage>("Start", (Action<SharedTextureStartMessage>)delegate
			{
			});
			_messenger.ReceiveObject<SharedTextureStopMessage>("Stop", (Action<SharedTextureStopMessage>)delegate
			{
			});
			_messenger.ReceiveObject<SharedTextureRunningMessage>("Running", (Action<SharedTextureRunningMessage>)OnRunning);
			_messenger.ReceiveObject<SharedTextureStoppedMessage>("Stopped", (Action<SharedTextureStoppedMessage>)OnStopped);
			_messenger.ReceiveObject<SharedTextureRendererDeviceMessage>("RendererDevice", (Action<SharedTextureRendererDeviceMessage>)OnRendererDevice);
		}

		internal int RegisterTexture(nint sharedTextureHandle, string sharedTextureName, int sharedTextureWidth, int sharedTextureHeight)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (_messenger == null)
			{
				throw new InvalidOperationException("Channel not open");
			}
			int num = -1;
			int num2;
			lock (_slotStateLock)
			{
				for (int i = 0; i < 4096; i++)
				{
					if (!_usedSlots.Contains(i) && !_slotStopping[i])
					{
						num = i;
						break;
					}
				}
				if (num < 0)
				{
					Log.Msg("[SharedTextureBridgeChannel] No free texture slots available");
					return -1;
				}
				_usedSlots.Add(num);
				num2 = ++_slotGenerations[num];
				_slotStopping[num] = false;
				_slotRunning[num] = false;
				_slotWidths[num] = 0;
				_slotHeights[num] = 0;
			}
			QueueStart(num, num2, sharedTextureHandle, sharedTextureName, sharedTextureWidth, sharedTextureHeight);
			Log.Msg($"[SharedTextureBridgeChannel] Registered texture slot={num} gen={num2} name={sharedTextureName} shared=0x{sharedTextureHandle:X} {sharedTextureWidth}x{sharedTextureHeight}");
			return num;
		}

		internal int RegisterLinuxCapture(int widthHint, int heightHint, uint pipeWireNodeId)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (_messenger == null)
			{
				throw new InvalidOperationException("Channel not open");
			}
			int num = -1;
			int num2;
			lock (_slotStateLock)
			{
				for (int i = 0; i < 4096; i++)
				{
					if (!_usedSlots.Contains(i) && !_slotStopping[i])
					{
						num = i;
						break;
					}
				}
				if (num < 0)
				{
					Log.Msg("[SharedTextureBridgeChannel] No free texture slots available for Linux capture");
					return -1;
				}
				_usedSlots.Add(num);
				num2 = ++_slotGenerations[num];
				_slotStopping[num] = false;
				_slotRunning[num] = false;
				_slotWidths[num] = 0;
				_slotHeights[num] = 0;
			}
			QueueStart(num, num2, new global::System.IntPtr(-1), $"DesktopBuddyLinuxCapture:{pipeWireNodeId}", widthHint, heightHint);
			Log.Msg($"[SharedTextureBridgeChannel] Registered Linux capture slot={num} gen={num2} node={pipeWireNodeId} hint={widthHint}x{heightHint}");
			return num;
		}

		internal void StopTexture(int slot)
		{
			Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.StopTexture ENTER slot={slot} disposed={_disposed} messenger={_messenger != null}");
			if (_messenger == null || _disposed || slot < 0 || slot >= 4096)
			{
				return;
			}
			bool flag = false;
			int generation = 0;
			lock (_slotStateLock)
			{
				if (_usedSlots.Contains(slot) && !_slotStopping[slot])
				{
					generation = _slotGenerations[slot];
					_slotStopping[slot] = true;
					_slotRunning[slot] = false;
					_slotWidths[slot] = 0;
					_slotHeights[slot] = 0;
					flag = true;
				}
			}
			if (flag)
			{
				QueueStop(slot, generation);
			}
			Log.Msg($"[SharedTextureBridgeChannel] Stopped texture slot={slot}");
			Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.StopTexture EXIT slot={slot}");
		}

		internal void UpdateTexture(int slot, nint sharedTextureHandle, string sharedTextureName, int sharedTextureWidth, int sharedTextureHeight)
		{
			if (_messenger == null || _disposed || slot < 0 || slot >= 4096)
			{
				return;
			}
			int num;
			lock (_slotStateLock)
			{
				if (!_usedSlots.Contains(slot))
				{
					return;
				}
				num = ++_slotGenerations[slot];
				_slotStopping[slot] = false;
				_slotRunning[slot] = false;
				_slotWidths[slot] = 0;
				_slotHeights[slot] = 0;
			}
			QueueStart(slot, num, sharedTextureHandle, sharedTextureName, sharedTextureWidth, sharedTextureHeight);
			Log.Msg($"[SharedTextureBridgeChannel] Updated texture slot={slot} gen={num} name={sharedTextureName} shared=0x{sharedTextureHandle:X} {sharedTextureWidth}x{sharedTextureHeight}");
		}

		internal bool IsTextureRunning(int slot)
		{
			if (slot < 0 || slot >= 4096)
			{
				return false;
			}
			lock (_slotStateLock)
			{
				return _slotRunning[slot];
			}
		}

		internal bool TryGetTextureSize(int slot, out int width, out int height)
		{
			width = 0;
			height = 0;
			if (slot < 0 || slot >= 4096)
			{
				return false;
			}
			lock (_slotStateLock)
			{
				if (!_slotRunning[slot])
				{
					return false;
				}
				width = _slotWidths[slot];
				height = _slotHeights[slot];
				return width > 0 && height > 0;
			}
		}

		internal bool IsTextureRunning(int slot, int width, int height)
		{
			if (slot < 0 || slot >= 4096)
			{
				return false;
			}
			lock (_slotStateLock)
			{
				return _slotRunning[slot] && _slotWidths[slot] == width && _slotHeights[slot] == height;
			}
		}

		private void QueueStart(int slot, int generation, nint sharedTextureHandle, string sharedTextureName, int sharedTextureWidth, int sharedTextureHeight)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			ThreadPool.QueueUserWorkItem((WaitCallback)delegate
			{
				try
				{
					Messenger messenger = _messenger;
					if (messenger != null && !_disposed)
					{
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.SendStart START slot={slot} gen={generation} name={sharedTextureName} shared=0x{sharedTextureHandle:X}");
						messenger.SendObject<SharedTextureStartMessage>("Start", new SharedTextureStartMessage
						{
							SlotId = slot,
							Generation = generation,
							SharedTextureHandle = ((global::System.IntPtr)sharedTextureHandle).ToInt64(),
							SharedTextureName = sharedTextureName,
							SharedTextureWidth = sharedTextureWidth,
							SharedTextureHeight = sharedTextureHeight
						});
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.SendStart DONE slot={slot} gen={generation}");
					}
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.SendStart ERROR slot={slot} gen={generation}: {ex}");
				}
			});
		}

		private void QueueStop(int slot, int generation)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			ThreadPool.QueueUserWorkItem((WaitCallback)delegate
			{
				try
				{
					Messenger messenger = _messenger;
					if (messenger != null && !_disposed)
					{
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.StopTexture SendObject START slot={slot} gen={generation}");
						messenger.SendObject<SharedTextureStopMessage>("Stop", new SharedTextureStopMessage
						{
							SlotId = slot,
							Generation = generation
						});
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.StopTexture SendObject DONE slot={slot} gen={generation}");
					}
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.StopTexture SendObject ERROR slot={slot} gen={generation}: {ex}");
				}
			});
		}

		private void OnRunning(SharedTextureRunningMessage message)
		{
			try
			{
				if (message == null)
				{
					return;
				}
				int slotId = message.SlotId;
				if (slotId < 0 || slotId >= 4096)
				{
					return;
				}
				string msg;
				lock (_slotStateLock)
				{
					if (!_usedSlots.Contains(slotId) || _slotGenerations[slotId] != message.Generation)
					{
						msg = $"[SharedTextureBridgeChannel] Ignored stale running ack slot={slotId} gen={message.Generation} current={_slotGenerations[slotId]}";
					}
					else
					{
						_slotRunning[slotId] = true;
						_slotWidths[slotId] = message.Width;
						_slotHeights[slotId] = message.Height;
						msg = $"[SharedTextureBridgeChannel] Texture {slotId} gen={message.Generation} running: {message.Width}x{message.Height}";
					}
				}
				Log.Msg(msg);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.OnRunning ERROR: {ex}");
			}
		}

		private void OnStopped(SharedTextureStoppedMessage message)
		{
			try
			{
				if (message == null)
				{
					return;
				}
				int slotId = message.SlotId;
				if (slotId < 0 || slotId >= 4096)
				{
					return;
				}
				string msg;
				lock (_slotStateLock)
				{
					if (_slotGenerations[slotId] != message.Generation)
					{
						msg = $"[SharedTextureBridgeChannel] Ignored stale stopped ack slot={slotId} gen={message.Generation} current={_slotGenerations[slotId]}";
					}
					else
					{
						_usedSlots.Remove(slotId);
						_slotStopping[slotId] = false;
						_slotRunning[slotId] = false;
						_slotWidths[slotId] = 0;
						_slotHeights[slotId] = 0;
						msg = $"[SharedTextureBridgeChannel] Texture {slotId} gen={message.Generation} stopped";
					}
				}
				Log.Msg(msg);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.OnStopped ERROR: {ex}");
			}
		}

		private static void OnRendererDevice(SharedTextureRendererDeviceMessage message)
		{
			try
			{
				if (message != null && message.AdapterLuid != 0L)
				{
					WgcCapture.SetRendererAdapterHint(message.AdapterLuid, (uint)message.VendorId, message.Description);
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[SharedTextureBridgeChannel] Renderer device hint error: {ex}");
			}
		}

		private static void OnWarning(string message)
		{
			Log.Msg("[InterprocessLib] WARN " + message);
		}

		private static void OnFailure(global::System.Exception ex)
		{
			Log.Msg($"[InterprocessLib] ERROR {ex}");
		}

		public void Dispose()
		{
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			int count;
			lock (_slotStateLock)
			{
				count = _usedSlots.Count;
			}
			Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.Dispose ENTER disposed={_disposed} messenger={_messenger != null} slots={count}");
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			List<ValueTuple<int, int>> val = new List<ValueTuple<int, int>>();
			lock (_slotStateLock)
			{
				Enumerator<int> enumerator = _usedSlots.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						int current = enumerator.Current;
						val.Add(new ValueTuple<int, int>(current, _slotGenerations[current]));
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				_usedSlots.Clear();
				global::System.Array.Clear((global::System.Array)_slotStopping, 0, _slotStopping.Length);
				global::System.Array.Clear((global::System.Array)_slotRunning, 0, _slotRunning.Length);
				global::System.Array.Clear((global::System.Array)_slotWidths, 0, _slotWidths.Length);
				global::System.Array.Clear((global::System.Array)_slotHeights, 0, _slotHeights.Length);
			}
			if (_messenger != null)
			{
				Enumerator<ValueTuple<int, int>> enumerator2 = val.GetEnumerator();
				try
				{
					while (enumerator2.MoveNext())
					{
						ValueTuple<int, int> current2 = enumerator2.Current;
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.Dispose SendObject START slot={current2.Item1}");
						try
						{
							_messenger.SendObject<SharedTextureStopMessage>("Stop", new SharedTextureStopMessage
							{
								SlotId = current2.Item1,
								Generation = current2.Item2
							});
						}
						catch
						{
						}
						Log.Msg($"[CleanupTrace] SharedTextureBridgeChannel.Dispose SendObject DONE slot={current2.Item1}");
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
				}
			}
			Log.Msg("[CleanupTrace] SharedTextureBridgeChannel.Dispose Messenger.Dispose START");
			Messenger messenger = _messenger;
			if (messenger != null)
			{
				messenger.Dispose();
			}
			Log.Msg("[CleanupTrace] SharedTextureBridgeChannel.Dispose Messenger.Dispose DONE");
			_messenger = null;
			Messenger.OnWarning -= OnWarning;
			Messenger.OnFailure -= OnFailure;
			Log.Msg("[CleanupTrace] SharedTextureBridgeChannel.Dispose EXIT");
		}
	}
	public sealed class D3D11AverageColorSampler : global::System.IDisposable
	{
		private struct VP_CONTENT_DESC
		{
			public int InputFrameFormat;

			public uint InputFrameRateNum;

			public uint InputFrameRateDen;

			public uint InputWidth;

			public uint InputHeight;

			public uint OutputFrameRateNum;

			public uint OutputFrameRateDen;

			public uint OutputWidth;

			public uint OutputHeight;

			public int Usage;
		}

		private struct VP_INPUT_VIEW_DESC
		{
			public uint FourCC;

			public int ViewDimension;

			public uint MipSlice;

			public uint ArraySlice;
		}

		private struct VP_OUTPUT_VIEW_DESC
		{
			public int ViewDimension;

			public uint MipSlice;

			public uint FirstArraySlice;

			public uint ArraySize;
		}

		private struct VP_STREAM
		{
			public int Enable;

			public uint OutputIndex;

			public uint InputFrameOrField;

			public uint PastFrames;

			public uint FutureFrames;

			private uint _pad;

			public nint ppPastSurfaces;

			public nint pInputSurface;

			public nint ppFutureSurfaces;

			public nint ppPastSurfacesRight;

			public nint pInputSurfaceRight;

			public nint ppFutureSurfacesRight;
		}

		private struct VP_COLOR_SPACE
		{
			public uint Value;
		}

		private struct TEX2D_DESC
		{
			public uint Width;

			public uint Height;

			public uint MipLevels;

			public uint ArraySize;

			public int Format;

			public uint SampleCount;

			public uint SampleQuality;

			public int Usage;

			public uint BindFlags;

			public uint CPUAccessFlags;

			public uint MiscFlags;
		}

		private struct D3D11_MAPPED_SUBRESOURCE
		{
			public nint pData;

			public uint RowPitch;

			public uint DepthPitch;
		}

		private static readonly Guid IID_ID3D11VideoDevice = new Guid(283921755u, (ushort)38746, (ushort)18057, (byte)185, (byte)228, (byte)208, (byte)170, (byte)195, (byte)15, (byte)227, (byte)51);

		private static readonly Guid IID_ID3D11VideoContext = new Guid(1643256901, (short)15374, (short)19060, (byte)156, (byte)234, (byte)103, (byte)16, (byte)13, (byte)154, (byte)213, (byte)228);

		private const int DXGI_FORMAT_B8G8R8A8_UNORM = 87;

		private const int D3D11_USAGE_DEFAULT = 0;

		private const int D3D11_USAGE_STAGING = 3;

		private const uint D3D11_BIND_RENDER_TARGET = 32u;

		private const uint D3D11_CPU_ACCESS_READ = 131072u;

		private const uint D3D11_MAP_READ = 1u;

		private readonly object _gate = new object();

		private nint _device;

		private nint _context;

		private nint _vpDevice;

		private nint _vpContext;

		private nint _vpEnum;

		private nint _vpProcessor;

		private nint _inputTexture;

		private nint _inputView;

		private nint _outputTexture;

		private nint _outputView;

		private nint _stagingTexture;

		private int _width;

		private int _height;

		private bool _disposed;

		public unsafe bool TrySample(nint device, nint context, nint sourceTexture, int width, int height, out colorX color)
		{
			//IL_0017: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			color = new colorX(1f, 1f, 1f, 1f, (ColorProfile)1);
			if (device == (nint)global::System.IntPtr.Zero || context == (nint)global::System.IntPtr.Zero || sourceTexture == (nint)global::System.IntPtr.Zero || width <= 0 || height <= 0)
			{
				return false;
			}
			lock (_gate)
			{
				if (_disposed)
				{
					return false;
				}
				EnsureResources(device, context, width, height);
				CopyResource(context, _inputTexture, sourceTexture);
				VP_STREAM vP_STREAM = new VP_STREAM
				{
					Enable = 1,
					OutputIndex = 0u,
					InputFrameOrField = 0u,
					PastFrames = 0u,
					FutureFrames = 0u,
					pInputSurface = _inputView
				};
				int num = ((delegate* unmanaged[Stdcall]<nint, nint, nint, uint, uint, VP_STREAM*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_vpContext) + (nint)53 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, _outputView, 0u, 1u, &vP_STREAM);
				if (num < 0)
				{
					throw new InvalidOperationException($"VideoProcessorBlt failed hr=0x{num:X8}");
				}
				CopyResource(context, _stagingTexture, _outputTexture);
				return ReadStagingPixel(context, _stagingTexture, out color);
			}
		}

		private unsafe void EnsureResources(nint device, nint context, int width, int height)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			if (_device != device || _context != context || _width != width || _height != height || _inputTexture == (nint)global::System.IntPtr.Zero)
			{
				ReleaseResources();
				_device = device;
				_context = context;
				_width = width;
				_height = height;
				Guid iID_ID3D11VideoDevice = IID_ID3D11VideoDevice;
				Guid iID_ID3D11VideoContext = IID_ID3D11VideoContext;
				int num = Marshal.QueryInterface((global::System.IntPtr)device, ref iID_ID3D11VideoDevice, ref _vpDevice);
				if (num < 0)
				{
					throw new InvalidOperationException($"QueryInterface ID3D11VideoDevice failed hr=0x{num:X8}");
				}
				num = Marshal.QueryInterface((global::System.IntPtr)context, ref iID_ID3D11VideoContext, ref _vpContext);
				if (num < 0)
				{
					throw new InvalidOperationException($"QueryInterface ID3D11VideoContext failed hr=0x{num:X8}");
				}
				VP_CONTENT_DESC vP_CONTENT_DESC = new VP_CONTENT_DESC
				{
					InputFrameFormat = 0,
					InputFrameRateNum = 30u,
					InputFrameRateDen = 1u,
					InputWidth = (uint)width,
					InputHeight = (uint)height,
					OutputFrameRateNum = 30u,
					OutputFrameRateDen = 1u,
					OutputWidth = 1u,
					OutputHeight = 1u,
					Usage = 1
				};
				nint vpDevice = *(nint*)_vpDevice;
				num = ((delegate* unmanaged[Stdcall]<nint, VP_CONTENT_DESC*, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)10 * (nint)sizeof(nint))))(_vpDevice, &vP_CONTENT_DESC, ref _vpEnum);
				if (num < 0)
				{
					throw new InvalidOperationException($"CreateVideoProcessorEnumerator failed hr=0x{num:X8}");
				}
				num = ((delegate* unmanaged[Stdcall]<nint, nint, uint, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)4 * (nint)sizeof(nint))))(_vpDevice, _vpEnum, 0u, ref _vpProcessor);
				if (num < 0)
				{
					throw new InvalidOperationException($"CreateVideoProcessor failed hr=0x{num:X8}");
				}
				_inputTexture = CreateTexture2D(device, (uint)width, (uint)height, 0, 32u, 0u);
				_outputTexture = CreateTexture2D(device, 1u, 1u, 0, 32u, 0u);
				_stagingTexture = CreateTexture2D(device, 1u, 1u, 3, 0u, 131072u);
				VP_INPUT_VIEW_DESC vP_INPUT_VIEW_DESC = new VP_INPUT_VIEW_DESC
				{
					FourCC = 0u,
					ViewDimension = 1,
					MipSlice = 0u,
					ArraySlice = 0u
				};
				num = ((delegate* unmanaged[Stdcall]<nint, nint, nint, VP_INPUT_VIEW_DESC*, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)8 * (nint)sizeof(nint))))(_vpDevice, _inputTexture, _vpEnum, &vP_INPUT_VIEW_DESC, ref _inputView);
				if (num < 0)
				{
					throw new InvalidOperationException($"CreateVideoProcessorInputView failed hr=0x{num:X8}");
				}
				VP_OUTPUT_VIEW_DESC vP_OUTPUT_VIEW_DESC = new VP_OUTPUT_VIEW_DESC
				{
					ViewDimension = 1,
					MipSlice = 0u,
					FirstArraySlice = 0u,
					ArraySize = 1u
				};
				num = ((delegate* unmanaged[Stdcall]<nint, nint, nint, VP_OUTPUT_VIEW_DESC*, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)9 * (nint)sizeof(nint))))(_vpDevice, _outputTexture, _vpEnum, &vP_OUTPUT_VIEW_DESC, ref _outputView);
				if (num < 0)
				{
					throw new InvalidOperationException($"CreateVideoProcessorOutputView failed hr=0x{num:X8}");
				}
				nint vpContext = *(nint*)_vpContext;
				VP_COLOR_SPACE vP_COLOR_SPACE = new VP_COLOR_SPACE
				{
					Value = 0u
				};
				((delegate* unmanaged[Stdcall]<nint, nint, VP_COLOR_SPACE*, void>)(*(global::System.IntPtr*)(vpContext + (nint)15 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, &vP_COLOR_SPACE);
				((delegate* unmanaged[Stdcall]<nint, nint, uint, int, void>)(*(global::System.IntPtr*)(vpContext + (nint)27 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, 0u, 0);
				((delegate* unmanaged[Stdcall]<nint, nint, uint, VP_COLOR_SPACE*, void>)(*(global::System.IntPtr*)(vpContext + (nint)28 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, 0u, &vP_COLOR_SPACE);
			}
		}

		private unsafe static nint CreateTexture2D(nint device, uint width, uint height, int usage, uint bindFlags, uint cpuAccessFlags)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			TEX2D_DESC tEX2D_DESC = new TEX2D_DESC
			{
				Width = width,
				Height = height,
				MipLevels = 1u,
				ArraySize = 1u,
				Format = 87,
				SampleCount = 1u,
				SampleQuality = 0u,
				Usage = usage,
				BindFlags = bindFlags,
				CPUAccessFlags = cpuAccessFlags,
				MiscFlags = 0u
			};
			nint result = default(nint);
			int num = ((delegate* unmanaged[Stdcall]<nint, TEX2D_DESC*, nint, ref nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)device) + (nint)5 * (nint)sizeof(nint))))(device, &tEX2D_DESC, global::System.IntPtr.Zero, ref result);
			if (num < 0)
			{
				throw new InvalidOperationException($"CreateTexture2D {width}x{height} failed hr=0x{num:X8}");
			}
			return result;
		}

		private unsafe static void CopyResource(nint context, nint dst, nint src)
		{
			((delegate* unmanaged[Stdcall]<nint, nint, nint, void>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)context) + (nint)47 * (nint)sizeof(nint))))(context, dst, src);
		}

		private unsafe static bool ReadStagingPixel(nint context, nint stagingTexture, out colorX color)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			color = new colorX(1f, 1f, 1f, 1f, (ColorProfile)1);
			nint num = *(nint*)context;
			delegate* unmanaged[Stdcall]<nint, nint, uint, uint, uint, D3D11_MAPPED_SUBRESOURCE*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, nint, uint, uint, uint, D3D11_MAPPED_SUBRESOURCE*, int>)(*(global::System.IntPtr*)(num + (nint)14 * (nint)sizeof(nint)));
			delegate* unmanaged[Stdcall]<nint, nint, uint, void> delegate*2 = (delegate* unmanaged[Stdcall]<nint, nint, uint, void>)(*(global::System.IntPtr*)(num + (nint)15 * (nint)sizeof(nint)));
			D3D11_MAPPED_SUBRESOURCE d3D11_MAPPED_SUBRESOURCE = default(D3D11_MAPPED_SUBRESOURCE);
			int num2 = delegate*(context, stagingTexture, 0u, 1u, 0u, &d3D11_MAPPED_SUBRESOURCE);
			if (num2 < 0)
			{
				throw new InvalidOperationException($"Map 1x1 staging texture failed hr=0x{num2:X8}");
			}
			try
			{
				byte* pData = (byte*)d3D11_MAPPED_SUBRESOURCE.pData;
				color = new colorX((float)(int)pData[2] / 255f, (float)(int)pData[1] / 255f, (float)(int)(*pData) / 255f, 1f, (ColorProfile)1);
				return true;
			}
			finally
			{
				delegate*2(context, stagingTexture, 0u);
			}
		}

		public void Dispose()
		{
			lock (_gate)
			{
				if (!_disposed)
				{
					_disposed = true;
					ReleaseResources();
				}
			}
		}

		private void ReleaseResources()
		{
			Release(ref _stagingTexture);
			Release(ref _outputView);
			Release(ref _outputTexture);
			Release(ref _inputView);
			Release(ref _inputTexture);
			Release(ref _vpProcessor);
			Release(ref _vpEnum);
			Release(ref _vpContext);
			Release(ref _vpDevice);
			_width = 0;
			_height = 0;
			_device = global::System.IntPtr.Zero;
			_context = global::System.IntPtr.Zero;
		}

		private static void Release(ref nint ptr)
		{
			if (ptr != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)ptr);
				ptr = global::System.IntPtr.Zero;
			}
		}
	}
	public sealed class WgcCapture : global::System.IDisposable
	{
		internal readonly struct GpuAdapterInfo
		{
			public readonly string Name;

			public readonly uint VendorId;

			public readonly long Luid;

			public readonly ulong DedicatedVideoMemoryBytes;

			public readonly bool IsBasicRenderDriver;

			public GpuAdapterInfo(string name, uint vendorId, long luid, ulong dedicatedVideoMemoryBytes, bool isBasicRenderDriver)
			{
				Name = name;
				VendorId = vendorId;
				Luid = luid;
				DedicatedVideoMemoryBytes = dedicatedVideoMemoryBytes;
				IsBasicRenderDriver = isBasicRenderDriver;
			}

			public string ToString()
			{
				return $"{Name} VendorId=0x{VendorId:X4} VRAM={DedicatedVideoMemoryBytes / 1048576}MB LUID=0x{Luid:X16}";
			}
		}

		[ComImport]
		[Guid("3628E81B-3CAC-4C60-B7F4-23CE0E0C3356")]
		[InterfaceType(/*Could not decode attribute arguments.*/)]
		private interface IGraphicsCaptureItemInterop
		{
			nint CreateForWindow([In] nint window, [In] ref Guid iid);

			nint CreateForMonitor([In] nint monitor, [In] ref Guid iid);
		}

		[ComImport]
		[Guid("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1")]
		[InterfaceType(/*Could not decode attribute arguments.*/)]
		private interface IDirect3DDxgiInterfaceAccess
		{
			nint GetInterface([In] ref Guid iid);
		}

		[StructLayout((LayoutKind)0, CharSet = (CharSet)3)]
		private struct DXGI_ADAPTER_DESC
		{
			[FixedBuffer(typeof(char), 128)]
			public unsafe fixed char Description[128];

			public uint VendorId;

			public uint DeviceId;

			public uint SubSysId;

			public uint Revision;

			public nuint DedicatedVideoMemory;

			public nuint DedicatedSystemMemory;

			public nuint SharedSystemMemory;

			public long AdapterLuid;
		}

		private struct DXGI_SAMPLE_DESC
		{
			public uint Count;

			public uint Quality;
		}

		private struct D3D11_TEXTURE2D_DESC
		{
			public uint Width;

			public uint Height;

			public uint MipLevels;

			public uint ArraySize;

			public uint Format;

			public DXGI_SAMPLE_DESC SampleDesc;

			public uint Usage;

			public uint BindFlags;

			public uint CPUAccessFlags;

			public uint MiscFlags;
		}

		private static uint _preferredD3dAdapterVendorId;

		private static readonly object _captureInteropLock = new object();

		private static IGraphicsCaptureItemInterop _captureInterop;

		private const int IDXGIFactory_EnumAdapters = 7;

		private const int IDXGIFactory6_EnumAdapterByGpuPreference = 29;

		private const int IDXGIAdapter_GetDesc = 8;

		private const uint DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE = 2u;

		private const uint MicrosoftBasicRenderDriverVendorId = 5140u;

		private const int D3D_DRIVER_TYPE_UNKNOWN = 0;

		private const int D3D_DRIVER_TYPE_HARDWARE = 1;

		private const uint D3D11_CREATE_DEVICE_BGRA_SUPPORT = 32u;

		private const int ID3D11DeviceContext_Flush = 111;

		private const int ID3D11Device_CreateTexture2D = 5;

		private const int ID3D11DeviceContext_CopyResource = 47;

		private const uint DXGI_FORMAT_B8G8R8A8_TYPELESS = 90u;

		private const uint D3D11_USAGE_DEFAULT = 0u;

		private const uint D3D11_BIND_SHADER_RESOURCE = 8u;

		private const uint D3D11_RESOURCE_MISC_SHARED = 2u;

		private static nint _cachedPreferredAdapter = global::System.IntPtr.Zero;

		private static uint _cachedPreferredAdapterVendorId;

		private static long _cachedPreferredAdapterLuid;

		private static bool _adapterCacheReady;

		private static bool _rendererAdapterHintReady;

		private static long _rendererAdapterHintLuid;

		private static uint _rendererAdapterHintVendorId;

		private static string _rendererAdapterHintDescription;

		private static readonly object _adapterCacheLock = new object();

		public Action<nint, nint, int, int> OnGpuFrame;

		private nint _hwnd;

		private bool _isDesktop;

		private readonly object _d3dLock = new object();

		private IDirect3DDevice _winrtDevice;

		private nint _d3dDevice;

		private nint _d3dContext;

		private GraphicsCaptureItem _item;

		private Direct3D11CaptureFramePool _framePool;

		private GraphicsCaptureSession _session;

		private TypedEventHandler<GraphicsCaptureItem, object> _itemClosedHandler;

		private volatile bool _closed;

		private int _framesCaptured;

		private int _sharedFramesCopied;

		private volatile bool _disposed;

		private volatile bool _needsPoolRecreate;

		private readonly object _resizeRecreateLock = new object();

		private int _resizeRecreateWorkerRunning;

		private int _resizeTargetWidth;

		private int _resizeTargetHeight;

		private static readonly Guid DxgiAccessGuid = new Guid("A9B3D012-3DF2-4EE3-B8D1-8695F457D3C1");

		private static readonly Guid TexGuid = new Guid("6f15aaf2-d208-4e89-9ab4-489535d34f9c");

		private static readonly Guid DxgiResourceGuid = new Guid("035F3AB4-482E-4E50-B41F-8A7F8BD8960B");

		private static int _wgcResizeLogCounter;

		private readonly object _disposeLock = new object();

		private readonly ManualResetEventSlim _frameCallbacksDrained = new ManualResetEventSlim(true);

		private int _activeFrameCallbacks;

		private int _frameProcessing;

		private int _d3dBusyFrameDrops;

		private int _frameBusyDrops;

		private nint _sharedTexture;

		internal static bool SharedD3dDeviceInitialized => _adapterCacheReady;

		internal static long SharedD3dAdapterLuid => _cachedPreferredAdapterLuid;

		internal static bool HasRendererAdapterHint
		{
			get
			{
				lock (_adapterCacheLock)
				{
					return _rendererAdapterHintReady && _rendererAdapterHintLuid != 0;
				}
			}
		}

		internal static uint RendererAdapterHintVendorId
		{
			get
			{
				lock (_adapterCacheLock)
				{
					return _rendererAdapterHintReady ? _rendererAdapterHintVendorId : 0u;
				}
			}
		}

		public nint D3dContext => _d3dContext;

		[field: CompilerGenerated]
		public int Width
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public int Height
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public int FramesCaptured => _framesCaptured;

		public bool HasCurrentSharedFrame
		{
			get
			{
				if (_sharedFramesCopied > 0)
				{
					return !_needsPoolRecreate;
				}
				return false;
			}
		}

		public bool IsResizeRecreatePending => _needsPoolRecreate;

		public nint D3dDevice => _d3dDevice;

		public nint SharedTexture => _sharedTexture;

		[field: CompilerGenerated]
		public nint SharedTextureHandle
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public int SharedTextureWidth
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		[field: CompilerGenerated]
		public int SharedTextureHeight
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		public bool IsValid
		{
			get
			{
				if (!_disposed && !_closed && _item != (GraphicsCaptureItem)null)
				{
					if (!_isDesktop)
					{
						if (IsWindow(_hwnd))
						{
							return !IsIconic(_hwnd);
						}
						return false;
					}
					return true;
				}
				return false;
			}
		}

		internal static uint SharedD3dAdapterVendorId
		{
			get
			{
				EnsurePreferredAdapterCached();
				return _preferredD3dAdapterVendorId;
			}
		}

		public object D3dContextLock => _d3dLock;

		public void StopCapture()
		{
			Log.Msg($"[CleanupTrace] WgcCapture.StopCapture ENTER hwnd={_hwnd} disposed={_disposed}");
			GraphicsCaptureSession session;
			Direct3D11CaptureFramePool framePool;
			GraphicsCaptureItem item;
			TypedEventHandler<GraphicsCaptureItem, object> itemClosedHandler;
			lock (_disposeLock)
			{
				Log.Msg($"[CleanupTrace] WgcCapture.StopCapture dispose lock ACQUIRED hwnd={_hwnd}");
				if (_disposed)
				{
					return;
				}
				_disposed = true;
				session = _session;
				framePool = _framePool;
				item = _item;
				itemClosedHandler = _itemClosedHandler;
				_session = null;
				_framePool = null;
				_itemClosedHandler = null;
			}
			Log.Msg($"[WgcCapture:StopCapture] Stopping session hwnd={_hwnd}");
			Log.Msg($"[CleanupTrace] WgcCapture.StopCapture unhook FrameArrived START hwnd={_hwnd}");
			try
			{
				if (framePool != (Direct3D11CaptureFramePool)null)
				{
					framePool.FrameArrived -= OnFrameArrived;
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCapture:StopCapture] Unhook error: " + ex.Message);
			}
			Log.Msg($"[CleanupTrace] WgcCapture.StopCapture unhook ItemClosed START hwnd={_hwnd}");
			try
			{
				if (item != (GraphicsCaptureItem)null && itemClosedHandler != null)
				{
					item.Closed -= itemClosedHandler;
				}
			}
			catch (global::System.Exception ex2)
			{
				Log.Msg("[WgcCapture:StopCapture] Item closed unhook error: " + ex2.Message);
			}
			WaitForFrameCallbacksToDrain("StopCapture");
			DisposeCaptureObjects(session, framePool, "StopCapture");
			Log.Msg("[WgcCapture:StopCapture] Session stopped, events unhooked/disposed");
			Log.Msg($"[CleanupTrace] WgcCapture.StopCapture EXIT hwnd={_hwnd}");
		}

		public void Dispose()
		{
			Log.Msg($"[CleanupTrace] WgcCapture.Dispose ENTER hwnd={_hwnd} disposed={_disposed}");
			bool disposed;
			GraphicsCaptureSession session;
			Direct3D11CaptureFramePool framePool;
			GraphicsCaptureItem item;
			TypedEventHandler<GraphicsCaptureItem, object> itemClosedHandler;
			lock (_disposeLock)
			{
				Log.Msg($"[CleanupTrace] WgcCapture.Dispose dispose lock ACQUIRED hwnd={_hwnd}");
				disposed = _disposed;
				_disposed = true;
				session = _session;
				framePool = _framePool;
				item = _item;
				itemClosedHandler = _itemClosedHandler;
				_session = null;
				_framePool = null;
				_itemClosedHandler = null;
			}
			if (!disposed)
			{
				Log.Msg("[WgcCapture:Dispose] Unhooking events");
				try
				{
					if (framePool != (Direct3D11CaptureFramePool)null)
					{
						framePool.FrameArrived -= OnFrameArrived;
					}
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[WgcCapture:Dispose] Unhook error: " + ex.Message);
				}
				try
				{
					if (item != (GraphicsCaptureItem)null && itemClosedHandler != null)
					{
						item.Closed -= itemClosedHandler;
					}
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg("[WgcCapture:Dispose] Item closed unhook error: " + ex2.Message);
				}
				WaitForFrameCallbacksToDrain("Dispose");
				DisposeCaptureObjects(session, framePool, "Dispose");
			}
			_item = null;
			OnGpuFrame = null;
			if (!_frameCallbacksDrained.IsSet && !WaitForFrameCallbacksToDrain("Dispose"))
			{
				Log.Msg($"[CleanupTrace] WgcCapture.Dispose EXIT without D3D release hwnd={_hwnd}");
				return;
			}
			Log.Msg($"[CleanupTrace] WgcCapture.Dispose ReleaseSharedTexture START hwnd={_hwnd}");
			ReleaseSharedTexture();
			Log.Msg($"[CleanupTrace] WgcCapture.Dispose ReleaseD3dDevice START hwnd={_hwnd}");
			lock (_d3dLock)
			{
				ReleaseD3dDevice();
			}
			Log.Msg($"[WgcCapture:Dispose] Released D3D device hwnd={_hwnd}");
			Log.Msg($"[CleanupTrace] WgcCapture.Dispose EXIT hwnd={_hwnd}");
		}

		private static void DisposeCaptureObjects(GraphicsCaptureSession session, Direct3D11CaptureFramePool framePool, string reason)
		{
			try
			{
				if (session != null)
				{
					session.Dispose();
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCapture:" + reason + "] Session dispose error: " + ex.Message);
			}
			try
			{
				if (framePool != null)
				{
					framePool.Dispose();
				}
			}
			catch (global::System.Exception ex2)
			{
				Log.Msg("[WgcCapture:" + reason + "] FramePool dispose error: " + ex2.Message);
			}
		}

		[DllImport("user32.dll")]
		private static extern bool IsWindow(nint hWnd);

		[DllImport("user32.dll")]
		private static extern bool IsIconic(nint hWnd);

		[DllImport("d3d11.dll")]
		private static extern int D3D11CreateDevice(nint pAdapter, int DriverType, nint Software, uint Flags, nint pFeatureLevels, uint FeatureLevels, uint SDKVersion, out nint ppDevice, out int pFeatureLevel, out nint ppImmediateContext);

		[DllImport("dxgi.dll")]
		private static extern int CreateDXGIFactory1(ref Guid riid, out nint ppFactory);

		internal static void SetRendererAdapterHint(long adapterLuid, uint vendorId, string description)
		{
			if (adapterLuid == 0L)
			{
				return;
			}
			bool flag;
			lock (_adapterCacheLock)
			{
				flag = !_rendererAdapterHintReady || _rendererAdapterHintLuid != adapterLuid;
				_rendererAdapterHintReady = true;
				_rendererAdapterHintLuid = adapterLuid;
				_rendererAdapterHintVendorId = vendorId;
				_rendererAdapterHintDescription = description;
				if (_adapterCacheReady && _cachedPreferredAdapterLuid != adapterLuid)
				{
					if (_cachedPreferredAdapter != (nint)global::System.IntPtr.Zero)
					{
						try
						{
							Marshal.Release((global::System.IntPtr)_cachedPreferredAdapter);
						}
						catch
						{
						}
					}
					_cachedPreferredAdapter = global::System.IntPtr.Zero;
					_cachedPreferredAdapterVendorId = 0u;
					_cachedPreferredAdapterLuid = 0L;
					_adapterCacheReady = false;
					_preferredD3dAdapterVendorId = 0u;
				}
			}
			if (flag)
			{
				Log.Msg($"[WgcCapture] Renderer adapter hint: '{description}' VendorId=0x{vendorId:X4} LUID=0x{adapterLuid:X16}");
			}
		}

		public void RecreatePoolIfNeeded()
		{
			if (_needsPoolRecreate && !_disposed)
			{
				if (_updateCountForLogging() % 30 == 0)
				{
					Log.Msg($"[WgcCapture] Resize recreate pending hwnd={_hwnd} target={_resizeTargetWidth}x{_resizeTargetHeight} worker={_resizeRecreateWorkerRunning}");
				}
				QueuePoolRecreateWorker();
			}
		}

		private void RequestPoolRecreate(int width, int height)
		{
			if (width > 0 && height > 0 && !_disposed)
			{
				Width = width;
				Height = height;
				_sharedFramesCopied = 0;
				lock (_resizeRecreateLock)
				{
					_resizeTargetWidth = width;
					_resizeTargetHeight = height;
					_needsPoolRecreate = true;
				}
				Log.Msg($"[WgcCapture] Resize recreate requested hwnd={_hwnd} target={width}x{height} worker={_resizeRecreateWorkerRunning}");
				QueuePoolRecreateWorker();
			}
		}

		private void QueuePoolRecreateWorker()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			if (Interlocked.CompareExchange(ref _resizeRecreateWorkerRunning, 1, 0) != 0)
			{
				Log.Msg($"[WgcCapture] Resize recreate worker already running hwnd={_hwnd} target={_resizeTargetWidth}x{_resizeTargetHeight}");
				return;
			}
			Log.Msg($"[WgcCapture] Resize recreate worker queued hwnd={_hwnd} target={_resizeTargetWidth}x{_resizeTargetHeight}");
			ThreadPool.QueueUserWorkItem((WaitCallback)([CompilerGenerated] (object? _) =>
			{
				RunPoolRecreateWorker();
			}));
		}

		private void RunPoolRecreateWorker()
		{
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			Log.Msg($"[WgcCapture] Resize recreate worker START hwnd={_hwnd}");
			try
			{
				while (!_disposed)
				{
					int resizeTargetWidth;
					int resizeTargetHeight;
					lock (_resizeRecreateLock)
					{
						if (!_needsPoolRecreate)
						{
							break;
						}
						resizeTargetWidth = _resizeTargetWidth;
						resizeTargetHeight = _resizeTargetHeight;
					}
					if (resizeTargetWidth <= 0 || resizeTargetHeight <= 0)
					{
						Log.Msg($"[WgcCapture] Resize recreate worker ignored invalid target hwnd={_hwnd} target={resizeTargetWidth}x{resizeTargetHeight}");
						break;
					}
					if (!TryEnterCaptureResourceUse())
					{
						Log.Msg($"[WgcCapture] Resize recreate worker could not enter resource use hwnd={_hwnd} disposed={_disposed}");
						break;
					}
					try
					{
						Direct3D11CaptureFramePool framePool;
						IDirect3DDevice winrtDevice;
						lock (_disposeLock)
						{
							if (_disposed)
							{
								break;
							}
							framePool = _framePool;
							winrtDevice = _winrtDevice;
						}
						if (framePool == (Direct3D11CaptureFramePool)null || winrtDevice == null)
						{
							Log.Msg($"[WgcCapture] Resize recreate worker missing capture resources hwnd={_hwnd} pool={framePool != (Direct3D11CaptureFramePool)null} device={winrtDevice != null}");
							break;
						}
						long timestamp = Stopwatch.GetTimestamp();
						Log.Msg($"[WgcCapture] FramePool.Recreate START {resizeTargetWidth}x{resizeTargetHeight} hwnd={_hwnd}");
						framePool.Recreate(winrtDevice, (DirectXPixelFormat)87, 2, new SizeInt32
						{
							Width = resizeTargetWidth,
							Height = resizeTargetHeight
						});
						double num = (double)(Stopwatch.GetTimestamp() - timestamp) * 1000.0 / (double)Stopwatch.Frequency;
						Log.Msg($"[WgcCapture] FramePool.Recreate DONE {resizeTargetWidth}x{resizeTargetHeight} hwnd={_hwnd} {num:F2}ms");
						bool flag = TryCreateSharedTexture(resizeTargetWidth, resizeTargetHeight);
						lock (_resizeRecreateLock)
						{
							if (_resizeTargetWidth == resizeTargetWidth && _resizeTargetHeight == resizeTargetHeight)
							{
								_needsPoolRecreate = false;
							}
						}
						Log.Msg(flag ? $"[WgcCapture] FramePool/shared texture recreated for {resizeTargetWidth}x{resizeTargetHeight}" : $"[WgcCapture] FramePool recreated but shared texture was not ready for {resizeTargetWidth}x{resizeTargetHeight}");
						lock (_resizeRecreateLock)
						{
							if (!_needsPoolRecreate)
							{
								break;
							}
						}
					}
					catch (global::System.Exception ex)
					{
						lock (_resizeRecreateLock)
						{
							_needsPoolRecreate = false;
						}
						Log.Msg($"[WgcCapture] FramePool.Recreate failed: {ex}");
						break;
					}
					finally
					{
						LeaveCaptureResourceUse();
					}
				}
			}
			finally
			{
				Log.Msg($"[WgcCapture] Resize recreate worker EXIT hwnd={_hwnd} needs={_needsPoolRecreate} disposed={_disposed}");
				Interlocked.Exchange(ref _resizeRecreateWorkerRunning, 0);
				if (_needsPoolRecreate && !_disposed)
				{
					QueuePoolRecreateWorker();
				}
			}
		}

		private static int _updateCountForLogging()
		{
			return Interlocked.Increment(ref _wgcResizeLogCounter);
		}

		public bool Init(nint hwnd, nint monitorHandle = 0)
		{
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			_hwnd = hwnd;
			_isDesktop = hwnd == (nint)global::System.IntPtr.Zero;
			try
			{
				Log.Msg($"[WgcCapture] Init starting hwnd={hwnd} monitor=0x{monitorHandle:X}");
				if (!CreateD3dDevice())
				{
					return false;
				}
				Log.Msg($"[WgcCapture] D3D ready for hwnd={hwnd} device=0x{_d3dDevice:X}");
				if (hwnd == (nint)global::System.IntPtr.Zero)
				{
					nint num = ((monitorHandle != 0) ? monitorHandle : MonitorFromPoint(0, 0, 1u));
					Log.Msg($"[WgcCapture] Creating capture for monitor 0x{num:X} (explicit={monitorHandle != 0})");
					_item = CreateItemForMonitor(num);
				}
				else
				{
					Log.Msg($"[WgcCapture] Creating capture for window 0x{hwnd:X}");
					_item = CreateItemForWindow(hwnd);
				}
				if (_item == (GraphicsCaptureItem)null)
				{
					Log.Msg("[WgcCapture] CaptureItem is null");
					return false;
				}
				Log.Msg($"[WgcCapture] CaptureItem ready: {_item.Size.Width}x{_item.Size.Height}, hwnd={hwnd}");
				_itemClosedHandler = [CompilerGenerated] (GraphicsCaptureItem _, object _) =>
				{
					_closed = true;
				};
				_item.Closed += _itemClosedHandler;
				Width = _item.Size.Width;
				Height = _item.Size.Height;
				Log.Msg($"[WgcCapture] Creating shared texture {Width}x{Height}, hwnd={hwnd}");
				if (!TryCreateSharedTexture(Width, Height))
				{
					Log.Msg($"[WgcCapture] Init failed: shared texture unavailable hwnd={hwnd}");
					return false;
				}
				Log.Msg($"[WgcCapture] Creating frame pool {Width}x{Height}, hwnd={hwnd}");
				_framePool = Direct3D11CaptureFramePool.CreateFreeThreaded(_winrtDevice, (DirectXPixelFormat)87, 2, _item.Size);
				_framePool.FrameArrived += OnFrameArrived;
				Log.Msg($"[WgcCapture] Creating capture session hwnd={hwnd}");
				_session = _framePool.CreateCaptureSession(_item);
				try
				{
					_session.IsBorderRequired = false;
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[WgcCapture] IsBorderRequired not supported (Win11+ only): " + ex.Message);
				}
				TrySetIncludeSecondaryWindows(_session);
				_session.IsCursorCaptureEnabled = true;
				Log.Msg($"[WgcCapture] Starting capture hwnd={hwnd}");
				_session.StartCapture();
				Log.Msg($"[WgcCapture] Init complete: {Width}x{Height}, hwnd={hwnd}");
				return true;
			}
			catch (global::System.Exception ex2)
			{
				Log.Msg($"[WgcCapture] Init failed: {ex2}");
				return false;
			}
		}

		private static void TrySetIncludeSecondaryWindows(GraphicsCaptureSession session)
		{
			try
			{
				if (!ApiInformation.IsPropertyPresent("Windows.Graphics.Capture.GraphicsCaptureSession", "IncludeSecondaryWindows"))
				{
					Log.Msg("[WgcCapture] IncludeSecondaryWindows unsupported on this Windows API");
					return;
				}
				session.IncludeSecondaryWindows = true;
				Log.Msg("[WgcCapture] IncludeSecondaryWindows enabled");
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCapture] IncludeSecondaryWindows failed: " + ex.Message);
			}
		}

		[DllImport("user32.dll")]
		private static extern nint MonitorFromPoint(int x, int y, uint dwFlags);

		[DllImport("combase.dll")]
		private static extern int WindowsCreateString([MarshalAs((UnmanagedType)21)] string sourceString, int length, out nint hstring);

		[DllImport("combase.dll")]
		private static extern int WindowsDeleteString(nint hstring);

		[DllImport("combase.dll")]
		private static extern int RoGetActivationFactory(nint activatableClassId, ref Guid iid, out nint factory);

		private static nint GetActivationFactory(string className, Guid iid)
		{
			WindowsCreateString(className, className.Length, out var hstring);
			RoGetActivationFactory(hstring, ref iid, out var factory);
			WindowsDeleteString(hstring);
			return factory;
		}

		private static bool EnsureCaptureInterop()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			lock (_captureInteropLock)
			{
				if (_captureInterop != null)
				{
					return true;
				}
				Guid iid = default(Guid);
				((Guid)(ref iid))..ctor("3628E81B-3CAC-4C60-B7F4-23CE0E0C3356");
				nint activationFactory = GetActivationFactory("Windows.Graphics.Capture.GraphicsCaptureItem", iid);
				if (activationFactory == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg("[WgcCapture] GraphicsCaptureItem activation factory unavailable");
					return false;
				}
				_captureInterop = (IGraphicsCaptureItemInterop)Marshal.GetObjectForIUnknown((global::System.IntPtr)activationFactory);
				Marshal.Release((global::System.IntPtr)activationFactory);
				Log.Msg("[WgcCapture] GraphicsCaptureItem interop factory ready");
				return true;
			}
		}

		private static GraphicsCaptureItem CreateItemForWindow(nint hwnd)
		{
			if (!EnsureCaptureInterop())
			{
				return null;
			}
			try
			{
				Guid iid = default(Guid);
				((Guid)(ref iid))..ctor("79C3F95B-31F7-4EC2-A464-632EF5D30760");
				nint num = _captureInterop.CreateForWindow(hwnd, ref iid);
				GraphicsCaptureItem result = MarshalInterface<GraphicsCaptureItem>.FromAbi((global::System.IntPtr)num);
				Marshal.Release((global::System.IntPtr)num);
				return result;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCapture] CreateForWindow failed: " + ex.Message);
				return null;
			}
		}

		private static GraphicsCaptureItem CreateItemForMonitor(nint hmon)
		{
			if (!EnsureCaptureInterop())
			{
				return null;
			}
			try
			{
				Guid iid = default(Guid);
				((Guid)(ref iid))..ctor("79C3F95B-31F7-4EC2-A464-632EF5D30760");
				nint num = _captureInterop.CreateForMonitor(hmon, ref iid);
				GraphicsCaptureItem result = MarshalInterface<GraphicsCaptureItem>.FromAbi((global::System.IntPtr)num);
				Marshal.Release((global::System.IntPtr)num);
				return result;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCapture] CreateForMonitor failed: " + ex.Message);
				return null;
			}
		}

		internal unsafe static List<GpuAdapterInfo> EnumerateAdapters()
		{
			List<GpuAdapterInfo> val = new List<GpuAdapterInfo>();
			Guid riid = default(Guid);
			((Guid)(ref riid))..ctor("770aae78-f26f-4dba-a829-253c83d1b387");
			if (CreateDXGIFactory1(ref riid, out var ppFactory) < 0 || ppFactory == (nint)global::System.IntPtr.Zero)
			{
				return val;
			}
			try
			{
				delegate* unmanaged[Stdcall]<nint, uint, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, uint, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)ppFactory) + (nint)7 * (nint)sizeof(nint)));
				nint num2 = default(nint);
				for (uint num = 0u; delegate*(ppFactory, num, &num2) >= 0; num++)
				{
					try
					{
						DXGI_ADAPTER_DESC adapterDesc = GetAdapterDesc(num2);
						val.Add(new GpuAdapterInfo(AdapterName(adapterDesc), adapterDesc.VendorId, adapterDesc.AdapterLuid, adapterDesc.DedicatedVideoMemory, adapterDesc.VendorId == 5140));
					}
					finally
					{
						Marshal.Release((global::System.IntPtr)num2);
					}
				}
				return val;
			}
			finally
			{
				Marshal.Release((global::System.IntPtr)ppFactory);
			}
		}

		private unsafe static DXGI_ADAPTER_DESC GetAdapterDesc(nint adapter)
		{
			DXGI_ADAPTER_DESC result = default(DXGI_ADAPTER_DESC);
			((delegate* unmanaged[Stdcall]<nint, DXGI_ADAPTER_DESC*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)adapter) + (nint)8 * (nint)sizeof(nint))))(adapter, &result);
			return result;
		}

		private unsafe static string AdapterName(DXGI_ADAPTER_DESC desc)
		{
			return new string(desc.Description).TrimEnd('\0');
		}

		private static void CacheAdapter(nint adapter, DXGI_ADAPTER_DESC desc)
		{
			_cachedPreferredAdapter = adapter;
			_cachedPreferredAdapterVendorId = desc.VendorId;
			_cachedPreferredAdapterLuid = desc.AdapterLuid;
			if (_cachedPreferredAdapter != (nint)global::System.IntPtr.Zero)
			{
				Marshal.AddRef((global::System.IntPtr)_cachedPreferredAdapter);
			}
			_adapterCacheReady = true;
		}

		private static bool TryGetConfiguredGpuLuid(out long luid)
		{
			luid = 0L;
			string text = DesktopBuddyMod.Config?.GetValue(DesktopBuddyMod.PreferredGpuLuid)?.Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return false;
			}
			if (text.StartsWith("0x", (StringComparison)5))
			{
				return long.TryParse(text.Substring(2), (NumberStyles)515, (IFormatProvider)(object)CultureInfo.InvariantCulture, ref luid);
			}
			return long.TryParse(text, ref luid);
		}

		private unsafe static nint FindAdapterByLuid(long preferredLuid, out DXGI_ADAPTER_DESC matchedDesc)
		{
			matchedDesc = default(DXGI_ADAPTER_DESC);
			Guid riid = default(Guid);
			((Guid)(ref riid))..ctor("770aae78-f26f-4dba-a829-253c83d1b387");
			if (CreateDXGIFactory1(ref riid, out var ppFactory) < 0 || ppFactory == (nint)global::System.IntPtr.Zero)
			{
				return global::System.IntPtr.Zero;
			}
			try
			{
				delegate* unmanaged[Stdcall]<nint, uint, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, uint, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)ppFactory) + (nint)7 * (nint)sizeof(nint)));
				nint num2 = default(nint);
				for (uint num = 0u; delegate*(ppFactory, num, &num2) >= 0; num++)
				{
					DXGI_ADAPTER_DESC adapterDesc = GetAdapterDesc(num2);
					if (adapterDesc.VendorId != 5140 && adapterDesc.AdapterLuid == preferredLuid)
					{
						matchedDesc = adapterDesc;
						return num2;
					}
					Marshal.Release((global::System.IntPtr)num2);
				}
			}
			finally
			{
				Marshal.Release((global::System.IntPtr)ppFactory);
			}
			return global::System.IntPtr.Zero;
		}

		private unsafe static nint FindPreferredAdapter()
		{
			lock (_adapterCacheLock)
			{
				if (_adapterCacheReady)
				{
					if (_cachedPreferredAdapter != (nint)global::System.IntPtr.Zero)
					{
						Marshal.AddRef((global::System.IntPtr)_cachedPreferredAdapter);
					}
					return _cachedPreferredAdapter;
				}
				if (TryGetConfiguredGpuLuid(out var luid))
				{
					DXGI_ADAPTER_DESC matchedDesc;
					nint num = FindAdapterByLuid(luid, out matchedDesc);
					if (num != (nint)global::System.IntPtr.Zero)
					{
						CacheAdapter(num, matchedDesc);
						Log.Msg($"[WgcCapture] Selected configured adapter: '{AdapterName(matchedDesc)}' VendorId=0x{matchedDesc.VendorId:X4} LUID=0x{matchedDesc.AdapterLuid:X16}");
						return num;
					}
					Log.Msg($"[WgcCapture] Configured GPU LUID 0x{luid:X16} was not found; falling back to automatic adapter selection");
				}
				if (_rendererAdapterHintReady && _rendererAdapterHintLuid != 0L)
				{
					DXGI_ADAPTER_DESC matchedDesc2;
					nint num2 = FindAdapterByLuid(_rendererAdapterHintLuid, out matchedDesc2);
					if (num2 != (nint)global::System.IntPtr.Zero)
					{
						CacheAdapter(num2, matchedDesc2);
						Log.Msg($"[WgcCapture] Selected renderer adapter: '{AdapterName(matchedDesc2)}' VendorId=0x{matchedDesc2.VendorId:X4} LUID=0x{matchedDesc2.AdapterLuid:X16}");
						return num2;
					}
					Log.Msg($"[WgcCapture] Renderer adapter hint 0x{_rendererAdapterHintLuid:X16} was not found; falling back to automatic adapter selection");
				}
				Guid riid = default(Guid);
				((Guid)(ref riid))..ctor("c1b6694f-ff09-44a9-b03c-77900a0a1d17");
				int num3 = CreateDXGIFactory1(ref riid, out var ppFactory);
				if (num3 >= 0 && ppFactory != (nint)global::System.IntPtr.Zero)
				{
					delegate* unmanaged[Stdcall]<nint, uint, uint, Guid*, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, uint, uint, Guid*, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)ppFactory) + (nint)29 * (nint)sizeof(nint)));
					Guid val = default(Guid);
					((Guid)(ref val))..ctor("2411e7e1-12ac-4ccf-bd14-9798e8534dc0");
					uint num4 = 0u;
					nint num5 = default(nint);
					while (true)
					{
						num3 = delegate*(ppFactory, num4, 2u, &val, &num5);
						if (num3 < 0)
						{
							break;
						}
						DXGI_ADAPTER_DESC adapterDesc = GetAdapterDesc(num5);
						string text = AdapterName(adapterDesc);
						bool flag = adapterDesc.VendorId == 5140;
						Log.Msg($"[WgcCapture] HighPerf adapter {num4}: '{text}' VendorId=0x{adapterDesc.VendorId:X4} VRAM={adapterDesc.DedicatedVideoMemory / 1048576}MB LUID=0x{adapterDesc.AdapterLuid:X16}{(flag ? " [basic]" : "")}");
						if (!flag)
						{
							CacheAdapter(num5, adapterDesc);
							Log.Msg($"[WgcCapture] Selected high-performance adapter: '{text}' VendorId=0x{adapterDesc.VendorId:X4} LUID=0x{adapterDesc.AdapterLuid:X16}");
							Marshal.Release((global::System.IntPtr)ppFactory);
							return num5;
						}
						Marshal.Release((global::System.IntPtr)num5);
						num4++;
					}
					Marshal.Release((global::System.IntPtr)ppFactory);
				}
				else
				{
					Log.Msg($"[WgcCapture] IDXGIFactory6 unavailable; falling back to dedicated VRAM adapter selection hr=0x{num3:X8}");
				}
				Guid riid2 = default(Guid);
				((Guid)(ref riid2))..ctor("770aae78-f26f-4dba-a829-253c83d1b387");
				num3 = CreateDXGIFactory1(ref riid2, out var ppFactory2);
				if (num3 < 0 || ppFactory2 == (nint)global::System.IntPtr.Zero)
				{
					_adapterCacheReady = true;
					return global::System.IntPtr.Zero;
				}
				delegate* unmanaged[Stdcall]<nint, uint, nint*, int> delegate*2 = (delegate* unmanaged[Stdcall]<nint, uint, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)ppFactory2) + (nint)7 * (nint)sizeof(nint)));
				nint num6 = global::System.IntPtr.Zero;
				nuint num7 = 0u;
				bool flag2 = true;
				DXGI_ADAPTER_DESC desc = default(DXGI_ADAPTER_DESC);
				uint num8 = 0u;
				uint num9 = 0u;
				nint num10 = default(nint);
				while (true)
				{
					num3 = delegate*2(ppFactory2, num9, &num10);
					if (num3 < 0)
					{
						break;
					}
					DXGI_ADAPTER_DESC adapterDesc2 = GetAdapterDesc(num10);
					bool flag3 = adapterDesc2.VendorId == 5140;
					string text2 = AdapterName(adapterDesc2);
					Log.Msg($"[WgcCapture] Adapter {num9}: '{text2}' VendorId=0x{adapterDesc2.VendorId:X4} VRAM={adapterDesc2.DedicatedVideoMemory / 1048576}MB LUID=0x{adapterDesc2.AdapterLuid:X16}{(flag3 ? " [basic]" : "")}");
					if (num6 == (nint)global::System.IntPtr.Zero || (flag2 && !flag3) || (flag2 == flag3 && adapterDesc2.DedicatedVideoMemory > num7))
					{
						if (num6 != (nint)global::System.IntPtr.Zero)
						{
							Marshal.Release((global::System.IntPtr)num6);
						}
						num6 = num10;
						num8 = adapterDesc2.VendorId;
						num7 = adapterDesc2.DedicatedVideoMemory;
						flag2 = flag3;
						desc = adapterDesc2;
					}
					else
					{
						Marshal.Release((global::System.IntPtr)num10);
					}
					num9++;
				}
				Marshal.Release((global::System.IntPtr)ppFactory2);
				if (num6 != (nint)global::System.IntPtr.Zero)
				{
					CacheAdapter(num6, desc);
					Log.Msg($"[WgcCapture] Selected max-VRAM adapter: '{AdapterName(desc)}' VendorId=0x{num8:X4} VRAM={num7 / 1048576}MB LUID=0x{desc.AdapterLuid:X16}");
				}
				else
				{
					_adapterCacheReady = true;
				}
				_adapterCacheReady = true;
				return num6;
			}
		}

		[DllImport("kernel32.dll", CharSet = (CharSet)3)]
		private static extern nint LoadLibraryW(string lpFileName);

		[DllImport("kernel32.dll", CharSet = (CharSet)2)]
		private static extern nint GetProcAddress(nint hModule, string procName);

		private unsafe static int CallCreateDirect3D11DeviceFromDXGIDevice(nint dxgiDevice, out nint graphicsDevice)
		{
			nint procAddress = GetProcAddress(LoadLibraryW("d3d11.dll"), "CreateDirect3D11DeviceFromDXGIDevice");
			if (procAddress == (nint)global::System.IntPtr.Zero)
			{
				graphicsDevice = global::System.IntPtr.Zero;
				return -1;
			}
			nint num = default(nint);
			int result = ((delegate* unmanaged[Stdcall]<nint, nint*, int>)procAddress)(dxgiDevice, &num);
			graphicsDevice = num;
			return result;
		}

		internal static bool PrewarmSharedDevice()
		{
			EnsurePreferredAdapterCached();
			return _adapterCacheReady;
		}

		internal static bool PrewarmCaptureFactory()
		{
			return EnsureCaptureInterop();
		}

		private static void EnsurePreferredAdapterCached()
		{
			nint num = FindPreferredAdapter();
			if (num != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)num);
			}
			_preferredD3dAdapterVendorId = _cachedPreferredAdapterVendorId;
		}

		private unsafe bool CreateD3dDevice()
		{
			if (_d3dDevice != (nint)global::System.IntPtr.Zero && _d3dContext != (nint)global::System.IntPtr.Zero && _winrtDevice != null)
			{
				return true;
			}
			lock (_d3dLock)
			{
				if (_d3dDevice != (nint)global::System.IntPtr.Zero && _d3dContext != (nint)global::System.IntPtr.Zero && _winrtDevice != null)
				{
					return true;
				}
				uint flags = 32u;
				nint num = FindPreferredAdapter();
				uint cachedPreferredAdapterVendorId = _cachedPreferredAdapterVendorId;
				long cachedPreferredAdapterLuid = _cachedPreferredAdapterLuid;
				int driverType = ((num == (nint)global::System.IntPtr.Zero) ? 1 : 0);
				int num2 = D3D11CreateDevice(num, driverType, global::System.IntPtr.Zero, flags, global::System.IntPtr.Zero, 0u, 7u, out _d3dDevice, out var _, out _d3dContext);
				if (num != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)num);
				}
				if (num2 < 0)
				{
					Log.Msg($"[WgcCapture] D3D11CreateDevice failed hr=0x{num2:X8}");
					ReleaseD3dDevice();
					return false;
				}
				Guid val = default(Guid);
				((Guid)(ref val))..ctor("9B7E4E00-342C-4106-A19F-4F2704F689F0");
				nint num3 = default(nint);
				if (Marshal.QueryInterface((global::System.IntPtr)_d3dDevice, ref val, ref num3) >= 0)
				{
					((delegate* unmanaged[Stdcall]<nint, int, int*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)num3) + (nint)4 * (nint)sizeof(nint))))(num3, 1, null);
					Marshal.Release((global::System.IntPtr)num3);
					Log.Msg("[WgcCapture] D3D11 multithread protection enabled");
				}
				Guid val2 = default(Guid);
				((Guid)(ref val2))..ctor("54ec77fa-1377-44e6-8c32-88fd5f44c84c");
				nint num4 = default(nint);
				num2 = Marshal.QueryInterface((global::System.IntPtr)_d3dDevice, ref val2, ref num4);
				if (num2 < 0 || num4 == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg($"[WgcCapture] IDXGIDevice QueryInterface failed hr=0x{num2:X8}");
					ReleaseD3dDevice();
					return false;
				}
				num2 = CallCreateDirect3D11DeviceFromDXGIDevice(num4, out var graphicsDevice);
				Marshal.Release((global::System.IntPtr)num4);
				if (num2 < 0 || graphicsDevice == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg($"[WgcCapture] CreateDirect3D11DeviceFromDXGIDevice failed hr=0x{num2:X8}");
					ReleaseD3dDevice();
					return false;
				}
				_winrtDevice = MarshalInterface<IDirect3DDevice>.FromAbi((global::System.IntPtr)graphicsDevice);
				Marshal.Release((global::System.IntPtr)graphicsDevice);
				_preferredD3dAdapterVendorId = cachedPreferredAdapterVendorId;
				Log.Msg($"[WgcCapture] D3D11 device ready 0x{_d3dDevice:X} vendor=0x{cachedPreferredAdapterVendorId:X4} LUID=0x{cachedPreferredAdapterLuid:X16}");
				return true;
			}
		}

		private void ReleaseD3dDevice()
		{
			_winrtDevice = null;
			if (_d3dContext != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					Marshal.Release((global::System.IntPtr)_d3dContext);
				}
				catch
				{
				}
				_d3dContext = global::System.IntPtr.Zero;
			}
			if (_d3dDevice != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					Marshal.Release((global::System.IntPtr)_d3dDevice);
				}
				catch
				{
				}
				_d3dDevice = global::System.IntPtr.Zero;
			}
		}

		private unsafe void OnFrameArrived(Direct3D11CaptureFramePool sender, object args)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			if (!TryEnterFrameProcessing())
			{
				return;
			}
			try
			{
				if (_disposed)
				{
					return;
				}
				Direct3D11CaptureFrame val = null;
				nint num = global::System.IntPtr.Zero;
				nint zero = global::System.IntPtr.Zero;
				nint zero2 = global::System.IntPtr.Zero;
				try
				{
					val = sender.TryGetNextFrame();
					if (val == (Direct3D11CaptureFrame)null)
					{
						return;
					}
					SizeInt32 contentSize = val.ContentSize;
					int width = contentSize.Width;
					int height = contentSize.Height;
					if (width <= 0 || height <= 0 || _needsPoolRecreate)
					{
						return;
					}
					if (width != Width || height != Height)
					{
						Log.Msg($"[WgcCapture] Resize {Width}x{Height} -> {width}x{height}");
						RequestPoolRecreate(width, height);
						return;
					}
					num = MarshalInterface<IDirect3DSurface>.FromManaged(val.Surface);
					if (num == (nint)global::System.IntPtr.Zero)
					{
						return;
					}
					Guid dxgiAccessGuid = DxgiAccessGuid;
					int num2 = Marshal.QueryInterface((global::System.IntPtr)num, ref dxgiAccessGuid, ref zero);
					Marshal.Release((global::System.IntPtr)num);
					num = global::System.IntPtr.Zero;
					if (num2 < 0 || zero == (nint)global::System.IntPtr.Zero)
					{
						return;
					}
					delegate* unmanaged[Stdcall]<nint, Guid*, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, Guid*, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)zero) + (nint)3 * (nint)sizeof(nint)));
					Guid texGuid = TexGuid;
					if (delegate*(zero, &texGuid, &zero2) < 0 || zero2 == (nint)global::System.IntPtr.Zero)
					{
						return;
					}
					if (CopyFrameToSharedTexture(zero2, width, height) != (nint)global::System.IntPtr.Zero)
					{
						_sharedFramesCopied++;
					}
					if (zero2 != (nint)global::System.IntPtr.Zero)
					{
						using (DesktopBuddyMod.Perf.Time("queue_frame"))
						{
							Action<nint, nint, int, int> onGpuFrame = OnGpuFrame;
							try
							{
								onGpuFrame?.Invoke(_d3dDevice, zero2, width, height);
							}
							catch (global::System.Exception ex)
							{
								Log.Msg($"[WgcCapture] OnGpuFrame error: {ex}");
							}
						}
					}
					_framesCaptured++;
					if (_framesCaptured == 1)
					{
						Log.Msg($"[WgcCapture] First frame: {width}x{height}");
					}
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg("[WgcCapture] OnFrameArrived error: " + ex2.Message + "\n" + ex2.StackTrace);
				}
				finally
				{
					if (zero2 != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)zero2);
					}
					if (zero != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)zero);
					}
					if (num != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)num);
					}
					if (val != null)
					{
						val.Dispose();
					}
				}
			}
			finally
			{
				LeaveFrameProcessing();
			}
		}

		private bool TryEnterFrameProcessing()
		{
			lock (_disposeLock)
			{
				if (_disposed)
				{
					return false;
				}
				if (_frameProcessing != 0)
				{
					LogFrameBusyDrop();
					return false;
				}
				_frameProcessing = 1;
				_activeFrameCallbacks++;
				_frameCallbacksDrained.Reset();
				return true;
			}
		}

		private void LeaveFrameProcessing()
		{
			lock (_disposeLock)
			{
				_frameProcessing = 0;
				if (_activeFrameCallbacks > 0 && --_activeFrameCallbacks == 0)
				{
					_frameCallbacksDrained.Set();
				}
			}
		}

		private bool TryEnterCaptureResourceUse()
		{
			lock (_disposeLock)
			{
				if (_disposed)
				{
					return false;
				}
				_activeFrameCallbacks++;
				_frameCallbacksDrained.Reset();
				return true;
			}
		}

		private void LeaveCaptureResourceUse()
		{
			lock (_disposeLock)
			{
				if (_activeFrameCallbacks > 0 && --_activeFrameCallbacks == 0)
				{
					_frameCallbacksDrained.Set();
				}
			}
		}

		private bool WaitForFrameCallbacksToDrain(string reason)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (_frameCallbacksDrained.Wait(TimeSpan.FromSeconds(2L)))
			{
				return true;
			}
			int activeFrameCallbacks;
			lock (_disposeLock)
			{
				activeFrameCallbacks = _activeFrameCallbacks;
			}
			Log.Msg($"[WgcCapture:{reason}] Timed out waiting for {activeFrameCallbacks} active frame callback(s); leaving D3D resources alive to avoid use-after-release hwnd={_hwnd}");
			return false;
		}

		private void LogFrameBusyDrop()
		{
			int num = Interlocked.Increment(ref _frameBusyDrops);
			if (num == 1 || num % 120 == 0)
			{
				Log.Msg($"[WgcCapture] Dropped {num} frame callback(s): previous frame still processing hwnd={_hwnd}");
			}
		}

		private void LogD3dBusyFrameDrop()
		{
			int num = Interlocked.Increment(ref _d3dBusyFrameDrops);
			if (num == 1 || num % 120 == 0)
			{
				Log.Msg($"[WgcCapture] Dropped {num} shared texture copy frame(s): D3D context busy hwnd={_hwnd}");
			}
		}

		private unsafe bool TryCreateSharedTexture(int width, int height)
		{
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			if (_d3dDevice == (nint)global::System.IntPtr.Zero || width <= 0 || height <= 0)
			{
				return false;
			}
			if (_sharedTexture != (nint)global::System.IntPtr.Zero && SharedTextureWidth == width && SharedTextureHeight == height)
			{
				return true;
			}
			D3D11_TEXTURE2D_DESC d3D11_TEXTURE2D_DESC = new D3D11_TEXTURE2D_DESC
			{
				Width = (uint)width,
				Height = (uint)height,
				MipLevels = 1u,
				ArraySize = 1u,
				Format = 90u,
				SampleDesc = new DXGI_SAMPLE_DESC
				{
					Count = 1u,
					Quality = 0u
				},
				Usage = 0u,
				BindFlags = 8u,
				CPUAccessFlags = 0u,
				MiscFlags = 2u
			};
			lock (_d3dLock)
			{
				ReleaseSharedTextureUnlocked();
				delegate* unmanaged[Stdcall]<nint, D3D11_TEXTURE2D_DESC*, nint, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, D3D11_TEXTURE2D_DESC*, nint, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_d3dDevice) + (nint)5 * (nint)sizeof(nint)));
				long timestamp = Stopwatch.GetTimestamp();
				Log.Msg($"[WgcCapture] Shared texture CreateTexture2D START {width}x{height} hwnd={_hwnd}");
				nint num2 = default(nint);
				int num = delegate*(_d3dDevice, &d3D11_TEXTURE2D_DESC, global::System.IntPtr.Zero, &num2);
				double num3 = (double)(Stopwatch.GetTimestamp() - timestamp) * 1000.0 / (double)Stopwatch.Frequency;
				Log.Msg($"[WgcCapture] Shared texture CreateTexture2D DONE {width}x{height} hwnd={_hwnd} hr=0x{num:X8} {num3:F2}ms");
				if (num < 0 || num2 == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg($"[WgcCapture] Shared texture CreateTexture2D failed hr=0x{num:X8} size={width}x{height}");
					return false;
				}
				Guid dxgiResourceGuid = DxgiResourceGuid;
				nint num4 = default(nint);
				num = Marshal.QueryInterface((global::System.IntPtr)num2, ref dxgiResourceGuid, ref num4);
				if (num < 0 || num4 == (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)num2);
					Log.Msg($"[WgcCapture] Shared texture IDXGIResource QueryInterface failed hr=0x{num:X8}");
					return false;
				}
				try
				{
					nint num5 = default(nint);
					num = ((delegate* unmanaged[Stdcall]<nint, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)num4) + (nint)8 * (nint)sizeof(nint))))(num4, &num5);
					if (num < 0 || num5 == (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)num2);
						Log.Msg($"[WgcCapture] GetSharedHandle failed hr=0x{num:X8}");
						return false;
					}
					_sharedTexture = num2;
					SharedTextureHandle = num5;
					SharedTextureWidth = width;
					SharedTextureHeight = height;
					_sharedFramesCopied = 0;
					Log.Msg($"[WgcCapture] Shared texture ready handle=0x{num5:X} ptr=0x{num2:X} {width}x{height}");
					return true;
				}
				finally
				{
					Marshal.Release((global::System.IntPtr)num4);
				}
			}
		}

		private unsafe nint CopyFrameToSharedTexture(nint srcTexture, int width, int height)
		{
			if (_sharedTexture == (nint)global::System.IntPtr.Zero || srcTexture == (nint)global::System.IntPtr.Zero)
			{
				return global::System.IntPtr.Zero;
			}
			if (width != SharedTextureWidth || height != SharedTextureHeight)
			{
				return global::System.IntPtr.Zero;
			}
			bool flag = false;
			try
			{
				Monitor.TryEnter(_d3dLock, 0, ref flag);
				if (!flag)
				{
					LogD3dBusyFrameDrop();
					return global::System.IntPtr.Zero;
				}
				if (_disposed || _sharedTexture == (nint)global::System.IntPtr.Zero || _d3dContext == (nint)global::System.IntPtr.Zero)
				{
					return global::System.IntPtr.Zero;
				}
				((delegate* unmanaged[Stdcall]<nint, nint, nint, void>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_d3dContext) + (nint)47 * (nint)sizeof(nint))))(_d3dContext, _sharedTexture, srcTexture);
				return _sharedTexture;
			}
			finally
			{
				if (flag)
				{
					Monitor.Exit(_d3dLock);
				}
			}
		}

		private void ReleaseSharedTexture()
		{
			lock (_d3dLock)
			{
				ReleaseSharedTextureUnlocked();
			}
		}

		private void ReleaseSharedTextureUnlocked()
		{
			SharedTextureHandle = global::System.IntPtr.Zero;
			SharedTextureWidth = 0;
			SharedTextureHeight = 0;
			if (_sharedTexture != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					Marshal.Release((global::System.IntPtr)_sharedTexture);
				}
				catch
				{
				}
				_sharedTexture = global::System.IntPtr.Zero;
			}
		}

		public unsafe void FlushD3dContext()
		{
			Log.Msg($"[CleanupTrace] WgcCapture.FlushD3dContext ENTER hwnd={_hwnd} disposed={_disposed} ctx=0x{_d3dContext:X}");
			lock (_d3dLock)
			{
				Log.Msg($"[CleanupTrace] WgcCapture.FlushD3dContext D3D lock ACQUIRED hwnd={_hwnd}");
				if (_d3dContext == (nint)global::System.IntPtr.Zero)
				{
					return;
				}
				try
				{
					nint d3dContext = *(nint*)_d3dContext;
					Log.Msg($"[CleanupTrace] WgcCapture.FlushD3dContext Flush START hwnd={_hwnd}");
					((delegate* unmanaged[Stdcall]<nint, void>)(*(global::System.IntPtr*)(d3dContext + (nint)111 * (nint)sizeof(nint))))(_d3dContext);
					Log.Msg("[WgcCapture] D3D11 Flush OK");
					Log.Msg($"[CleanupTrace] WgcCapture.FlushD3dContext DONE hwnd={_hwnd}");
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[WgcCapture] D3D11 flush error: " + ex.Message);
				}
			}
			Log.Msg($"[CleanupTrace] WgcCapture.FlushD3dContext EXIT hwnd={_hwnd}");
		}
	}
	internal sealed class WgcCaptureBackend : IDesktopCaptureBackend, global::System.IDisposable
	{
		private readonly nint _hwnd;

		private readonly nint _monitorHandle;

		private WgcCapture _wgc;

		public int Width => _wgc?.Width ?? 0;

		public int Height => _wgc?.Height ?? 0;

		public bool IsValid => _wgc?.IsValid ?? false;

		public object D3dContextLock => _wgc?.D3dContextLock;

		public nint D3dDevice => _wgc?.D3dDevice ?? global::System.IntPtr.Zero;

		public nint D3dContext => _wgc?.D3dContext ?? global::System.IntPtr.Zero;

		public nint SharedTexture => _wgc?.SharedTexture ?? global::System.IntPtr.Zero;

		public nint SharedTextureHandle => _wgc?.SharedTextureHandle ?? global::System.IntPtr.Zero;

		public int SharedTextureWidth => _wgc?.SharedTextureWidth ?? 0;

		public int SharedTextureHeight => _wgc?.SharedTextureHeight ?? 0;

		public bool HasCurrentSharedFrame => _wgc?.HasCurrentSharedFrame ?? false;

		public bool IsResizeRecreatePending => _wgc?.IsResizeRecreatePending ?? false;

		public Action<nint, nint, int, int> OnGpuFrame
		{
			get
			{
				return _wgc?.OnGpuFrame;
			}
			set
			{
				if (_wgc != null)
				{
					_wgc.OnGpuFrame = value;
				}
			}
		}

		internal WgcCaptureBackend(nint hwnd, nint monitorHandle)
		{
			_hwnd = hwnd;
			_monitorHandle = monitorHandle;
		}

		public bool TryInitialCapture()
		{
			Log.Msg($"[WgcCaptureBackend] Initial capture starting hwnd={_hwnd} monitor=0x{_monitorHandle:X}");
			WgcCapture wgcCapture = new WgcCapture();
			bool flag = false;
			try
			{
				flag = wgcCapture.Init(_hwnd, _monitorHandle);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WgcCaptureBackend] WGC init exception: " + ex.Message);
			}
			if (!flag)
			{
				Log.Msg($"[WgcCaptureBackend] Initial capture failed hwnd={_hwnd} monitor=0x{_monitorHandle:X}");
				wgcCapture.Dispose();
				return false;
			}
			_wgc = wgcCapture;
			Log.Msg($"[WgcCaptureBackend] WGC capture initialized ({Width}x{Height})");
			return true;
		}

		public void RecreatePoolIfNeeded()
		{
			_wgc?.RecreatePoolIfNeeded();
		}

		public void FlushD3dContext()
		{
			_wgc?.FlushD3dContext();
		}

		public void StopCapture()
		{
			_wgc?.StopCapture();
		}

		public void Dispose()
		{
			_wgc?.Dispose();
			_wgc = null;
		}
	}
	internal sealed class DesktopBuddyConfig
	{
		private const string Section = "DesktopBuddy";

		private readonly ConfigFile _file;

		internal DesktopBuddyConfig(ConfigFile file)
		{
			_file = file;
		}

		internal void Bind<T>(DesktopBuddyConfigKey<T> key)
		{
			if (key.Entry == null)
			{
				ConfigEntry<T> val = (key.Entry = _file.Bind<T>("DesktopBuddy", key.Name, key.DefaultValue, key.Description));
			}
		}

		internal T GetValue<T>(DesktopBuddyConfigKey<T> key)
		{
			Bind(key);
			return key.Entry.Value;
		}

		internal void Set<T>(DesktopBuddyConfigKey<T> key, T value)
		{
			Bind(key);
			key.Entry.Value = value;
		}

		internal void Save()
		{
			_file.Save();
		}
	}
	internal sealed class DesktopBuddyConfigKey<T>
	{
		private readonly Func<T> _defaultValue;

		internal string Name
		{
			[CompilerGenerated]
			get;
		}

		internal string Description
		{
			[CompilerGenerated]
			get;
		}

		internal ConfigEntry<T> Entry
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			set;
		}

		internal T DefaultValue => _defaultValue.Invoke();

		internal DesktopBuddyConfigKey(string name, string description, Func<T> defaultValue)
		{
			Name = name;
			Description = description;
			_defaultValue = defaultValue;
		}
	}
	public enum AudioCaptureMode
	{
		IncludeProcess,
		ExcludeProcess
	}
	public sealed class AudioCapture : global::System.IDisposable
	{
		[ComImport]
		[Guid("72A22D78-CDE4-431D-B8CC-843A71199B6D")]
		[InterfaceType(/*Could not decode attribute arguments.*/)]
		private interface IActivateAudioInterfaceAsyncOperation
		{
			void GetActivateResult(out int activateResult, [MarshalAs((UnmanagedType)25)] out object activatedInterface);
		}

		[ComImport]
		[Guid("41D949AB-9862-444A-80F6-C261334DA5EB")]
		[InterfaceType(/*Could not decode attribute arguments.*/)]
		private interface IActivateAudioInterfaceCompletionHandler
		{
			void ActivateCompleted(IActivateAudioInterfaceAsyncOperation activateOperation);
		}

		[StructLayout((LayoutKind)0, Pack = 1)]
		private struct WAVEFORMATEX
		{
			public ushort wFormatTag;

			public ushort nChannels;

			public uint nSamplesPerSec;

			public uint nAvgBytesPerSec;

			public ushort nBlockAlign;

			public ushort wBitsPerSample;

			public ushort cbSize;
		}

		private struct AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS
		{
			public uint TargetProcessId;

			public int ProcessLoopbackMode;
		}

		private struct AUDIOCLIENT_ACTIVATION_PARAMS
		{
			public int ActivationType;

			public AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS ProcessLoopbackParams;
		}

		private class ActivationHandler : IActivateAudioInterfaceCompletionHandler
		{
			private readonly ManualResetEventSlim _event = new ManualResetEventSlim(false);

			public object Result;

			public int HResult;

			public void ActivateCompleted(IActivateAudioInterfaceAsyncOperation activateOperation)
			{
				activateOperation.GetActivateResult(out HResult, out Result);
				_event.Set();
			}

			public bool WaitForCompletion(int timeoutMs)
			{
				return _event.Wait(timeoutMs);
			}
		}

		internal static Action<string> LogHandler = Console.WriteLine;

		private const string VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK = "VAD\\Process_Loopback";

		private static readonly Guid IID_IAudioClient = new Guid("1CB9AD4C-DBFA-4c32-B178-C2F568A703B2");

		private static readonly Guid IID_IAudioCaptureClient = new Guid("C8ADBD64-E71E-48a0-A4DE-185C395CD317");

		private const int AUDCLNT_SHAREMODE_SHARED = 0;

		private const int AUDCLNT_STREAMFLAGS_LOOPBACK = 131072;

		private const int AUDCLNT_STREAMFLAGS_EVENTCALLBACK = 262144;

		private const int AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM = -2147483648;

		private const int AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK = 1;

		private const int PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE = 0;

		private const int PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE = 1;

		private const int AC_Initialize = 3;

		private const int AC_Start = 10;

		private const int AC_Stop = 11;

		private const int AC_SetEventHandle = 13;

		private const int AC_GetService = 14;

		private const int ACC_GetBuffer = 3;

		private const int ACC_ReleaseBuffer = 4;

		private const int ACC_GetNextPacketSize = 5;

		private float[] _audioBuffer;

		private long _writePos;

		private const int AUDIO_RING_SAMPLES = 192000;

		private nint _audioClient;

		private nint _captureClient;

		private nint _captureEvent;

		private Thread _captureThread;

		private volatile bool _disposed;

		public long WritePosition => Volatile.Read(ref _writePos);

		public int SampleRate => 48000;

		public int Channels => 2;

		public int BitsPerSample => 32;

		public bool IsCapturing
		{
			get
			{
				if (_audioClient != (nint)global::System.IntPtr.Zero)
				{
					return !_disposed;
				}
				return false;
			}
		}

		internal static void Log(string msg)
		{
			LogHandler.Invoke(msg);
		}

		[DllImport("kernel32.dll")]
		private static extern nint CreateEventW(nint lpEventAttributes, bool bManualReset, bool bInitialState, nint lpName);

		[DllImport("kernel32.dll")]
		private static extern uint WaitForSingleObject(nint hHandle, uint dwMilliseconds);

		[DllImport("kernel32.dll")]
		private static extern bool CloseHandle(nint hObject);

		[DllImport("user32.dll")]
		private static extern uint GetWindowThreadProcessId(nint hWnd, out uint processId);

		[DllImport("Mmdevapi.dll", ExactSpelling = true)]
		private static extern int ActivateAudioInterfaceAsync([MarshalAs((UnmanagedType)21)] string deviceInterfacePath, ref Guid riid, nint activationParams, IActivateAudioInterfaceCompletionHandler completionHandler, out IActivateAudioInterfaceAsyncOperation activationOperation);

		public bool Start(nint hwnd, AudioCaptureMode mode)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0478: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Expected O, but got Unknown
			//IL_047d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_0489: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Expected O, but got Unknown
			try
			{
				uint processId;
				int processLoopbackMode;
				if (mode == AudioCaptureMode.IncludeProcess)
				{
					GetWindowThreadProcessId(hwnd, out processId);
					processLoopbackMode = 0;
					Log($"[AudioCapture] Capturing audio for PID {processId} (window 0x{hwnd:X})");
				}
				else
				{
					processId = (uint)Process.GetCurrentProcess().Id;
					processLoopbackMode = 1;
					Log($"[AudioCapture] Capturing all audio except PID {processId} (Resonite)");
				}
				AUDIOCLIENT_ACTIVATION_PARAMS obj = new AUDIOCLIENT_ACTIVATION_PARAMS
				{
					ActivationType = 1,
					ProcessLoopbackParams = new AUDIOCLIENT_PROCESS_LOOPBACK_PARAMS
					{
						TargetProcessId = processId,
						ProcessLoopbackMode = processLoopbackMode
					}
				};
				int num = Marshal.SizeOf<AUDIOCLIENT_ACTIVATION_PARAMS>();
				nint num2 = Marshal.AllocCoTaskMem(num);
				Marshal.StructureToPtr<AUDIOCLIENT_ACTIVATION_PARAMS>(obj, (global::System.IntPtr)num2, false);
				nint num3 = Marshal.AllocCoTaskMem(24);
				for (int i = 0; i < 24; i++)
				{
					Marshal.WriteByte((global::System.IntPtr)num3, i, (byte)0);
				}
				Marshal.WriteInt16((global::System.IntPtr)num3, 0, (short)65);
				Marshal.WriteInt32((global::System.IntPtr)num3, 8, num);
				Marshal.WriteIntPtr((global::System.IntPtr)num3, 16, (global::System.IntPtr)num2);
				ActivationHandler activationHandler = new ActivationHandler();
				Guid riid = IID_IAudioClient;
				int num4 = ActivateAudioInterfaceAsync("VAD\\Process_Loopback", ref riid, num3, activationHandler, out var _);
				if (num4 < 0)
				{
					Log($"[AudioCapture] ActivateAudioInterfaceAsync failed: 0x{num4:X8}");
					return false;
				}
				if (!activationHandler.WaitForCompletion(5000))
				{
					Log("[AudioCapture] Activation timed out");
					return false;
				}
				Marshal.FreeCoTaskMem((global::System.IntPtr)num3);
				Marshal.FreeCoTaskMem((global::System.IntPtr)num2);
				if (activationHandler.HResult < 0 || activationHandler.Result == null)
				{
					Log($"[AudioCapture] Activation failed: 0x{activationHandler.HResult:X8}");
					return false;
				}
				_audioClient = Marshal.GetIUnknownForObject(activationHandler.Result);
				Log($"[AudioCapture] IAudioClient activated: 0x{_audioClient:X}");
				WAVEFORMATEX obj2 = new WAVEFORMATEX
				{
					wFormatTag = 3,
					nChannels = 2,
					nSamplesPerSec = 48000u,
					wBitsPerSample = 32,
					nBlockAlign = 8,
					nAvgBytesPerSec = 384000u,
					cbSize = 0
				};
				nint num5 = Marshal.AllocCoTaskMem(Marshal.SizeOf<WAVEFORMATEX>());
				Marshal.StructureToPtr<WAVEFORMATEX>(obj2, (global::System.IntPtr)num5, false);
				num4 = AudioClientInitialize(_audioClient, 0, -2147090432, 0L, 0L, num5, global::System.IntPtr.Zero);
				Marshal.FreeCoTaskMem((global::System.IntPtr)num5);
				if (num4 < 0)
				{
					Log($"[AudioCapture] Initialize failed: 0x{num4:X8}");
					return false;
				}
				Log("[AudioCapture] IAudioClient initialized (event mode)");
				_captureEvent = CreateEventW(global::System.IntPtr.Zero, bManualReset: false, bInitialState: false, global::System.IntPtr.Zero);
				num4 = AudioClientSetEventHandle(_audioClient, _captureEvent);
				if (num4 < 0)
				{
					Log($"[AudioCapture] SetEventHandle failed: 0x{num4:X8}");
					return false;
				}
				Log("[AudioCapture] WASAPI event handle set");
				num4 = AudioClientGetService(_audioClient, IID_IAudioCaptureClient, out _captureClient);
				if (num4 < 0)
				{
					Log($"[AudioCapture] GetService failed: 0x{num4:X8}");
					return false;
				}
				Log($"[AudioCapture] IAudioCaptureClient: 0x{_captureClient:X}");
				_audioBuffer = new float[192000];
				_writePos = 0L;
				num4 = AudioClientStart(_audioClient);
				if (num4 < 0)
				{
					Log($"[AudioCapture] Start failed: 0x{num4:X8}");
					return false;
				}
				_captureThread = new Thread(new ThreadStart(CaptureLoop))
				{
					IsBackground = true,
					Name = "AudioCapture"
				};
				_captureThread.Start();
				Log("[AudioCapture] Started: 48000Hz float32 stereo");
				return true;
			}
			catch (global::System.Exception ex)
			{
				Log($"[AudioCapture] Start failed: {ex}");
				return false;
			}
		}

		private void CaptureLoop()
		{
			while (!_disposed)
			{
				WaitForSingleObject(_captureEvent, 100u);
				if (_disposed)
				{
					break;
				}
				try
				{
					DrainCaptureBuffer();
				}
				catch (global::System.Exception ex)
				{
					if (!_disposed)
					{
						Log("[AudioCapture] Capture error: " + ex.Message);
					}
				}
			}
		}

		private unsafe void DrainCaptureBuffer()
		{
			if (CaptureClientGetNextPacketSize(_captureClient, out var numFrames) < 0)
			{
				return;
			}
			nint data;
			uint numFrames2;
			uint flags;
			ulong devPos;
			ulong qpcPos;
			while (numFrames != 0 && CaptureClientGetBuffer(_captureClient, out data, out numFrames2, out flags, out devPos, out qpcPos) >= 0)
			{
				if (numFrames2 != 0)
				{
					bool num = (flags & 2) != 0;
					int num2 = (int)numFrames2 * Channels;
					int num3 = _audioBuffer.Length;
					long writePos = _writePos;
					int num4 = (int)(writePos % num3);
					if (num)
					{
						int num5 = Math.Min(num2, num3 - num4);
						global::System.Array.Clear((global::System.Array)_audioBuffer, num4, num5);
						if (num5 < num2)
						{
							global::System.Array.Clear((global::System.Array)_audioBuffer, 0, num2 - num5);
						}
					}
					else
					{
						float* ptr = (float*)data;
						int num6 = Math.Min(num2, num3 - num4);
						fixed (float* ptr2 = &_audioBuffer[num4])
						{
							Buffer.MemoryCopy((void*)ptr, (void*)ptr2, (long)(num6 * 4), (long)(num6 * 4));
						}
						if (num6 < num2)
						{
							fixed (float* ptr3 = &_audioBuffer[0])
							{
								Buffer.MemoryCopy((void*)(ptr + num6), (void*)ptr3, (long)((num2 - num6) * 4), (long)((num2 - num6) * 4));
							}
						}
					}
					Volatile.Write(ref _writePos, writePos + num2);
				}
				CaptureClientReleaseBuffer(_captureClient, numFrames2);
				if (CaptureClientGetNextPacketSize(_captureClient, out numFrames) < 0)
				{
					break;
				}
			}
		}

		public int ReadSamples(float[] output, int maxSamples, ref long readPos)
		{
			return AudioRingBuffer.Read(_audioBuffer, Volatile.Read(ref _writePos), ref readPos, output, maxSamples);
		}

		public int ReadSamples(global::System.Span<float> output, ref long readPos)
		{
			return AudioRingBuffer.Read(_audioBuffer, Volatile.Read(ref _writePos), ref readPos, output);
		}

		public void Dispose()
		{
			DesktopBuddy.Log.Msg($"[CleanupTrace] AudioCapture.Dispose ENTER disposed={_disposed} audioClient=0x{_audioClient:X} captureClient=0x{_captureClient:X}");
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose AudioClientStop START");
			if (_audioClient != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					AudioClientStop(_audioClient);
				}
				catch (global::System.Exception ex)
				{
					DesktopBuddy.Log.Msg("[AudioCapture] AudioClientStop error: " + ex.Message);
				}
			}
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose AudioClientStop DONE");
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose captureThread.Join START");
			Thread captureThread = _captureThread;
			if (captureThread != null)
			{
				captureThread.Join(1000);
			}
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose captureThread.Join DONE");
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose COM release START");
			if (_captureClient != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)_captureClient);
				_captureClient = global::System.IntPtr.Zero;
			}
			if (_audioClient != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)_audioClient);
				_audioClient = global::System.IntPtr.Zero;
			}
			if (_captureEvent != (nint)global::System.IntPtr.Zero)
			{
				CloseHandle(_captureEvent);
				_captureEvent = global::System.IntPtr.Zero;
			}
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose COM release DONE");
			Log("[AudioCapture] Disposed");
			DesktopBuddy.Log.Msg("[CleanupTrace] AudioCapture.Dispose EXIT");
		}

		private unsafe static int AudioClientInitialize(nint client, int shareMode, int streamFlags, long bufferDuration, long periodicity, nint pFormat, nint sessionGuid)
		{
			return ((delegate* unmanaged[Stdcall]<nint, int, int, long, long, nint, nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)3 * (nint)sizeof(nint))))(client, shareMode, streamFlags, bufferDuration, periodicity, pFormat, sessionGuid);
		}

		private unsafe static int AudioClientSetEventHandle(nint client, nint eventHandle)
		{
			return ((delegate* unmanaged[Stdcall]<nint, nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)13 * (nint)sizeof(nint))))(client, eventHandle);
		}

		private unsafe static int AudioClientStart(nint client)
		{
			return ((delegate* unmanaged[Stdcall]<nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)10 * (nint)sizeof(nint))))(client);
		}

		private unsafe static int AudioClientStop(nint client)
		{
			return ((delegate* unmanaged[Stdcall]<nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)11 * (nint)sizeof(nint))))(client);
		}

		private unsafe static int AudioClientGetService(nint client, Guid riid, out nint service)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			delegate* unmanaged[Stdcall]<nint, Guid*, nint*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, Guid*, nint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)14 * (nint)sizeof(nint)));
			Guid val = riid;
			nint num = default(nint);
			int result = delegate*(client, &val, &num);
			service = num;
			return result;
		}

		private unsafe static int CaptureClientGetBuffer(nint client, out nint data, out uint numFrames, out uint flags, out ulong devPos, out ulong qpcPos)
		{
			nint num = default(nint);
			uint num2 = default(uint);
			uint num3 = default(uint);
			ulong num4 = default(ulong);
			ulong num5 = default(ulong);
			int result = ((delegate* unmanaged[Stdcall]<nint, nint*, uint*, uint*, ulong*, ulong*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)3 * (nint)sizeof(nint))))(client, &num, &num2, &num3, &num4, &num5);
			data = num;
			numFrames = num2;
			flags = num3;
			devPos = num4;
			qpcPos = num5;
			return result;
		}

		private unsafe static int CaptureClientReleaseBuffer(nint client, uint numFrames)
		{
			return ((delegate* unmanaged[Stdcall]<nint, uint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)4 * (nint)sizeof(nint))))(client, numFrames);
		}

		private unsafe static int CaptureClientGetNextPacketSize(nint client, out uint numFrames)
		{
			uint num = default(uint);
			int result = ((delegate* unmanaged[Stdcall]<nint, uint*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)client) + (nint)5 * (nint)sizeof(nint))))(client, &num);
			numFrames = num;
			return result;
		}
	}
	internal static class AudioRingBuffer
	{
		internal static void WriteLatest(global::System.Span<float> samples, float[] ring, ref long writePosition)
		{
			int num = ring.Length;
			long num2 = Volatile.Read(ref writePosition);
			int num3 = Math.Min(samples.Length, num);
			int num4 = (int)(num2 % num);
			int num5 = Math.Min(num3, num - num4);
			samples.Slice(0, num5).CopyTo(MemoryExtensions.AsSpan<float>(ring, num4, num5));
			if (num5 < num3)
			{
				samples.Slice(num5, num3 - num5).CopyTo(MemoryExtensions.AsSpan<float>(ring, 0, num3 - num5));
			}
			Volatile.Write(ref writePosition, num2 + num3);
		}

		internal static int Read(float[] ring, long writePosition, ref long readPosition, float[] output, int maxSamples)
		{
			long num = ClampReadPosition(ring, writePosition, ref readPosition);
			if (num <= 0)
			{
				return 0;
			}
			int num2 = (int)Math.Min(num, (long)maxSamples);
			int num3 = ring.Length;
			int num4 = (int)(readPosition % num3);
			int num5 = Math.Min(num2, num3 - num4);
			global::System.Array.Copy((global::System.Array)ring, num4, (global::System.Array)output, 0, num5);
			if (num5 < num2)
			{
				global::System.Array.Copy((global::System.Array)ring, 0, (global::System.Array)output, num5, num2 - num5);
			}
			readPosition += num2;
			return num2;
		}

		internal static int Read(float[] ring, long writePosition, ref long readPosition, global::System.Span<float> output)
		{
			long num = ClampReadPosition(ring, writePosition, ref readPosition);
			if (num <= 0)
			{
				return 0;
			}
			int num2 = (int)Math.Min(num, (long)output.Length);
			int num3 = ring.Length;
			int num4 = (int)(readPosition % num3);
			int num5 = Math.Min(num2, num3 - num4);
			MemoryExtensions.AsSpan<float>(ring, num4, num5).CopyTo(output);
			if (num5 < num2)
			{
				MemoryExtensions.AsSpan<float>(ring, 0, num2 - num5).CopyTo(output.Slice(num5));
			}
			readPosition += num2;
			return num2;
		}

		private static long ClampReadPosition(float[] ring, long writePosition, ref long readPosition)
		{
			long num = writePosition - readPosition;
			if (num > ring.Length)
			{
				readPosition = writePosition - ring.Length;
				num = ring.Length;
			}
			return num;
		}
	}
	public sealed class FfmpegEncoder : ILiveStreamSource, global::System.IDisposable
	{
		private struct VP_CONTENT_DESC
		{
			public int InputFrameFormat;

			public uint InputFrameRateNum;

			public uint InputFrameRateDen;

			public uint InputWidth;

			public uint InputHeight;

			public uint OutputFrameRateNum;

			public uint OutputFrameRateDen;

			public uint OutputWidth;

			public uint OutputHeight;

			public int Usage;
		}

		private struct VP_INPUT_VIEW_DESC
		{
			public uint FourCC;

			public int ViewDimension;

			public uint MipSlice;

			public uint ArraySlice;
		}

		private struct VP_OUTPUT_VIEW_DESC
		{
			public int ViewDimension;

			public uint MipSlice;

			public uint FirstArraySlice;

			public uint ArraySize;
		}

		private struct VP_STREAM
		{
			public int Enable;

			public uint OutputIndex;

			public uint InputFrameOrField;

			public uint PastFrames;

			public uint FutureFrames;

			private uint _pad;

			public nint ppPastSurfaces;

			public nint pInputSurface;

			public nint ppFutureSurfaces;

			public nint ppPastSurfacesRight;

			public nint pInputSurfaceRight;

			public nint ppFutureSurfacesRight;
		}

		private struct VP_COLOR_SPACE
		{
			public uint Value;
		}

		private struct TEX2D_DESC
		{
			public uint Width;

			public uint Height;

			public uint MipLevels;

			public uint ArraySize;

			public int Format;

			public uint SampleCount;

			public uint SampleQuality;

			public int Usage;

			public uint BindFlags;

			public uint CPUAccessFlags;

			public uint MiscFlags;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static avio_alloc_context_write_packet <0>__WriteCallback;
		}

		private readonly int _streamId;

		private bool _initialized;

		private bool _initFailed;

		private unsafe AVCodecContext* _codecCtx;

		private unsafe AVFormatContext* _fmtCtx;

		private unsafe AVIOContext* _ioCtx;

		private unsafe AVStream* _stream;

		private unsafe AVBufferRef* _hwDeviceCtx;

		private unsafe AVBufferRef* _hwFramesCtx;

		private unsafe AVFrame* _hwFrame;

		private unsafe AVPacket* _pkt;

		private unsafe AVCodecContext* _audioCodecCtx;

		private unsafe AVStream* _audioStream;

		private unsafe AVFrame* _audioFrame;

		private AudioCapture _audioCapture;

		private long _audioReadPos;

		private long _audioSamplesEncoded;

		private long _lastAudioPts = -1L;

		private float[] _audioScratch;

		private Thread _audioEncodeThread;

		private unsafe AVPacket* _audioPkt;

		private byte[] _ringBuffer;

		private long _ringWritePos;

		private readonly object _ringLock = new object();

		private readonly object _muxerLock = new object();

		private readonly SemaphoreSlim _dataAvailable = new SemaphoreSlim(0, 2147483647);

		private uint _sourceWidth;

		private uint _sourceHeight;

		private uint _width;

		private uint _height;

		private int _totalFrames;

		private const int RING_SIZE = 16777216;

		private const int AVIO_BUFFER_SIZE = 65536;

		private volatile bool _disposed;

		private int _disposeGuard;

		private nint _deviceContext;

		private static readonly object _encoderD3dContextLock = new object();

		private object _d3dContextLock;

		private Thread _encodeThread;

		private volatile int _initStarted;

		private int _nativeDisposed;

		private readonly AutoResetEvent _encodeEvent = new AutoResetEvent(false);

		private volatile nint _pendingTexture;

		private volatile uint _pendingWidth;

		private volatile uint _pendingHeight;

		private bool _needsVideoProcessor;

		private bool _needsGpuScale;

		private nint _vpDevice;

		private nint _vpContext;

		private nint _vpEnum;

		private nint _vpProcessor;

		private nint _vpOutputView;

		private nint _vpOutputTexture;

		private nint _vpInputView;

		private nint _vpInputTexture;

		private long _startTicks;

		private long _lastVideoPts = -1L;

		private long _lastKeyframeRingPos = -1L;

		private long _readerOverrunEvents;

		private long _readerOverrunMaxBacklogBytes;

		private long _readerLastOverrunLogTicks;

		private avio_alloc_context_write_packet _writeCallbackDelegate;

		private GCHandle _selfHandle;

		private volatile bool _rtspBroken;

		private nint _keepAliveTexture;

		private uint _keepAliveW;

		private uint _keepAliveH;

		private long _lastEncodeTicks;

		private long _nextKeepAliveTicks;

		private int _keepAliveFramesEncoded;

		private int _keepAliveFps = 60;

		private long _readerLiveCatchupEvents;

		private long _readerLastCatchupLogTicks;

		private long _audioLiveCatchupEvents;

		private long _audioLastCatchupLogTicks;

		private static bool _ffmpegPathSet;

		private readonly object _initLock = new object();

		private static readonly object _ffmpegInitLock = new object();

		private readonly string _rtspUrl;

		private static readonly Guid IID_ID3D11VideoDevice = new Guid(283921755u, (ushort)38746, (ushort)18057, (byte)185, (byte)228, (byte)208, (byte)170, (byte)195, (byte)15, (byte)227, (byte)51);

		private static readonly Guid IID_ID3D11VideoContext = new Guid(1643256901, (short)15374, (short)19060, (byte)156, (byte)234, (byte)103, (byte)16, (byte)13, (byte)154, (byte)213, (byte)228);

		public bool IsInitialized => _initialized;

		public bool IsRunning => _initialized;

		public bool HasReadableVideoKeyframe
		{
			get
			{
				if (_rtspUrl != null)
				{
					if (_initialized)
					{
						return !_rtspBroken;
					}
					return false;
				}
				return HasReadableVideoKeyframeAtOrAfter(0L);
			}
		}

		public string ReadableStreamState
		{
			get
			{
				if (_rtspUrl != null)
				{
					return $"rtsp initialized={_initialized} broken={_rtspBroken} lastVideoPts={Interlocked.Read(ref _lastVideoPts)} frames={_totalFrames}";
				}
				lock (_ringLock)
				{
					long num = Interlocked.Read(ref _lastKeyframeRingPos);
					return $"http initialized={_initialized} ringReady={_ringBuffer != null} keyframePos={num} writePos={_ringWritePos} lastVideoPts={Interlocked.Read(ref _lastVideoPts)} frames={_totalFrames}";
				}
			}
		}

		public long CurrentWritePosition
		{
			get
			{
				lock (_ringLock)
				{
					return _ringWritePos;
				}
			}
		}

		private unsafe void SetupAudioStream()
		{
			//IL_0070: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			AVCodec* ptr = ffmpeg.avcodec_find_encoder((AVCodecID)86018);
			if (ptr == null)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] AAC encoder not found, audio disabled");
				return;
			}
			_audioCodecCtx = ffmpeg.avcodec_alloc_context3(ptr);
			((AVCodecContext)_audioCodecCtx).sample_rate = 48000;
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_audioCodecCtx).ch_layout, new AVChannelLayout
			{
				order = (AVChannelOrder)1,
				nb_channels = 2,
				u = new AVChannelLayout_u
				{
					mask = ffmpeg.AV_CH_LAYOUT_STEREO
				}
			});
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_audioCodecCtx).sample_fmt, (AVSampleFormat)8);
			((AVCodecContext)_audioCodecCtx).bit_rate = 128000L;
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_audioCodecCtx).time_base, new AVRational
			{
				num = 1,
				den = 48000
			});
			((AVCodecContext)_audioCodecCtx).flags |= 4194304;
			int num = ffmpeg.avcodec_open2(_audioCodecCtx, ptr, (AVDictionary**)null);
			if (num < 0)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Audio codec open failed: {FfmpegError(num)}");
				return;
			}
			_audioStream = ffmpeg.avformat_new_stream(_fmtCtx, (AVCodec*)null);
			ffmpeg.avcodec_parameters_from_context(((AVStream)_audioStream).codecpar, _audioCodecCtx);
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVStream)_audioStream).time_base, ((AVCodecContext)_audioCodecCtx).time_base);
			_audioFrame = ffmpeg.av_frame_alloc();
			((AVFrame)_audioFrame).nb_samples = ((AVCodecContext)_audioCodecCtx).frame_size;
			((AVFrame)_audioFrame).format = 8;
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVFrame)_audioFrame).ch_layout, ((AVCodecContext)_audioCodecCtx).ch_layout);
			((AVFrame)_audioFrame).sample_rate = 48000;
			ffmpeg.av_frame_get_buffer(_audioFrame, 0);
			_audioScratch = new float[96000];
			_audioPkt = ffmpeg.av_packet_alloc();
			Log.Msg($"[FfmpegEnc:{_streamId}] Audio stream added: AAC 48kHz stereo 128kbps");
		}

		private unsafe void StartAudioEncodeThreadIfReady()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if (_audioCodecCtx != null && _audioFrame != null && _audioPkt != null && _audioCapture != null && _audioCapture.IsCapturing && _audioEncodeThread == null)
			{
				_audioEncodeThread = new Thread(new ThreadStart(AudioEncodeLoop))
				{
					Name = $"FfmpegEnc:{_streamId}:Audio",
					IsBackground = true
				};
				_audioEncodeThread.Start();
				Log.Msg($"[FfmpegEnc:{_streamId}] Audio encode thread launched after muxer header");
			}
		}

		private static int GetStreamFps()
		{
			return Math.Clamp(DesktopBuddyMod.RuntimeStreamFps, 1, 240);
		}

		private void AudioEncodeLoop()
		{
			Log.Msg($"[FfmpegEnc:{_streamId}] Audio encode thread started");
			while (!_disposed)
			{
				Thread.Sleep(33);
				if (_disposed)
				{
					break;
				}
				try
				{
					EncodeAudio();
				}
				catch (global::System.Exception ex)
				{
					if (!_disposed)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] Audio encode error: {ex.Message}");
					}
				}
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] Audio encode thread stopped");
		}

		private unsafe void EncodeAudio()
		{
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			if (_audioScratch == null || _audioFrame == null || _audioPkt == null)
			{
				return;
			}
			int frame_size = ((AVCodecContext)_audioCodecCtx).frame_size;
			int num = 2;
			int num2 = frame_size * num;
			int maxSamples = Math.Min(_audioScratch.Length, num2 * 4);
			int num3 = num2 * 4;
			int num4 = num2 * 12;
			long writePosition = _audioCapture.WritePosition;
			long num5 = writePosition - _audioReadPos;
			if (num5 <= 0)
			{
				return;
			}
			if (num5 > num4)
			{
				long droppedSamples = num5 - num3;
				_audioReadPos = writePosition - num3;
				_audioReadPos -= _audioReadPos % num2;
				num5 = writePosition - _audioReadPos;
				RecordAudioLiveCatchup(droppedSamples, num5, num);
			}
			int num6 = _audioCapture.ReadSamples(_audioScratch, maxSamples, ref _audioReadPos);
			if (num6 <= 0)
			{
				return;
			}
			long timestamp = Stopwatch.GetTimestamp();
			double num7 = ((_startTicks != 0L) ? ((double)(timestamp - _startTicks) / (double)Stopwatch.Frequency) : 0.0);
			long num8 = Math.Max(0L, (long)(num7 * 48000.0));
			long num9 = Math.Max(0L, num8 - num6 / num);
			int i;
			for (i = 0; i + num2 <= num6; i += num2)
			{
				ffmpeg.av_frame_make_writable(_audioFrame);
				((AVFrame)_audioFrame).nb_samples = frame_size;
				float* ptr = (float*)((byte_ptrArray8)(&((AVFrame)_audioFrame).data))[0u];
				float* ptr2 = (float*)((byte_ptrArray8)(&((AVFrame)_audioFrame).data))[1u];
				fixed (float* ptr3 = &_audioScratch[i])
				{
					for (int j = 0; j < frame_size; j++)
					{
						ptr[j] = ptr3[j * num];
						ptr2[j] = ptr3[j * num + 1];
					}
				}
				long num10 = num9 + i / num;
				if (num10 <= _lastAudioPts)
				{
					num10 = _lastAudioPts + frame_size;
				}
				((AVFrame)_audioFrame).pts = num10;
				_lastAudioPts = num10;
				_audioSamplesEncoded += frame_size;
				int num11 = ffmpeg.avcodec_send_frame(_audioCodecCtx, _audioFrame);
				if (num11 < 0)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Audio send_frame failed: {FfmpegError(num11)}");
					break;
				}
				while (true)
				{
					num11 = ffmpeg.avcodec_receive_packet(_audioCodecCtx, _audioPkt);
					if (num11 == ffmpeg.AVERROR<int>(ffmpeg.EAGAIN) || num11 == ffmpeg.AVERROR_EOF || num11 < 0)
					{
						break;
					}
					((AVPacket)_audioPkt).stream_index = ((AVStream)_audioStream).index;
					ffmpeg.av_packet_rescale_ts(_audioPkt, ((AVCodecContext)_audioCodecCtx).time_base, ((AVStream)_audioStream).time_base);
					lock (_muxerLock)
					{
						if (!_rtspBroken)
						{
							num11 = ffmpeg.av_interleaved_write_frame(_fmtCtx, _audioPkt);
							if (num11 < 0)
							{
								Log.Msg($"[FfmpegEnc:{_streamId}] av_interleaved_write_frame (audio) failed: {FfmpegError(num11)}");
								if (_rtspUrl != null)
								{
									_rtspBroken = true;
								}
							}
						}
					}
					ffmpeg.av_packet_unref(_audioPkt);
				}
			}
			int num12 = num6 - i;
			if (num12 > 0)
			{
				_audioReadPos -= num12;
			}
		}

		private void RecordAudioLiveCatchup(long droppedSamples, long remainingSamples, int channels)
		{
			long num = Interlocked.Increment(ref _audioLiveCatchupEvents);
			long timestamp = Stopwatch.GetTimestamp();
			long num2 = Interlocked.Read(ref _audioLastCatchupLogTicks);
			if (num == 1 || num2 == 0L || (double)(timestamp - num2) / (double)Stopwatch.Frequency >= 30.0)
			{
				Interlocked.Exchange(ref _audioLastCatchupLogTicks, timestamp);
				Log.Msg($"[FfmpegEnc:{_streamId}] Audio live catch-up summary: dropped {(double)droppedSamples / (double)(48000 * channels):F3}s, remaining {(double)remainingSamples / (double)(48000 * channels):F3}s, events={num}");
			}
		}

		public bool HasReadableVideoKeyframeAtOrAfter(long minimumKeyframePos)
		{
			if (_rtspUrl != null)
			{
				if (_initialized)
				{
					return !_rtspBroken;
				}
				return false;
			}
			lock (_ringLock)
			{
				long num = Interlocked.Read(ref _lastKeyframeRingPos);
				return _initialized && _ringBuffer != null && num >= minimumKeyframePos && num >= 0 && num < _ringWritePos && num >= _ringWritePos - 16777216;
			}
		}

		public string GetReaderDiagnostics(long readPos, bool aligned)
		{
			lock (_ringLock)
			{
				long ringWritePos = _ringWritePos;
				long num = ringWritePos - readPos;
				long num2 = Interlocked.Read(ref _lastKeyframeRingPos);
				long num3 = ((num2 >= 0) ? (ringWritePos - num2) : (-1));
				return $"readPos={readPos} writePos={ringWritePos} backlog={num} aligned={aligned} latestKeyframe={num2} keyframeAgeBytes={num3} ringSize={16777216} frames={_totalFrames} keepAlive={_keepAliveFramesEncoded}";
			}
		}

		public void Stop()
		{
			_disposed = true;
			_initialized = false;
			try
			{
				((EventWaitHandle)_encodeEvent).Set();
			}
			catch
			{
			}
		}

		public FfmpegEncoder(int streamId, string rtspUrl = null)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			_streamId = streamId;
			_rtspUrl = rtspUrl;
		}

		private unsafe void SetupHardwareContext(nint d3dDevice, AVPixelFormat swFormat)
		{
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			_hwDeviceCtx = ffmpeg.av_hwdevice_ctx_alloc((AVHWDeviceType)7);
			if (_hwDeviceCtx == null)
			{
				throw new global::System.Exception("av_hwdevice_ctx_alloc failed");
			}
			AVHWDeviceContext* data = (AVHWDeviceContext*)((AVBufferRef)_hwDeviceCtx).data;
			AVD3D11VADeviceContext* hwctx = (AVD3D11VADeviceContext*)((AVHWDeviceContext)data).hwctx;
			Marshal.AddRef((global::System.IntPtr)d3dDevice);
			((AVD3D11VADeviceContext)hwctx).device = (ID3D11Device*)d3dDevice;
			Log.Msg($"[FfmpegEnc:{_streamId}] av_hwdevice_ctx_init: calling...");
			int num = ffmpeg.av_hwdevice_ctx_init(_hwDeviceCtx);
			Log.Msg($"[FfmpegEnc:{_streamId}] av_hwdevice_ctx_init: returned {num}");
			if (num < 0)
			{
				throw new global::System.Exception("av_hwdevice_ctx_init failed: " + FfmpegError(num));
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] D3D11VA hardware context initialized with device 0x{d3dDevice:X}");
			_hwFramesCtx = ffmpeg.av_hwframe_ctx_alloc(_hwDeviceCtx);
			if (_hwFramesCtx == null)
			{
				throw new global::System.Exception("av_hwframe_ctx_alloc failed");
			}
			AVHWFramesContext* data2 = (AVHWFramesContext*)((AVBufferRef)_hwFramesCtx).data;
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVHWFramesContext)data2).format, (AVPixelFormat)171);
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVHWFramesContext)data2).sw_format, swFormat);
			((AVHWFramesContext)data2).width = (int)_width;
			((AVHWFramesContext)data2).height = (int)_height;
			((AVHWFramesContext)data2).initial_pool_size = 0;
			Log.Msg($"[FfmpegEnc:{_streamId}] av_hwframe_ctx_init: calling...");
			int num2 = ffmpeg.av_hwframe_ctx_init(_hwFramesCtx);
			Log.Msg($"[FfmpegEnc:{_streamId}] av_hwframe_ctx_init: returned {num2}");
			if (num2 < 0)
			{
				throw new global::System.Exception("av_hwframe_ctx_init failed: " + FfmpegError(num2));
			}
			((AVCodecContext)_codecCtx).hw_frames_ctx = ffmpeg.av_buffer_ref(_hwFramesCtx);
			Log.Msg($"[FfmpegEnc:{_streamId}] Hardware frames context initialized: {_width}x{_height} {swFormat}");
		}

		public unsafe bool Initialize(nint d3dDevice, uint width, uint height, AudioCapture audioCapture = null, object d3dContextLock = null)
		{
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_04af: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04be: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a33: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a3d: Expected O, but got Unknown
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Expected O, but got Unknown
			lock (_initLock)
			{
				if (_initialized)
				{
					return true;
				}
				if (_initFailed || _disposed)
				{
					return false;
				}
				_d3dContextLock = d3dContextLock ?? _encoderD3dContextLock;
				try
				{
					SetFfmpegPath();
					if (!_ffmpegPathSet)
					{
						_initFailed = true;
						return false;
					}
					_sourceWidth = width & 0xFFFFFFFEu;
					_sourceHeight = height & 0xFFFFFFFEu;
					CalculateEncoderSize(_sourceWidth, _sourceHeight, out _width, out _height);
					_needsGpuScale = _width != _sourceWidth || _height != _sourceHeight;
					if (_width < 128 || _height < 128)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] Window too small for encoding: source={_sourceWidth}x{_sourceHeight}, encode={_width}x{_height} (min 128x128)");
						_initFailed = true;
						return false;
					}
					int num = (_keepAliveFps = GetStreamFps());
					Log.Msg($"[FfmpegEnc:{_streamId}] Initializing: source={_sourceWidth}x{_sourceHeight}, encode={_width}x{_height}, gpuScale={_needsGpuScale}, nominal encoder rate {num}fps, keepalive {GetKeepAliveFps()}fps (capture remains event-driven)");
					uint sharedD3dAdapterVendorId = WgcCapture.SharedD3dAdapterVendorId;
					string[] encoderPreference = GetEncoderPreference(sharedD3dAdapterVendorId);
					Log.Msg($"[FfmpegEnc:{_streamId}] Encoder preference for adapter vendor=0x{sharedD3dAdapterVendorId:X4}: {string.Join(", ", encoderPreference)}");
					AVCodec* ptr = null;
					string text = null;
					int num2 = -1;
					string[] array = encoderPreference;
					foreach (string text2 in array)
					{
						ptr = ffmpeg.avcodec_find_encoder_by_name(text2);
						if (ptr == null)
						{
							Log.Msg($"[FfmpegEnc:{_streamId}] {text2} not available");
							continue;
						}
						Log.Msg($"[FfmpegEnc:{_streamId}] Trying {text2}...");
						if (_codecCtx != null)
						{
							AVCodecContext* codecCtx = _codecCtx;
							ffmpeg.avcodec_free_context(&codecCtx);
							_codecCtx = null;
						}
						if (_hwFramesCtx != null)
						{
							AVBufferRef* hwFramesCtx = _hwFramesCtx;
							ffmpeg.av_buffer_unref(&hwFramesCtx);
							_hwFramesCtx = null;
						}
						if (_hwDeviceCtx != null)
						{
							AVBufferRef* hwDeviceCtx = _hwDeviceCtx;
							ffmpeg.av_buffer_unref(&hwDeviceCtx);
							_hwDeviceCtx = null;
						}
						_codecCtx = ffmpeg.avcodec_alloc_context3(ptr);
						if (_codecCtx == null)
						{
							continue;
						}
						((AVCodecContext)_codecCtx).width = (int)_width;
						((AVCodecContext)_codecCtx).height = (int)_height;
						global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_codecCtx).time_base, new AVRational
						{
							num = 1,
							den = 90000
						});
						global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_codecCtx).framerate, new AVRational
						{
							num = num,
							den = 1
						});
						long num3 = (long)Math.Max(1, DesktopBuddyMod.RuntimeBitrateMbps) * 1000000L;
						bool flag = text2.Contains("amf");
						long rc_max_rate = (long)((double)num3 * 1.2);
						int rc_buffer_size = (int)Math.Clamp(num3 / 4, 500000L, 2147483647L);
						((AVCodecContext)_codecCtx).max_b_frames = 0;
						global::System.Runtime.CompilerServices.Unsafe.Write(&((AVCodecContext)_codecCtx).pix_fmt, (AVPixelFormat)171);
						((AVCodecContext)_codecCtx).flags |= 4718592;
						((AVCodecContext)_codecCtx).gop_size = num;
						((AVCodecContext)_codecCtx).bit_rate = num3;
						((AVCodecContext)_codecCtx).rc_max_rate = rc_max_rate;
						((AVCodecContext)_codecCtx).rc_buffer_size = rc_buffer_size;
						AVPixelFormat swFormat = (AVPixelFormat)(flag ? 23 : 28);
						try
						{
							WithD3dContextLock((Action)delegate
							{
								//IL_0017: Unknown result type (might be due to invalid IL or missing references)
								SetupHardwareContext(d3dDevice, swFormat);
							});
						}
						catch (global::System.Exception ex)
						{
							Log.Msg($"[FfmpegEnc:{_streamId}] {text2} setup failed: {ex.Message}");
							num2 = -1;
							continue;
						}
						AVDictionary* ptr2 = null;
						if (text2.Contains("nvenc"))
						{
							ffmpeg.av_dict_set(&ptr2, "preset", "p1", 0);
							ffmpeg.av_dict_set(&ptr2, "tune", "ull", 0);
							ffmpeg.av_dict_set(&ptr2, "rc", "vbr", 0);
							ffmpeg.av_dict_set(&ptr2, "zerolatency", "1", 0);
							ffmpeg.av_dict_set(&ptr2, "delay", "0", 0);
							ffmpeg.av_dict_set(&ptr2, "rc-lookahead", "0", 0);
							ffmpeg.av_dict_set(&ptr2, "forced-idr", "1", 0);
							ffmpeg.av_dict_set(&ptr2, "repeat-headers", "1", 0);
						}
						else if (flag)
						{
							ffmpeg.av_dict_set(&ptr2, "usage", "lowlatency_high_quality", 0);
							ffmpeg.av_dict_set(&ptr2, "rc", "vbr_peak", 0);
							ffmpeg.av_dict_set(&ptr2, "header_insertion_mode", "idr", 0);
						}
						Log.Msg($"[FfmpegEnc:{_streamId}] avcodec_open2: calling...");
						num2 = ffmpeg.avcodec_open2(_codecCtx, ptr, &ptr2);
						Log.Msg($"[FfmpegEnc:{_streamId}] avcodec_open2: returned {num2} ({((num2 < 0) ? FfmpegError(num2) : "ok")})");
						ffmpeg.av_dict_free(&ptr2);
						if (num2 >= 0)
						{
							text = text2;
							_needsVideoProcessor = text2.Contains("amf");
							break;
						}
						Log.Msg($"[FfmpegEnc:{_streamId}] {text2} failed: {FfmpegError(num2)}");
					}
					if (num2 < 0 || text == null)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] No GPU encoder available (need NVIDIA, AMD, or Intel GPU)");
						if (_codecCtx != null)
						{
							AVCodecContext* codecCtx2 = _codecCtx;
							ffmpeg.avcodec_free_context(&codecCtx2);
							_codecCtx = null;
						}
						if (_hwFramesCtx != null)
						{
							AVBufferRef* hwFramesCtx2 = _hwFramesCtx;
							ffmpeg.av_buffer_unref(&hwFramesCtx2);
							_hwFramesCtx = null;
						}
						if (_hwDeviceCtx != null)
						{
							AVBufferRef* hwDeviceCtx2 = _hwDeviceCtx;
							ffmpeg.av_buffer_unref(&hwDeviceCtx2);
							_hwDeviceCtx = null;
						}
						_initFailed = true;
						return false;
					}
					Log.Msg($"[FfmpegEnc:{_streamId}] Codec opened: {text}, fps={num}, gop={((AVCodecContext)_codecCtx).gop_size}");
					_hwFrame = ffmpeg.av_frame_alloc();
					_pkt = ffmpeg.av_packet_alloc();
					_audioCapture = audioCapture;
					_startTicks = Stopwatch.GetTimestamp();
					_audioReadPos = _audioCapture?.WritePosition ?? 0;
					_audioSamplesEncoded = 0L;
					_lastAudioPts = -1L;
					SetupMuxer();
					StartAudioEncodeThreadIfReady();
					AVHWDeviceContext* data = (AVHWDeviceContext*)((AVBufferRef)_hwDeviceCtx).data;
					AVD3D11VADeviceContext* hwctx = (AVD3D11VADeviceContext*)((AVHWDeviceContext)data).hwctx;
					_deviceContext = (nint)((AVD3D11VADeviceContext)hwctx).device_context;
					if (_needsVideoProcessor || _needsGpuScale)
					{
						WithD3dContextLock((Action)delegate
						{
							SetupVideoProcessor(d3dDevice, _sourceWidth, _sourceHeight, _width, _height, _needsVideoProcessor);
						});
					}
					if (_rtspUrl == null)
					{
						_ringBuffer = new byte[16777216];
						_ringWritePos = 0L;
						Interlocked.Exchange(ref _lastKeyframeRingPos, -1L);
					}
					if (_disposed)
					{
						return false;
					}
					_initialized = true;
					Log.Msg($"[FfmpegEnc:{_streamId}] Ready: {_width}x{_height} {text}");
					return true;
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Initialize FAILED: {ex2}");
					_initFailed = true;
					return false;
				}
			}
		}

		public void StartInitializeAsync(nint d3dDevice, uint width, uint height, AudioCapture audioCapture = null, Action startAudio = null, object d3dContextLock = null)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			if (Interlocked.Exchange(ref _initStarted, 1) != 0)
			{
				return;
			}
			_encodeThread = new Thread((ThreadStart)delegate
			{
				try
				{
					try
					{
						Action obj = startAudio;
						if (obj != null)
						{
							obj.Invoke();
						}
					}
					catch (global::System.Exception ex)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] Audio start before init failed: {ex}");
					}
					if (Initialize(d3dDevice, width, height, audioCapture, d3dContextLock))
					{
						EncodeLoop();
					}
				}
				finally
				{
					DisposeNativeResources();
				}
			})
			{
				Name = $"FfmpegEnc:{_streamId}:Encoder",
				IsBackground = true
			};
			_encodeThread.Start();
		}

		private static void CalculateEncoderSize(uint sourceWidth, uint sourceHeight, out uint encoderWidth, out uint encoderHeight)
		{
			encoderWidth = sourceWidth & 0xFFFFFFFEu;
			encoderHeight = sourceHeight & 0xFFFFFFFEu;
			uint num = (uint)(DesktopBuddyMod.RuntimeMaxStreamResolution & -2);
			uint num2 = Math.Max(encoderWidth, encoderHeight);
			if (num2 > num)
			{
				double num3 = (double)num / (double)num2;
				encoderWidth = Math.Max(2u, (uint)Math.Floor((double)encoderWidth * num3) & 0xFFFFFFFEu);
				encoderHeight = Math.Max(2u, (uint)Math.Floor((double)encoderHeight * num3) & 0xFFFFFFFEu);
			}
		}

		private static string[] GetEncoderPreference(uint adapterVendorId)
		{
			string configured = DesktopBuddyMod.NormalizeEncoderPreference(DesktopBuddyMod.RuntimeEncoderPreference);
			if (configured == "libx264" || configured == "libx265")
			{
				Log.Msg("[FfmpegEnc] Software encoder '" + configured + "' is configured, but CPU readback encoding is not enabled in this build; falling back to automatic GPU encoders");
				configured = "auto";
			}
			string[] array = adapterVendorId switch
			{
				4318u => new string[6] { "hevc_nvenc", "h264_nvenc", "hevc_qsv", "h264_qsv", "hevc_amf", "h264_amf" }, 
				4098u => new string[6] { "hevc_amf", "h264_amf", "hevc_qsv", "h264_qsv", "hevc_nvenc", "h264_nvenc" }, 
				32902u => new string[6] { "hevc_qsv", "h264_qsv", "hevc_nvenc", "h264_nvenc", "hevc_amf", "h264_amf" }, 
				_ => new string[6] { "hevc_qsv", "h264_qsv", "hevc_nvenc", "hevc_amf", "h264_nvenc", "h264_amf" }, 
			};
			if (configured == "auto")
			{
				return array;
			}
			return Enumerable.ToArray<string>(Enumerable.Concat<string>((global::System.Collections.Generic.IEnumerable<string>)new string[1] { configured }, Enumerable.Where<string>((global::System.Collections.Generic.IEnumerable<string>)array, (Func<string, bool>)((string name) => !string.Equals(name, configured, (StringComparison)5)))));
		}

		public static void SetFfmpegPath()
		{
			lock (_ffmpegInitLock)
			{
				if (!_ffmpegPathSet)
				{
					string text = FindFfmpegDlls();
					if (text == null)
					{
						Log.Msg("[FFmpeg] FATAL: Could not find FFmpeg shared libraries (avcodec, avformat, avutil)");
						return;
					}
					ffmpeg.RootPath = text;
					DynamicallyLoadedBindings.Initialize();
					Log.Msg("[FFmpeg] Library path: " + text);
					uint num = ffmpeg.avcodec_version();
					Log.Msg($"[FFmpeg] avcodec version: {num >> 16}.{(num >> 8) & 0xFF}.{num & 0xFF}");
					_ffmpegPathSet = true;
				}
			}
		}

		public static string FindFfmpegDlls()
		{
			string fullPath = Path.GetFullPath(DesktopBuddyRuntimePaths.GetDirectory());
			if (File.Exists(Path.Combine(fullPath, "avcodec-62.dll")))
			{
				return fullPath;
			}
			Log.Msg("[FFmpeg] Missing FFmpeg libraries at " + fullPath);
			return null;
		}

		private unsafe static string FfmpegError(int error)
		{
			byte* ptr = stackalloc byte[256];
			ffmpeg.av_strerror(error, ptr, 256uL);
			return Marshal.PtrToStringAnsi((global::System.IntPtr)(nint)ptr) ?? $"error {error}";
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref _disposeGuard, 1) == 0)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose === START ===");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose ENTER stream={_streamId} initialized={_initialized} disposed={_disposed}");
				_initialized = false;
				_disposed = true;
				try
				{
					((EventWaitHandle)_encodeEvent).Set();
				}
				catch
				{
				}
				JoinThread(_encodeThread, "encoderThread");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose events START stream={_streamId}");
				try
				{
					_dataAvailable.Dispose();
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: dataAvailable dispose error: {ex.Message}");
				}
				try
				{
					((WaitHandle)_encodeEvent).Dispose();
				}
				catch
				{
				}
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose events DONE stream={_streamId}");
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose === DONE === {_totalFrames} total frames");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose EXIT stream={_streamId} totalFrames={_totalFrames}");
			}
		}

		private unsafe void DisposeNativeResources()
		{
			if (Interlocked.Exchange(ref _nativeDisposed, 1) != 0)
			{
				return;
			}
			Log.Msg($"[CleanupTrace] FfmpegEncoder.NativeCleanup ENTER stream={_streamId} thread={Thread.CurrentThread.ManagedThreadId}");
			_initialized = false;
			_disposed = true;
			try
			{
				JoinThread(_audioEncodeThread, "audioThread");
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: audio thread join error: {ex.Message}");
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: writing trailer");
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose trailer START stream={_streamId}");
			if (_fmtCtx != null)
			{
				try
				{
					ffmpeg.av_write_trailer(_fmtCtx);
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: trailer error: {ex2.Message}");
				}
			}
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose trailer DONE stream={_streamId}");
			Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing packets/audio frame");
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose packets/audio START stream={_streamId}");
			try
			{
				if (_pkt != null)
				{
					AVPacket* pkt = _pkt;
					ffmpeg.av_packet_free(&pkt);
					_pkt = null;
				}
			}
			catch (global::System.Exception ex3)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: pkt free error: {ex3.Message}");
				_pkt = null;
			}
			try
			{
				if (_audioPkt != null)
				{
					AVPacket* audioPkt = _audioPkt;
					ffmpeg.av_packet_free(&audioPkt);
					_audioPkt = null;
				}
			}
			catch (global::System.Exception ex4)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: audioPkt free error: {ex4.Message}");
				_audioPkt = null;
			}
			try
			{
				if (_audioFrame != null)
				{
					AVFrame* audioFrame = _audioFrame;
					ffmpeg.av_frame_free(&audioFrame);
					_audioFrame = null;
				}
			}
			catch (global::System.Exception ex5)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: audioFrame free error: {ex5.Message}");
				_audioFrame = null;
			}
			try
			{
				if (_audioCodecCtx != null)
				{
					AVCodecContext* audioCodecCtx = _audioCodecCtx;
					ffmpeg.avcodec_free_context(&audioCodecCtx);
					_audioCodecCtx = null;
				}
			}
			catch (global::System.Exception ex6)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: audioCodec free error: {ex6.Message}");
				_audioCodecCtx = null;
			}
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose packets/audio DONE stream={_streamId}");
			object d3dContextLock = _d3dContextLock;
			bool flag = false;
			if (d3dContextLock != null)
			{
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose D3D lock WAIT stream={_streamId}");
				Monitor.Enter(d3dContextLock);
				flag = true;
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose D3D lock ACQUIRED stream={_streamId}");
			}
			try
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing hardware frame/resources");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose hardware resources START stream={_streamId}");
				try
				{
					if (_hwFrame != null)
					{
						AVFrame* hwFrame = _hwFrame;
						ffmpeg.av_frame_free(&hwFrame);
						_hwFrame = null;
					}
				}
				catch (global::System.Exception ex7)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: hwFrame free error: {ex7.Message}");
					_hwFrame = null;
				}
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing VP resources");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose VP START stream={_streamId}");
				try
				{
					if (_vpInputView != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpInputView);
						_vpInputView = global::System.IntPtr.Zero;
					}
					if (_vpOutputView != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpOutputView);
						_vpOutputView = global::System.IntPtr.Zero;
					}
					if (_vpInputTexture != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpInputTexture);
						_vpInputTexture = global::System.IntPtr.Zero;
					}
					if (_vpOutputTexture != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpOutputTexture);
						_vpOutputTexture = global::System.IntPtr.Zero;
					}
					if (_vpProcessor != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpProcessor);
						_vpProcessor = global::System.IntPtr.Zero;
					}
					if (_vpEnum != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpEnum);
						_vpEnum = global::System.IntPtr.Zero;
					}
					if (_vpContext != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpContext);
						_vpContext = global::System.IntPtr.Zero;
					}
					if (_vpDevice != (nint)global::System.IntPtr.Zero)
					{
						Marshal.Release((global::System.IntPtr)_vpDevice);
						_vpDevice = global::System.IntPtr.Zero;
					}
				}
				catch (global::System.Exception ex8)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: VP cleanup error: {ex8.Message}");
				}
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose VP DONE stream={_streamId}");
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing codec contexts");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose codec contexts START stream={_streamId}");
				try
				{
					if (_codecCtx != null)
					{
						AVCodecContext* codecCtx = _codecCtx;
						ffmpeg.avcodec_free_context(&codecCtx);
						_codecCtx = null;
					}
				}
				catch (global::System.Exception ex9)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: codec free error: {ex9.Message}");
					_codecCtx = null;
				}
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose codec contexts DONE stream={_streamId}");
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing hw contexts");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose hw contexts START stream={_streamId}");
				try
				{
					if (_hwFramesCtx != null)
					{
						AVBufferRef* hwFramesCtx = _hwFramesCtx;
						ffmpeg.av_buffer_unref(&hwFramesCtx);
						_hwFramesCtx = null;
					}
				}
				catch (global::System.Exception ex10)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: hwFrames free error: {ex10.Message}");
					_hwFramesCtx = null;
				}
				try
				{
					if (_hwDeviceCtx != null)
					{
						AVBufferRef* hwDeviceCtx = _hwDeviceCtx;
						ffmpeg.av_buffer_unref(&hwDeviceCtx);
						_hwDeviceCtx = null;
					}
				}
				catch (global::System.Exception ex11)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: hwDevice free error: {ex11.Message}");
					_hwDeviceCtx = null;
				}
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose hw contexts DONE stream={_streamId}");
				ReleaseD3dTextureRef(Interlocked.Exchange(ref _pendingTexture, global::System.IntPtr.Zero), "pendingTexture");
				nint keepAliveTexture = _keepAliveTexture;
				_keepAliveTexture = global::System.IntPtr.Zero;
				ReleaseD3dTextureRef(keepAliveTexture, "keepAliveTexture");
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose hardware resources DONE stream={_streamId}");
			}
			finally
			{
				if (flag)
				{
					Monitor.Exit(d3dContextLock);
					Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose D3D lock EXIT stream={_streamId}");
				}
			}
			_audioCapture = null;
			Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: freeing format context");
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose format context START stream={_streamId}");
			try
			{
				if (_fmtCtx != null)
				{
					if (_rtspUrl != null)
					{
						if (((AVFormatContext)_fmtCtx).pb != null)
						{
							AVIOContext* pb = ((AVFormatContext)_fmtCtx).pb;
							ffmpeg.avio_closep(&pb);
							((AVFormatContext)_fmtCtx).pb = null;
						}
					}
					else if (((AVFormatContext)_fmtCtx).pb != null)
					{
						AVIOContext* pb2 = ((AVFormatContext)_fmtCtx).pb;
						ffmpeg.avio_context_free(&pb2);
						((AVFormatContext)_fmtCtx).pb = null;
					}
					ffmpeg.avformat_free_context(_fmtCtx);
					_fmtCtx = null;
				}
			}
			catch (global::System.Exception ex12)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] Dispose: fmtCtx free error: {ex12.Message}");
				_fmtCtx = null;
			}
			Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose format context DONE stream={_streamId}");
			if (((GCHandle)(ref _selfHandle)).IsAllocated)
			{
				((GCHandle)(ref _selfHandle)).Free();
			}
			Log.Msg($"[CleanupTrace] FfmpegEncoder.NativeCleanup EXIT stream={_streamId} thread={Thread.CurrentThread.ManagedThreadId}");
		}

		private void JoinThread(Thread thread, string name)
		{
			if (thread != null && thread != Thread.CurrentThread)
			{
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose {name}.Join START stream={_streamId}");
				thread.Join();
				Log.Msg($"[CleanupTrace] FfmpegEncoder.Dispose {name}.Join DONE stream={_streamId}");
			}
		}

		private void ReleaseD3dTextureRef(nint texture, string name)
		{
			if (texture == (nint)global::System.IntPtr.Zero)
			{
				return;
			}
			try
			{
				Marshal.Release((global::System.IntPtr)texture);
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] {name} release error: {ex.Message}");
			}
		}

		private unsafe void SetupMuxer()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			if (_rtspUrl != null)
			{
				SetupRtspMuxer();
				return;
			}
			_selfHandle = GCHandle.Alloc((object)this);
			AVFormatContext* ptr = null;
			int num = ffmpeg.avformat_alloc_output_context2(&ptr, (AVOutputFormat*)null, "mpegts", (string)null);
			if (num < 0 || ptr == null)
			{
				throw new global::System.Exception("avformat_alloc_output_context2 failed: " + FfmpegError(num));
			}
			_fmtCtx = ptr;
			byte* ptr2 = (byte*)ffmpeg.av_malloc(65536uL);
			object obj = <>O.<0>__WriteCallback;
			if (obj == null)
			{
				avio_alloc_context_write_packet val = WriteCallback;
				<>O.<0>__WriteCallback = val;
				obj = (object)val;
			}
			_writeCallbackDelegate = (avio_alloc_context_write_packet)obj;
			_ioCtx = ffmpeg.avio_alloc_context(ptr2, 65536, 1, (void*)GCHandle.ToIntPtr(_selfHandle), avio_alloc_context_read_packet_func.op_Implicit((avio_alloc_context_read_packet)null), avio_alloc_context_write_packet_func.op_Implicit(_writeCallbackDelegate), avio_alloc_context_seek_func.op_Implicit((avio_alloc_context_seek)null));
			if (_ioCtx == null)
			{
				throw new global::System.Exception("avio_alloc_context failed");
			}
			((AVFormatContext)_fmtCtx).pb = _ioCtx;
			((AVFormatContext)_fmtCtx).flags |= 640;
			((AVFormatContext)_fmtCtx).max_delay = 0;
			_stream = ffmpeg.avformat_new_stream(_fmtCtx, (AVCodec*)null);
			if (_stream == null)
			{
				throw new global::System.Exception("avformat_new_stream failed");
			}
			ffmpeg.avcodec_parameters_from_context(((AVStream)_stream).codecpar, _codecCtx);
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVStream)_stream).time_base, ((AVCodecContext)_codecCtx).time_base);
			if (_audioCapture != null && _audioCapture.IsCapturing)
			{
				SetupAudioStream();
			}
			AVDictionary* ptr3 = null;
			ffmpeg.av_dict_set(&ptr3, "mpegts_flags", "pat_pmt_at_frames", 0);
			ffmpeg.av_dict_set(&ptr3, "flush_packets", "1", 0);
			ffmpeg.av_dict_set(&ptr3, "muxdelay", "0", 0);
			ffmpeg.av_dict_set(&ptr3, "muxpreload", "0", 0);
			num = ffmpeg.avformat_write_header(_fmtCtx, &ptr3);
			ffmpeg.av_dict_free(&ptr3);
			if (num < 0)
			{
				throw new global::System.Exception("avformat_write_header failed: " + FfmpegError(num));
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] MPEG-TS muxer ready (in-process, no external ffmpeg)");
		}

		private unsafe void SetupRtspMuxer()
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			AVFormatContext* ptr = null;
			int num = ffmpeg.avformat_alloc_output_context2(&ptr, (AVOutputFormat*)null, "rtsp", _rtspUrl);
			if (num < 0 || ptr == null)
			{
				throw new global::System.Exception("avformat_alloc_output_context2 (rtsp) failed: " + FfmpegError(num));
			}
			_fmtCtx = ptr;
			_stream = ffmpeg.avformat_new_stream(_fmtCtx, (AVCodec*)null);
			if (_stream == null)
			{
				throw new global::System.Exception("avformat_new_stream (rtsp) failed");
			}
			ffmpeg.avcodec_parameters_from_context(((AVStream)_stream).codecpar, _codecCtx);
			global::System.Runtime.CompilerServices.Unsafe.Write(&((AVStream)_stream).time_base, ((AVCodecContext)_codecCtx).time_base);
			if (_audioCapture != null && _audioCapture.IsCapturing)
			{
				SetupAudioStream();
			}
			AVDictionary* ptr2 = null;
			ffmpeg.av_dict_set(&ptr2, "rtsp_transport", "tcp", 0);
			num = ffmpeg.avformat_write_header(_fmtCtx, &ptr2);
			ffmpeg.av_dict_free(&ptr2);
			if (num < 0)
			{
				throw new global::System.Exception("avformat_write_header (rtsp) failed: " + FfmpegError(num));
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] RTSP muxer ready: {_rtspUrl}");
		}

		private unsafe void RtspReconnect()
		{
			Log.Msg($"[FfmpegEnc:{_streamId}] RTSP broken, reconnecting in 3s...");
			Thread.Sleep(3000);
			if (_disposed)
			{
				return;
			}
			lock (_muxerLock)
			{
				try
				{
					if (_fmtCtx != null)
					{
						try
						{
							ffmpeg.av_write_trailer(_fmtCtx);
						}
						catch
						{
						}
						if (((AVFormatContext)_fmtCtx).pb != null)
						{
							AVIOContext* pb = ((AVFormatContext)_fmtCtx).pb;
							ffmpeg.avio_closep(&pb);
							((AVFormatContext)_fmtCtx).pb = null;
						}
						ffmpeg.avformat_free_context(_fmtCtx);
						_fmtCtx = null;
					}
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] RTSP cleanup error: {ex.Message}");
					_fmtCtx = null;
				}
				_stream = null;
				_audioStream = null;
				try
				{
					SetupRtspMuxer();
					_rtspBroken = false;
					Log.Msg($"[FfmpegEnc:{_streamId}] RTSP reconnected");
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] RTSP reconnect failed: {ex2.Message}");
				}
			}
		}

		private unsafe static int WriteCallback(void* opaque, byte* buf, int buf_size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			GCHandle val = GCHandle.FromIntPtr((global::System.IntPtr)(nint)opaque);
			return ((FfmpegEncoder)((GCHandle)(ref val)).Target).OnMpegTsData(buf, buf_size);
		}

		private unsafe int OnMpegTsData(byte* buf, int buf_size)
		{
			if (buf_size <= 0)
			{
				return 0;
			}
			lock (_ringLock)
			{
				int num = (int)(_ringWritePos % 16777216);
				int num2 = Math.Min(buf_size, 16777216 - num);
				Marshal.Copy((global::System.IntPtr)(nint)buf, _ringBuffer, num, num2);
				if (num2 < buf_size)
				{
					Marshal.Copy((global::System.IntPtr)(nint)(buf + num2), _ringBuffer, 0, buf_size - num2);
				}
				_ringWritePos += buf_size;
			}
			try
			{
				_dataAvailable.Release();
			}
			catch (SemaphoreFullException)
			{
			}
			return buf_size;
		}

		public global::System.Threading.Tasks.Task WaitForDataAsync(int timeoutMs)
		{
			return _dataAvailable.WaitAsync(Math.Max(1, timeoutMs));
		}

		public int ReadStream(byte[] buffer, ref long readPos, ref bool aligned, long minimumKeyframePos, out bool startsAtKeyframe)
		{
			startsAtKeyframe = false;
			lock (_ringLock)
			{
				long num = _ringWritePos - readPos;
				if (num <= 0)
				{
					return 0;
				}
				long num2 = Interlocked.Read(ref _lastKeyframeRingPos);
				if (!aligned)
				{
					long num3 = num2;
					if (num3 >= minimumKeyframePos && num3 >= 0 && num3 >= _ringWritePos - 16777216 && num3 < _ringWritePos)
					{
						readPos = num3;
						num = _ringWritePos - readPos;
						aligned = true;
						Log.Msg($"[FfmpegEnc:{_streamId}] Reader aligned to latest keyframe at ringPos={readPos}, liveWritePos={_ringWritePos}, backlog={num} bytes");
					}
					if (!aligned)
					{
						return 0;
					}
				}
				num = _ringWritePos - readPos;
				if (num > 16777216)
				{
					RecordReaderOverrun(readPos, _ringWritePos, num);
					return -1;
				}
				long maxHttpLiveBacklogBytes = GetMaxHttpLiveBacklogBytes();
				if (aligned && num > maxHttpLiveBacklogBytes)
				{
					long num4 = num2;
					if (num4 <= readPos || num4 < minimumKeyframePos || num4 < _ringWritePos - 16777216 || num4 >= _ringWritePos)
					{
						return 0;
					}
					long droppedBytes = num4 - readPos;
					readPos = num4;
					num = _ringWritePos - readPos;
					startsAtKeyframe = true;
					RecordReaderLiveCatchup(droppedBytes, num, maxHttpLiveBacklogBytes, readPos);
				}
				int num5 = (int)Math.Min(num, (long)buffer.Length);
				startsAtKeyframe = num2 >= 0 && readPos == num2;
				int num6 = (int)(readPos % 16777216);
				int num7 = Math.Min(num5, 16777216 - num6);
				Buffer.BlockCopy((global::System.Array)_ringBuffer, num6, (global::System.Array)buffer, 0, num7);
				if (num7 < num5)
				{
					Buffer.BlockCopy((global::System.Array)_ringBuffer, 0, (global::System.Array)buffer, num7, num5 - num7);
				}
				readPos += num5;
				return num5;
			}
		}

		private static long GetMaxHttpLiveBacklogBytes()
		{
			return Math.Clamp((long)Math.Max(1, DesktopBuddyMod.RuntimeBitrateMbps) * 1000000L / 16, 262144L, 2097152L);
		}

		private void RecordReaderLiveCatchup(long droppedBytes, long remainingBytes, long maxBacklogBytes, long readPos)
		{
			long num = Interlocked.Increment(ref _readerLiveCatchupEvents);
			long timestamp = Stopwatch.GetTimestamp();
			long num2 = Interlocked.Read(ref _readerLastCatchupLogTicks);
			if (num == 1 || num2 == 0L || (double)(timestamp - num2) / (double)Stopwatch.Frequency >= 30.0)
			{
				Interlocked.Exchange(ref _readerLastCatchupLogTicks, timestamp);
				Log.Msg($"[FfmpegEnc:{_streamId}] Reader live catch-up summary: dropped={droppedBytes}B remaining={remainingBytes}B max={maxBacklogBytes}B events={num}");
			}
		}

		private void RecordReaderOverrun(long readPos, long liveWritePos, long backlogBytes)
		{
			DesktopBuddyMod.Perf.IncrementCounter("stream_reader_overrun", 1L);
			Interlocked.Increment(ref _readerOverrunEvents);
			UpdateMax(ref _readerOverrunMaxBacklogBytes, backlogBytes);
			long timestamp = Stopwatch.GetTimestamp();
			long num = Interlocked.Read(ref _readerLastOverrunLogTicks);
			if ((num == 0L || !((double)(timestamp - num) * 1000.0 / (double)Stopwatch.Frequency < 5000.0)) && Interlocked.CompareExchange(ref _readerLastOverrunLogTicks, timestamp, num) == num)
			{
				long num2 = Interlocked.Exchange(ref _readerOverrunEvents, 0L);
				long num3 = Interlocked.Exchange(ref _readerOverrunMaxBacklogBytes, 0L);
				Log.Msg($"[FfmpegEnc:{_streamId}] Reader overrun summary: events={num2}, maxBacklog={num3} bytes, ringSize={16777216} bytes, lastReadPos={readPos}, liveWritePos={liveWritePos}, backlog={backlogBytes} bytes; closing reader for clean reconnect");
			}
		}

		private static void UpdateMax(ref long target, long value)
		{
			long num;
			do
			{
				num = Interlocked.Read(ref target);
			}
			while (value > num && Interlocked.CompareExchange(ref target, value, num) != num);
		}

		public void QueueFrame(nint srcTexture, uint width, uint height)
		{
			if (_disposed || _initFailed)
			{
				return;
			}
			if (_initialized && ((width & 0xFFFFFFFEu) != _sourceWidth || (height & 0xFFFFFFFEu) != _sourceHeight))
			{
				if (_totalFrames == 0)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Skipping frame: size mismatch source={_sourceWidth}x{_sourceHeight} encode={_width}x{_height} frame={width}x{height}");
				}
			}
			else if (!_initialized || _startTicks == 0L || (long)((double)(Stopwatch.GetTimestamp() - _startTicks) / (double)Stopwatch.Frequency * 90000.0) > Interlocked.Read(ref _lastVideoPts))
			{
				Marshal.AddRef((global::System.IntPtr)srcTexture);
				nint num = Interlocked.Exchange(ref _pendingTexture, (global::System.IntPtr)srcTexture);
				if (num != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)num);
				}
				_pendingWidth = width;
				_pendingHeight = height;
				((EventWaitHandle)_encodeEvent).Set();
			}
		}

		private void EncodeLoop()
		{
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Expected O, but got Unknown
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			Log.Msg($"[FfmpegEnc:{_streamId}] Encode thread started");
			while (!_disposed)
			{
				if (_rtspBroken && _rtspUrl != null)
				{
					RtspReconnect();
					continue;
				}
				((WaitHandle)_encodeEvent).WaitOne(GetEncodeWaitMs());
				if (_disposed)
				{
					break;
				}
				nint num = Interlocked.Exchange(ref _pendingTexture, global::System.IntPtr.Zero);
				uint num2 = _pendingWidth;
				uint num3 = _pendingHeight;
				bool keepAliveFrame = false;
				if (num == (nint)global::System.IntPtr.Zero)
				{
					if (_keepAliveTexture != (nint)global::System.IntPtr.Zero && IsKeepAliveDue(Stopwatch.GetTimestamp()))
					{
						Marshal.AddRef((global::System.IntPtr)_keepAliveTexture);
						num = _keepAliveTexture;
						num2 = _keepAliveW;
						num3 = _keepAliveH;
						keepAliveFrame = true;
					}
					if (num == (nint)global::System.IntPtr.Zero)
					{
						continue;
					}
				}
				try
				{
					EncodeFrameInternalLocked(num, num2, num3, keepAliveFrame);
					ScheduleNextKeepAlive(_lastEncodeTicks = Stopwatch.GetTimestamp());
					nint prev = _keepAliveTexture;
					Marshal.AddRef((global::System.IntPtr)num);
					_keepAliveTexture = num;
					_keepAliveW = num2;
					_keepAliveH = num3;
					if (prev != (nint)global::System.IntPtr.Zero)
					{
						WithD3dContextLock((Action)delegate
						{
							ReleaseD3dTextureRef(prev, "previousKeepAliveTexture");
						});
					}
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] Encode error (frame {_totalFrames}): {ex}");
				}
				finally
				{
					Marshal.Release((global::System.IntPtr)num);
				}
			}
			nint keepAliveTexture = _keepAliveTexture;
			_keepAliveTexture = global::System.IntPtr.Zero;
			if (keepAliveTexture != (nint)global::System.IntPtr.Zero)
			{
				WithD3dContextLock((Action)delegate
				{
					ReleaseD3dTextureRef(keepAliveTexture, "keepAliveTexture");
				});
			}
			Log.Msg($"[FfmpegEnc:{_streamId}] Encode thread stopped");
		}

		private int GetEncodeWaitMs()
		{
			long num = Interlocked.Read(ref _nextKeepAliveTicks);
			int keepAliveIntervalMs = GetKeepAliveIntervalMs();
			if (num == 0L || _keepAliveTexture == (nint)global::System.IntPtr.Zero)
			{
				return keepAliveIntervalMs;
			}
			long num2 = num - Stopwatch.GetTimestamp();
			if (num2 <= 0)
			{
				return 0;
			}
			return Math.Clamp((int)Math.Ceiling((double)num2 * 1000.0 / (double)Stopwatch.Frequency), 1, keepAliveIntervalMs);
		}

		private bool IsKeepAliveDue(long nowTicks)
		{
			long num = Interlocked.Read(ref _nextKeepAliveTicks);
			if (num != 0L)
			{
				return nowTicks >= num;
			}
			return false;
		}

		private void ScheduleNextKeepAlive(long nowTicks)
		{
			long num = Stopwatch.Frequency / GetKeepAliveFps();
			Interlocked.Exchange(ref _nextKeepAliveTicks, nowTicks + num);
		}

		private int GetKeepAliveFps()
		{
			return Math.Clamp(_keepAliveFps, 1, 240);
		}

		private int GetKeepAliveIntervalMs()
		{
			return Math.Max(1, (int)Math.Ceiling(1000.0 / (double)GetKeepAliveFps()));
		}

		private unsafe void EncodeFrameInternalLocked(nint srcTexture, uint width, uint height, bool keepAliveFrame)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_036b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (_disposed)
				{
					return;
				}
				int ret;
				using (DesktopBuddyMod.Perf.Time("ffmpeg_get_buffer"))
				{
					ret = 0;
					WithD3dContextLock((Action)delegate
					{
						ret = ffmpeg.av_hwframe_get_buffer(_hwFramesCtx, _hwFrame, 0);
					});
					if (ret < 0)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] av_hwframe_get_buffer failed: {FfmpegError(ret)}");
						return;
					}
				}
				if (_needsVideoProcessor || _needsGpuScale)
				{
					bool converted = false;
					using (DesktopBuddyMod.Perf.Time("ffmpeg_tex_copy"))
					{
						WithD3dContextLock((Action)delegate
						{
							converted = VideoProcessorConvert(srcTexture);
							if (converted)
							{
								nint dstTexture = (nint)((byte_ptrArray8)(&((AVFrame)_hwFrame).data))[0u];
								int dstArrayIndex = (int)((byte_ptrArray8)(&((AVFrame)_hwFrame).data))[1u];
								CopyTextureToFrame(_deviceContext, dstTexture, dstArrayIndex, _vpOutputTexture, (int)_width, (int)_height);
							}
						});
					}
					if (!converted)
					{
						ffmpeg.av_frame_unref(_hwFrame);
						return;
					}
				}
				else
				{
					using (DesktopBuddyMod.Perf.Time("ffmpeg_tex_copy"))
					{
						WithD3dContextLock((Action)delegate
						{
							nint dstTexture = (nint)((byte_ptrArray8)(&((AVFrame)_hwFrame).data))[0u];
							int dstArrayIndex = (int)((byte_ptrArray8)(&((AVFrame)_hwFrame).data))[1u];
							CopyTextureToFrame(_deviceContext, dstTexture, dstArrayIndex, srcTexture, (int)_width, (int)_height);
						});
					}
				}
				long num = (long)((double)(Stopwatch.GetTimestamp() - _startTicks) / (double)Stopwatch.Frequency * 90000.0);
				if (num <= Interlocked.Read(ref _lastVideoPts))
				{
					ffmpeg.av_frame_unref(_hwFrame);
					return;
				}
				Interlocked.Exchange(ref _lastVideoPts, num);
				((AVFrame)_hwFrame).pts = num;
				((AVFrame)_hwFrame).width = (int)_width;
				((AVFrame)_hwFrame).height = (int)_height;
				global::System.Runtime.CompilerServices.Unsafe.Write(&((AVFrame)_hwFrame).pict_type, (AVPictureType)(_totalFrames == 0));
				if (_totalFrames == 0)
				{
					((AVFrame)_hwFrame).flags |= 2;
				}
				using (DesktopBuddyMod.Perf.Time("ffmpeg_encode"))
				{
					ret = ffmpeg.avcodec_send_frame(_codecCtx, _hwFrame);
					ffmpeg.av_frame_unref(_hwFrame);
					if (ret < 0)
					{
						Log.Msg($"[FfmpegEnc:{_streamId}] avcodec_send_frame failed: {FfmpegError(ret)}");
						return;
					}
				}
				using (DesktopBuddyMod.Perf.Time("ffmpeg_mux"))
				{
					while (true)
					{
						ret = ffmpeg.avcodec_receive_packet(_codecCtx, _pkt);
						if (ret == ffmpeg.AVERROR<int>(ffmpeg.EAGAIN) || ret == ffmpeg.AVERROR_EOF)
						{
							break;
						}
						if (ret < 0)
						{
							Log.Msg($"[FfmpegEnc:{_streamId}] avcodec_receive_packet failed: {FfmpegError(ret)}");
							break;
						}
						((AVPacket)_pkt).stream_index = ((AVStream)_stream).index;
						ffmpeg.av_packet_rescale_ts(_pkt, ((AVCodecContext)_codecCtx).time_base, ((AVStream)_stream).time_base);
						bool flag = (((AVPacket)_pkt).flags & 1) != 0;
						long num2 = -1L;
						lock (_muxerLock)
						{
							if (_rtspBroken)
							{
								break;
							}
							if (flag && _rtspUrl == null)
							{
								ffmpeg.avio_flush(((AVFormatContext)_fmtCtx).pb);
								num2 = _ringWritePos;
							}
							ret = ffmpeg.av_interleaved_write_frame(_fmtCtx, _pkt);
							if (ret < 0)
							{
								Log.Msg($"[FfmpegEnc:{_streamId}] av_interleaved_write_frame (video) failed: {FfmpegError(ret)}");
								if (_rtspUrl != null)
								{
									_rtspBroken = true;
								}
							}
							else if (num2 >= 0)
							{
								ffmpeg.avio_flush(((AVFormatContext)_fmtCtx).pb);
								Interlocked.Exchange(ref _lastKeyframeRingPos, num2);
							}
							goto IL_048f;
						}
						IL_048f:
						ffmpeg.av_packet_unref(_pkt);
					}
				}
				if (_rtspUrl == null)
				{
					lock (_muxerLock)
					{
						ffmpeg.avio_flush(((AVFormatContext)_fmtCtx).pb);
					}
				}
			}
			finally
			{
				if (_hwFrame != null)
				{
					ffmpeg.av_frame_unref(_hwFrame);
				}
			}
			_totalFrames++;
			if (keepAliveFrame)
			{
				_keepAliveFramesEncoded++;
			}
		}

		private unsafe static void CopyTextureToFrame(nint deviceContext, nint dstTexture, int dstArrayIndex, nint srcTexture, int width, int height)
		{
			uint* ptr = stackalloc uint[6];
			*ptr = 0u;
			ptr[1] = 0u;
			ptr[2] = 0u;
			ptr[3] = (uint)width;
			ptr[4] = (uint)height;
			ptr[5] = 1u;
			((delegate* unmanaged[Stdcall]<nint, nint, uint, uint, uint, uint, nint, uint, void*, void>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)deviceContext) + (nint)46 * (nint)sizeof(nint))))(deviceContext, dstTexture, (uint)dstArrayIndex, 0u, 0u, 0u, srcTexture, 0u, ptr);
		}

		private void WithD3dContextLock(Action action)
		{
			if (_d3dContextLock == null)
			{
				action.Invoke();
				return;
			}
			lock (_d3dContextLock)
			{
				action.Invoke();
			}
		}

		private unsafe void SetupVideoProcessor(nint d3dDevice, uint inputW, uint inputH, uint outputW, uint outputH, bool outputNv12)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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)
			Guid iID_ID3D11VideoDevice = IID_ID3D11VideoDevice;
			Guid iID_ID3D11VideoContext = IID_ID3D11VideoContext;
			int num = Marshal.QueryInterface((global::System.IntPtr)d3dDevice, ref iID_ID3D11VideoDevice, ref _vpDevice);
			if (num < 0)
			{
				throw new global::System.Exception($"QueryInterface ID3D11VideoDevice failed hr=0x{num:X8}");
			}
			num = Marshal.QueryInterface((global::System.IntPtr)_deviceContext, ref iID_ID3D11VideoContext, ref _vpContext);
			if (num < 0)
			{
				throw new global::System.Exception($"QueryInterface ID3D11VideoContext failed hr=0x{num:X8}");
			}
			VP_CONTENT_DESC vP_CONTENT_DESC = new VP_CONTENT_DESC
			{
				InputFrameFormat = 0,
				InputFrameRateNum = 30u,
				InputFrameRateDen = 1u,
				InputWidth = inputW,
				InputHeight = inputH,
				OutputFrameRateNum = 30u,
				OutputFrameRateDen = 1u,
				OutputWidth = outputW,
				OutputHeight = outputH,
				Usage = 1
			};
			nint vpDevice = *(nint*)_vpDevice;
			num = ((delegate* unmanaged[Stdcall]<nint, VP_CONTENT_DESC*, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)10 * (nint)sizeof(nint))))(_vpDevice, &vP_CONTENT_DESC, ref _vpEnum);
			if (num < 0)
			{
				throw new global::System.Exception($"CreateVideoProcessorEnumerator failed hr=0x{num:X8}");
			}
			num = ((delegate* unmanaged[Stdcall]<nint, nint, uint, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)4 * (nint)sizeof(nint))))(_vpDevice, _vpEnum, 0u, ref _vpProcessor);
			if (num < 0)
			{
				throw new global::System.Exception($"CreateVideoProcessor failed hr=0x{num:X8}");
			}
			TEX2D_DESC tEX2D_DESC = new TEX2D_DESC
			{
				Width = outputW,
				Height = outputH,
				MipLevels = 1u,
				ArraySize = 1u,
				Format = (outputNv12 ? 103 : 87),
				SampleCount = 1u,
				SampleQuality = 0u,
				Usage = 0,
				BindFlags = 32u,
				CPUAccessFlags = 0u,
				MiscFlags = 0u
			};
			delegate* unmanaged[Stdcall]<nint, TEX2D_DESC*, nint, ref nint, int> delegate* = (delegate* unmanaged[Stdcall]<nint, TEX2D_DESC*, nint, ref nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)d3dDevice) + (nint)5 * (nint)sizeof(nint)));
			TEX2D_DESC tEX2D_DESC2 = new TEX2D_DESC
			{
				Width = inputW,
				Height = inputH,
				MipLevels = 1u,
				ArraySize = 1u,
				Format = 87,
				SampleCount = 1u,
				SampleQuality = 0u,
				Usage = 0,
				BindFlags = 32u,
				CPUAccessFlags = 0u,
				MiscFlags = 0u
			};
			num = delegate*(d3dDevice, &tEX2D_DESC2, global::System.IntPtr.Zero, ref _vpInputTexture);
			if (num < 0)
			{
				throw new global::System.Exception($"CreateTexture2D video processor input failed hr=0x{num:X8}");
			}
			num = delegate*(d3dDevice, &tEX2D_DESC, global::System.IntPtr.Zero, ref _vpOutputTexture);
			if (num < 0)
			{
				throw new global::System.Exception($"CreateTexture2D video processor output failed hr=0x{num:X8}");
			}
			VP_OUTPUT_VIEW_DESC vP_OUTPUT_VIEW_DESC = new VP_OUTPUT_VIEW_DESC
			{
				ViewDimension = 1,
				MipSlice = 0u
			};
			num = ((delegate* unmanaged[Stdcall]<nint, nint, nint, VP_OUTPUT_VIEW_DESC*, ref nint, int>)(*(global::System.IntPtr*)(vpDevice + (nint)9 * (nint)sizeof(nint))))(_vpDevice, _vpOutputTexture, _vpEnum, &vP_OUTPUT_VIEW_DESC, ref _vpOutputView);
			if (num < 0)
			{
				throw new global::System.Exception($"CreateVideoProcessorOutputView failed hr=0x{num:X8}");
			}
			nint vpContext = *(nint*)_vpContext;
			VP_COLOR_SPACE vP_COLOR_SPACE = new VP_COLOR_SPACE
			{
				Value = (outputNv12 ? 6u : 0u)
			};
			((delegate* unmanaged[Stdcall]<nint, nint, VP_COLOR_SPACE*, void>)(*(global::System.IntPtr*)(vpContext + (nint)15 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, &vP_COLOR_SPACE);
			((delegate* unmanaged[Stdcall]<nint, nint, uint, int, void>)(*(global::System.IntPtr*)(vpContext + (nint)27 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, 0u, 0);
			VP_COLOR_SPACE vP_COLOR_SPACE2 = new VP_COLOR_SPACE
			{
				Value = 0u
			};
			((delegate* unmanaged[Stdcall]<nint, nint, uint, VP_COLOR_SPACE*, void>)(*(global::System.IntPtr*)(vpContext + (nint)28 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, 0u, &vP_COLOR_SPACE2);
			Log.Msg($"[FfmpegEnc:{_streamId}] Video Processor ready: BGRA {inputW}x{inputH} -> {(outputNv12 ? "NV12" : "BGRA")} {outputW}x{outputH}, inCs=0, outCs=0x{vP_COLOR_SPACE.Value:X}");
		}

		private unsafe bool VideoProcessorConvert(nint bgraTexture)
		{
			if (_vpInputTexture == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			CopyTextureToFrame(_deviceContext, _vpInputTexture, 0, bgraTexture, (int)_sourceWidth, (int)_sourceHeight);
			if (_vpInputView == (nint)global::System.IntPtr.Zero)
			{
				if (_vpInputView != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)_vpInputView);
					_vpInputView = global::System.IntPtr.Zero;
				}
				VP_INPUT_VIEW_DESC vP_INPUT_VIEW_DESC = new VP_INPUT_VIEW_DESC
				{
					FourCC = 0u,
					ViewDimension = 1,
					MipSlice = 0u,
					ArraySlice = 0u
				};
				int num = ((delegate* unmanaged[Stdcall]<nint, nint, nint, VP_INPUT_VIEW_DESC*, ref nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_vpDevice) + (nint)8 * (nint)sizeof(nint))))(_vpDevice, _vpInputTexture, _vpEnum, &vP_INPUT_VIEW_DESC, ref _vpInputView);
				if (num < 0)
				{
					Log.Msg($"[FfmpegEnc:{_streamId}] CreateVideoProcessorInputView failed hr=0x{num:X8}");
					_vpInputView = global::System.IntPtr.Zero;
					return false;
				}
			}
			VP_STREAM vP_STREAM = new VP_STREAM
			{
				Enable = 1,
				OutputIndex = 0u,
				InputFrameOrField = 0u,
				PastFrames = 0u,
				FutureFrames = 0u,
				pInputSurface = _vpInputView
			};
			int num2 = ((delegate* unmanaged[Stdcall]<nint, nint, nint, uint, uint, VP_STREAM*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_vpContext) + (nint)53 * (nint)sizeof(nint))))(_vpContext, _vpProcessor, _vpOutputView, 0u, 1u, &vP_STREAM);
			if (num2 < 0)
			{
				Log.Msg($"[FfmpegEnc:{_streamId}] VideoProcessorBlt failed hr=0x{num2:X8}");
				return false;
			}
			return true;
		}
	}
	public class DesktopCurvedScreenInput : Component, ITouchable, IComponent, IComponentBase, IDestroyable, IWorker, IWorldElement, IUpdatable, IChangeable, IAudioUpdatable, IInitializable, ILinkable
	{
		private const float BoundsEpsilon = 0.001f;

		public CurvedPlaneMesh ScreenMesh;

		public Func<bool> ShouldIgnore;

		public Action<Component, float2> Pressed;

		public Action<Component, float2> Pressing;

		public Action<Component, float2> Released;

		public Action<Component, float2> Hovering;

		public bool AcceptsExistingTouch => false;

		public bool CanTouchOutOfSight => false;

		public bool CanTouchInteract(TouchSource source)
		{
			return source?.SafeTouchSource ?? false;
		}

		public void OnTouch(in TouchEventInfo eventInfo)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Invalid comparison between Unknown and I4
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Invalid comparison between Unknown and I4
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Invalid comparison between Unknown and I4
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Invalid comparison between Unknown and I4
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Invalid comparison between Unknown and I4
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			Func<bool> shouldIgnore = ShouldIgnore;
			if ((shouldIgnore == null || !shouldIgnore.Invoke()) && eventInfo.source != null && eventInfo.source.SafeTouchSource && TryGetDesktopPoint(in eventInfo.point, out var point))
			{
				Component source = (Component)(object)eventInfo.source;
				if ((int)eventInfo.hover == 1 || (int)eventInfo.hover == 2)
				{
					Hovering?.Invoke(source, point);
				}
				if ((int)eventInfo.touch == 1)
				{
					Pressed?.Invoke(source, point);
				}
				else if ((int)eventInfo.touch == 2)
				{
					Pressing?.Invoke(source, point);
				}
				else if ((int)eventInfo.touch == 3)
				{
					Released?.Invoke(source, point);
				}
			}
		}

		private bool TryGetDesktopPoint(in float3 globalPoint, out float2 point)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: 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_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			point = default(float2);
			CurvedPlaneMesh screenMesh = ScreenMesh;
			if (screenMesh == null || ((ComponentBase<Component>)(object)screenMesh).IsDestroyed)
			{
				return false;
			}
			float3 val = ((Component)screenMesh).Slot.GlobalPointToLocal(ref globalPoint);
			float num = MathX.Clamp01(((SyncField<float>)(object)screenMesh.Curvature).Value);
			float2 value = ((SyncField<float2>)(object)screenMesh.Size).Value;
			float2 val2 = CurvedPlaneMesh.CompensateSize(ref value, num, ((SyncField<CurvatureAspectRatioCompensation>)(object)screenMesh.AspectRatioCompensation).Value);
			if (val2.x <= 0f || val2.y <= 0f)
			{
				return false;
			}
			float num2;
			if (num < 0.01f)
			{
				num2 = val.x / val2.x + 0.5f;
			}
			else
			{
				float num3 = val2.x * 0.5f;
				float num4 = (float)Math.PI * num;
				float num5 = ((float)Math.PI - num4) * 0.5f;
				float num6 = 1f / MathX.Cos(num5);
				num2 = (MathF.Acos(MathX.Clamp(val.x / ((0f - num6) * num3), -1f, 1f)) - num5) / num4;
			}
			float num7 = 0.5f - val.y / val2.y;
			if (num2 < -0.001f || num2 > 1.001f || num7 < -0.001f || num7 > 1.001f)
			{
				return false;
			}
			point = new float2(MathX.Clamp01(num2), MathX.Clamp01(num7));
			return true;
		}

		void ITouchable.OnTouch(in TouchEventInfo eventInfo)
		{
			OnTouch(in eventInfo);
		}
	}
	public class DesktopKeyboardSource : Component, IFocusable, IComponent, IComponentBase, IDestroyable, IWorker, IWorldElement, IUpdatable, IChangeable, IAudioUpdatable, IInitializable, ILinkable
	{
		private Text _keyboardTargetText;

		public void Focus(User user)
		{
			if (user.IsLocalUser)
			{
				KeyboardInputRouter.SetFocused(this);
			}
		}

		public void Defocus(User user)
		{
			if (user.IsLocalUser)
			{
				KeyboardInputRouter.UnregisterTarget(this, (IText)(object)_keyboardTargetText);
				((Worker)this).InputInterface.HideKeyboard((object)null);
				ReleaseModifiers();
			}
		}

		public void OpenKeyboard()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			EnsureKeyboardTarget();
			float3 val = ((Component)this).Slot.GlobalPosition;
			floatQ val2 = ((Component)this).Slot.GlobalRotation;
			if (((Worker)this).World != Userspace.UserspaceWorld)
			{
				val = WorldManager.TransferPoint(val, ((Worker)this).World, Userspace.UserspaceWorld);
				val2 = WorldManager.TransferRotation(val2, ((Worker)this).World, Userspace.UserspaceWorld);
			}
			KeyboardInputRouter.RegisterTarget(this, (IText)(object)_keyboardTargetText);
			KeyboardInputRouter.SetFocused(this);
			((Worker)this).InputInterface.ShowKeyboard((IText)(object)_keyboardTargetText, "", (KeyboardType)0, true, false, false, "", 0, (object)null, (float3?)val, (floatQ?)val2);
		}

		public void CloseKeyboard()
		{
			KeyboardInputRouter.UnregisterTarget(this, (IText)(object)_keyboardTargetText);
			((Worker)this).InputInterface.HideKeyboard((object)null);
			ReleaseModifiers();
		}

		private void EnsureKeyboardTarget()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (_keyboardTargetText == null || ((ComponentBase<Component>)(object)_keyboardTargetText).IsDestroyed)
			{
				_keyboardTargetText = ((ContainerWorker<Component>)(object)((Component)this).Slot).AttachComponent<Text>(true, (Action<Text>)null);
				((SyncField<string>)(object)_keyboardTargetText.Content).Value = "";
				((SyncField<int>)(object)_keyboardTargetText.CaretPosition).Value = 0;
				((SyncField<int>)(object)_keyboardTargetText.SelectionStart).Value = -1;
				((SyncField<colorX>)(object)_keyboardTargetText.CaretColor).Value = colorX.Clear;
				((SyncField<colorX>)(object)_keyboardTargetText.SelectionColor).Value = colorX.Clear;
			}
		}

		protected override void OnDispose()
		{
			KeyboardInputRouter.UnregisterTarget(this, (IText)(object)_keyboardTargetText);
			ReleaseModifiers();
			((Worker)this).OnDispose();
		}

		public void SendKey(Key key)
		{
			//IL_0000: 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)
			if (!KeyMapper.TryGetVirtualKey(key, out var vk, out var shift))
			{
				return;
			}
			if (KeyMapper.IsModifier(key))
			{
				WindowInput.SendVirtualKeyDown(vk);
				return;
			}
			if (shift)
			{
				WindowInput.SendVirtualKeyDown(160);
			}
			WindowInput.SendVirtualKey(vk);
			WindowInput.ReleaseAllModifiers();
		}

		public void TypeString(string text)
		{
			if (!string.IsNullOrEmpty(text))
			{
				WindowInput.SendString(text);
				WindowInput.ReleaseAllModifiers();
			}
		}

		public void ReleaseModifiers()
		{
			WindowInput.ReleaseAllModifiers();
		}
	}
	public class DesktopUVRayExit : Component, IUVToRayConverter, IComponent, IComponentBase, IDestroyable, IWorker, IWorldElement, IUpdatable, IChangeable, IAudioUpdatable, IInitializable, ILinkable
	{
		public float2 Size;

		public float BackOffset = 10f;

		public void UVToRay(float2 uv, out float3 rayOrigin, out float3 rayDirection)
		{
			//IL_0002: 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_0047: 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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			float3 val = default(float3);
			((float3)(ref val))..ctor((uv.x - 0.5f) * Size.x, (uv.y - 0.5f) * Size.y, 0f - BackOffset);
			rayOrigin = ((Component)this).Slot.LocalPointToGlobal(ref val);
			rayDirection = ((Component)this).Slot.Forward;
		}
	}
	[HarmonyPatch(typeof(InteractionHandler), "BeforeInputUpdate")]
	internal static class LocomotionSuppressionPatch
	{
		private static readonly FieldInfo _inputsField = typeof(InteractionHandler).GetField("_inputs", (BindingFlags)36);

		private static void Postfix(InteractionHandler __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (DesktopBuddyMod.DesktopCanvasIds.Count == 0)
				{
					return;
				}
				InteractionLaser laser = __instance.Laser;
				ITouchable val = ((laser != null) ? laser.CurrentTouchable : null);
				if (val == null)
				{
					return;
				}
				if (!(val is DesktopCurvedScreenInput))
				{
					Canvas val2 = (Canvas)(object)((val is Canvas) ? val : null);
					if (val2 == null || !DesktopBuddyMod.DesktopCanvasIds.Contains(((Worker)val2).ReferenceID))
					{
						return;
					}
				}
				FieldInfo inputsField = _inputsField;
				object obj = ((inputsField != null) ? inputsField.GetValue((object)__instance) : null);
				InteractionHandlerInputs val3 = (InteractionHandlerInputs)((obj is InteractionHandlerInputs) ? obj : null);
				if (val3 != null)
				{
					((InputAction)val3.Axis).RegisterBlocks = true;
				}
			}
			catch
			{
			}
		}
	}
	internal static class KeyMapper
	{
		public static readonly Dictionary<Key, ushort> KeyToVK;

		public static bool IsModifier(Key key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Invalid comparison between Unknown and I4
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			if ((int)key != 304 && (int)key != 303 && (int)key != 512 && (int)key != 306 && (int)key != 305 && (int)key != 513 && (int)key != 308 && (int)key != 307 && (int)key != 514 && (int)key != 313 && (int)key != 311 && (int)key != 312)
			{
				return (int)key == 515;
			}
			return true;
		}

		public static bool TryGetVirtualKey(Key key, out ushort vk, out bool shift)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: 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_0053: 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_003d: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Invalid comparison between Unknown and I4
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected I4, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Invalid comparison between Unknown and I4
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected I4, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected I4, but got Unknown
			shift = false;
			if ((int)key >= 48 && (int)key <= 57)
			{
				vk = (ushort)(48 + (key - 48));
				return true;
			}
			if ((int)key >= 97 && (int)key <= 122)
			{
				vk = (ushort)(65 + (key - 97));
				return true;
			}
			if ((int)key >= 256 && (int)key <= 265)
			{
				vk = (ushort)(96 + (key - 256));
				return true;
			}
			if (KeyToVK.TryGetValue(key, ref vk))
			{
				return true;
			}
			shift = true;
			ushort num;
			if ((int)key <= 65)
			{
				switch (key - 33)
				{
				case 0:
					goto IL_010c;
				case 2:
					goto IL_0116;
				case 3:
					goto IL_011b;
				case 5:
					goto IL_012a;
				case 9:
					goto IL_012f;
				case 7:
					goto IL_0134;
				case 8:
					goto IL_0139;
				case 1:
					goto IL_016e;
				case 10:
					goto IL_0176;
				case 4:
				case 6:
					goto IL_017e;
				}
				switch (key - 58)
				{
				case 2:
					break;
				case 4:
					goto IL_00fc;
				case 6:
					goto IL_0111;
				case 0:
					goto IL_013e;
				case 5:
					goto IL_0146;
				case 7:
					goto IL_015e;
				default:
					goto IL_017e;
				}
				num = 188;
			}
			else if ((int)key != 94)
			{
				if ((int)key != 95)
				{
					switch (key - 123)
					{
					case 0:
						break;
					case 1:
						goto IL_014e;
					case 2:
						goto IL_0156;
					case 3:
						goto IL_0166;
					default:
						goto IL_017e;
					}
					num = 53;
				}
				else
				{
					num = 189;
				}
			}
			else
			{
				num = 54;
			}
			goto IL_0180;
			IL_011b:
			num = 52;
			goto IL_0180;
			IL_0116:
			num = 51;
			goto IL_0180;
			IL_0139:
			num = 48;
			goto IL_0180;
			IL_0134:
			num = 57;
			goto IL_0180;
			IL_015e:
			num = 220;
			goto IL_0180;
			IL_0176:
			num = 187;
			goto IL_0180;
			IL_00fc:
			num = 190;
			goto IL_0180;
			IL_0111:
			num = 50;
			goto IL_0180;
			IL_017e:
			num = 0;
			goto IL_0180;
			IL_0180:
			vk = num;
			return vk != 0;
			IL_012f:
			num = 56;
			goto IL_0180;
			IL_013e:
			num = 186;
			goto IL_0180;
			IL_012a:
			num = 55;
			goto IL_0180;
			IL_014e:
			num = 192;
			goto IL_0180;
			IL_0156:
			num = 219;
			goto IL_0180;
			IL_0166:
			num = 221;
			goto IL_0180;
			IL_0146:
			num = 191;
			goto IL_0180;
			IL_010c:
			num = 49;
			goto IL_0180;
			IL_016e:
			num = 222;
			goto IL_0180;
		}

		static KeyMapper()
		{
			Dictionary<Key, ushort> obj = new Dictionary<Key, ushort>();
			obj.Add((Key)8, (ushort)8);
			obj.Add((Key)9, (ushort)9);
			obj.Add((Key)13, (ushort)13);
			obj.Add((Key)27, (ushort)27);
			obj.Add((Key)32, (ushort)32);
			obj.Add((Key)127, (ushort)46);
			obj.Add((Key)12, (ushort)12);
			obj.Add((Key)19, (ushort)19);
			obj.Add((Key)273, (ushort)38);
			obj.Add((Key)274, (ushort)40);
			obj.Add((Key)276, (ushort)37);
			obj.Add((Key)275, (ushort)39);
			obj.Add((Key)277, (ushort)45);
			obj.Add((Key)278, (ushort)36);
			obj.Add((Key)279, (ushort)35);
			obj.Add((Key)280, (ushort)33);
			obj.Add((Key)281, (ushort)34);
			obj.Add((Key)304, (ushort)160);
			obj.Add((Key)303, (ushort)161);
			obj.Add((Key)512, (ushort)160);
			obj.Add((Key)306, (ushort)162);
			obj.Add((Key)305, (ushort)163);
			obj.Add((Key)513, (ushort)162);
			obj.Add((Key)308, (ushort)164);
			obj.Add((Key)307, (ushort)165);
			obj.Add((Key)514, (ushort)164);
			obj.Add((Key)313, (ushort)165);
			obj.Add((Key)311, (ushort)91);
			obj.Add((Key)312, (ushort)92);
			obj.Add((Key)515, (ushort)91);
			obj.Add((Key)282, (ushort)112);
			obj.Add((Key)283, (ushort)113);
			obj.Add((Key)284, (ushort)114);
			obj.Add((Key)285, (ushort)115);
			obj.Add((Key)286, (ushort)116);
			obj.Add((Key)287, (ushort)117);
			obj.Add((Key)288, (ushort)118);
			obj.Add((Key)289, (ushort)119);
			obj.Add((Key)290, (ushort)120);
			obj.Add((Key)291, (ushort)121);
			obj.Add((Key)292, (ushort)122);
			obj.Add((Key)293, (ushort)123);
			obj.Add((Key)294, (ushort)124);
			obj.Add((Key)295, (ushort)125);
			obj.Add((Key)296, (ushort)126);
			obj.Add((Key)300, (ushort)144);
			obj.Add((Key)301, (ushort)20);
			obj.Add((Key)302, (ushort)145);
			obj.Add((Key)315, (ushort)47);
			obj.Add((Key)316, (ushort)42);
			obj.Add((Key)44, (ushort)188);
			obj.Add((Key)46, (ushort)190);
			obj.Add((Key)45, (ushort)189);
			obj.Add((Key)61, (ushort)187);
			obj.Add((Key)59, (ushort)186);
			obj.Add((Key)47, (ushort)191);
			obj.Add((Key)96, (ushort)192);
			obj.Add((Key)91, (ushort)219);
			obj.Add((Key)92, (ushort)220);
			obj.Add((Key)93, (ushort)221);
			obj.Add((Key)39, (ushort)222);
			obj.Add((Key)270, (ushort)107);
			obj.Add((Key)269, (ushort)109);
			obj.Add((Key)266, (ushort)110);
			obj.Add((Key)267, (ushort)111);
			obj.Add((Key)268, (ushort)106);
			obj.Add((Key)271, (ushort)13);
			KeyToVK = obj;
		}
	}
	internal static class KeyboardInputRouter
	{
		private static readonly Dictionary<IText, DesktopKeyboardSource> _targetSources = new Dictionary<IText, DesktopKeyboardSource>();

		private static DesktopKeyboardSource _focusedSource;

		public static void RegisterTarget(DesktopKeyboardSource source, IText target)
		{
			if (source != null && target != null)
			{
				_targetSources[target] = source;
			}
		}

		public static void UnregisterTarget(DesktopKeyboardSource source, IText target)
		{
			DesktopKeyboardSource desktopKeyboardSource = default(DesktopKeyboardSource);
			if (target != null && _targetSources.TryGetValue(target, ref desktopKeyboardSource) && desktopKeyboardSource == source)
			{
				_targetSources.Remove(target);
			}
			ClearFocused(source);
		}

		public static void SetFocused(DesktopKeyboardSource source)
		{
			if (source != null && !((ComponentBase<Component>)(object)source).IsDestroyed)
			{
				_focusedSource = source;
			}
		}

		public static void ClearFocused(DesktopKeyboardSource source)
		{
			if (_focusedSource == source)
			{
				_focusedSource = null;
			}
		}

		public static void KeyboardShown(IText target)
		{
			if (TryGetRegisteredSource(target) == null)
			{
				_focusedSource = null;
			}
		}

		public static void KeyboardHidden()
		{
			_focusedSource = null;
		}

		public static DesktopKeyboardSource Resolve(World origin, Slot pressedSlot = null)
		{
			try
			{
				return IsUsable(_focusedSource) ? _focusedSource : null;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[InputPatch] Keyboard resolve error: {ex}");
				return null;
			}
		}

		private static DesktopKeyboardSource TryGetRegisteredSource(IText target)
		{
			if (target == null || ((IDestroyable)target).IsDestroyed)
			{
				return null;
			}
			DesktopKeyboardSource desktopKeyboardSource = default(DesktopKeyboardSource);
			if (!_targetSources.TryGetValue(target, ref desktopKeyboardSource))
			{
				return null;
			}
			if (IsUsable(desktopKeyboardSource))
			{
				return desktopKeyboardSource;
			}
			_targetSources.Remove(target);
			return null;
		}

		private static bool IsUsable(DesktopKeyboardSource source)
		{
			if (source != null)
			{
				return !((ComponentBase<Component>)(object)source).IsDestroyed;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InputInterface), "ShowKeyboard")]
	internal static class ShowKeyboardPatch
	{
		private static void Prefix(IText targetText)
		{
			KeyboardInputRouter.KeyboardShown(targetText);
		}
	}
	[HarmonyPatch(typeof(InputInterface), "HideKeyboard")]
	internal static class HideKeyboardPatch
	{
		private static void Postfix(InputInterface __instance)
		{
			if (!__instance.IsKeyboardActive)
			{
				KeyboardInputRouter.KeyboardHidden();
			}
		}
	}
	[HarmonyPatch(typeof(VirtualKey), "Press")]
	internal static class VirtualKeyPressPatch
	{
		private static bool Prefix(VirtualKey __instance)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			DesktopKeyboardSource desktopKeyboardSource = KeyboardInputRouter.Resolve(((Worker)__instance).World, ((Component)__instance).Slot);
			if (desktopKeyboardSource == null)
			{
				return true;
			}
			string value;
			Key value2;
			if (__instance.UseModifier)
			{
				value = ((SyncField<string>)(object)__instance.ModifiedAppendString).Value;
				value2 = ((SyncField<Key>)(object)__instance.ModifiedTargetKey).Value;
			}
			else if (((SyncField<bool>)(object)__instance.IgnoreShift).Value || ((SyncRef<VirtualKeyboard>)(object)__instance.Keyboard).Target == null || !((SyncField<bool>)(object)((SyncRef<VirtualKeyboard>)(object)__instance.Keyboard).Target.ShiftActive).Value)
			{
				value = ((SyncField<string>)(object)__instance.AppendString).Value;
				value2 = ((SyncField<Key>)(object)__instance.TargetKey).Value;
			}
			else
			{
				value = ((SyncField<string>)(object)__instance.ShiftAppendString).Value;
				value2 = ((SyncField<Key>)(object)__instance.ShiftTargetKey).Value;
			}
			if (ShouldSendAsKey(value, value2))
			{
				desktopKeyboardSource.SendKey(value2);
			}
			else if (!string.IsNullOrEmpty(value))
			{
				desktopKeyboardSource.TypeString(value);
			}
			else if ((int)value2 != 0)
			{
				desktopKeyboardSource.SendKey(value2);
			}
			VirtualKeyboard target = ((SyncRef<VirtualKeyboard>)(object)__instance.Keyboard).Target;
			if (target != null && !((SyncField<bool>)(object)__instance.IgnoreShift).Value && ((SyncField<bool>)(object)target.ShiftActive).Value && !((SyncField<bool>)(object)target.HoldShift).Value)
			{
				((SyncField<bool>)(object)target.ShiftActive).Value = false;
				((SyncField<bool>)(object)target.HoldShift).Value = false;
			}
			return false;
		}

		private static bool ShouldSendAsKey(string text, Key key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Invalid comparison between Unknown and I4
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Invalid comparison between Unknown and I4
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Invalid comparison between Unknown and I4
			if ((int)key == 0)
			{
				return false;
			}
			if (string.IsNullOrEmpty(text))
			{
				return true;
			}
			if ((int)key != 8 && (int)key != 127 && (int)key != 13 && (int)key != 271 && (int)key != 9 && (int)key != 27 && (int)key != 273 && (int)key != 274 && (int)key != 276 && (int)key != 275 && (int)key != 278 && (int)key != 279 && (int)key != 280 && (int)key != 281)
			{
				return (int)key == 277;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(VirtualMultiKey), "Pressed")]
	internal static class VirtualMultiKeyPressedPatch
	{
		private static bool Prefix(VirtualMultiKey __instance, IButton button, ButtonEventData eventData)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Component source = eventData.source;
			TouchSource val = (TouchSource)(object)((source is TouchSource) ? source : null);
			if (val == null || !val.SafeTouchSource)
			{
				return false;
			}
			DesktopKeyboardSource desktopKeyboardSource = KeyboardInputRouter.Resolve(((Worker)__instance).World, ((Component)__instance).Slot);
			if (desktopKeyboardSource == null)
			{
				return true;
			}
			Enumerator<Key> enumerator = __instance.Keys.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Key current = enumerator.Current;
					desktopKeyboardSource.SendKey(current);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InputInterface), "SimulatePress")]
	internal static class SimulatePressPatch
	{
		private static bool Prefix(Key key, World origin)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (origin != Userspace.UserspaceWorld && Userspace.HasFocus)
				{
					return true;
				}
				DesktopKeyboardSource desktopKeyboardSource = KeyboardInputRouter.Resolve(origin);
				if (desktopKeyboardSource != null)
				{
					desktopKeyboardSource.SendKey(key);
					return false;
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[InputPatch] SimulatePress error: {ex}");
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InputInterface), "TypeAppend")]
	internal static class TypeAppendPatch
	{
		private static bool Prefix(string typeDelta, World origin)
		{
			try
			{
				if (origin != Userspace.UserspaceWorld && Userspace.HasFocus)
				{
					return true;
				}
				DesktopKeyboardSource desktopKeyboardSource = KeyboardInputRouter.Resolve(origin);
				if (desktopKeyboardSource != null)
				{
					desktopKeyboardSource.TypeString(typeDelta);
					return false;
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[InputPatch] TypeAppend error: {ex}");
			}
			return true;
		}
	}
	internal static class TopBarRaycastPortalPatch
	{
		private static bool _installed;

		internal static void Install(Harmony harmony)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (_installed)
			{
				return;
			}
			try
			{
				MethodInfo val = Enumerable.FirstOrDefault<MethodInfo>((global::System.Collections.Generic.IEnumerable<MethodInfo>)typeof(MeshUVRaycastPortal).GetMethods((BindingFlags)20), (Func<MethodInfo, bool>)delegate(MethodInfo val2)
				{
					if (((MemberInfo)val2).Name != "TransferRay")
					{
						return false;
					}
					ParameterInfo[] parameters = ((MethodBase)val2).GetParameters();
					return parameters.Length == 6 && parameters[0].ParameterType == typeof(RaycastHit).MakeByRefType() && parameters[1].ParameterType == typeof(float3).MakeByRefType() && parameters[2].ParameterType == typeof(float3).MakeByRefType() && parameters[3].ParameterType == typeof(float3).MakeByRefType() && parameters[4].ParameterType == typeof(Func<ICollider, int, bool>).MakeByRefType() && parameters[5].ParameterType == typeof(bool).MakeByRefType();
				});
				if (val == (MethodInfo)null)
				{
					DesktopBuddyMod.Msg("[TopBarRaycast] MeshUVRaycastPortal.TransferRay signature not found; top bar raycast isolation disabled");
					return;
				}
				MethodInfo method = typeof(TopBarRaycastPortalPatch).GetMethod("Postfix", (BindingFlags)40);
				harmony.Patch((MethodBase)(object)val, (HarmonyMethod)null, new HarmonyMethod(method), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				_installed = true;
				DesktopBuddyMod.Msg("[TopBarRaycast] Installed runtime portal filter patch");
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg($"[TopBarRaycast] Failed to install portal filter patch: {ex}");
			}
		}

		private static void Postfix(MeshUVRaycastPortal __instance, bool __result, ref Func<ICollider, int, bool> filter)
		{
			if (!__result)
			{
				return;
			}
			try
			{
				Slot targetRoot = DesktopBuddyMod.GetTopBarRaycastTarget((__instance != null) ? ((Component)__instance).Slot : null);
				if (targetRoot == null || ((ContainerWorker<Component>)(object)targetRoot).IsDestroyed)
				{
					return;
				}
				Func<ICollider, int, bool> previous = filter;
				filter = delegate(ICollider collider, int depth)
				{
					try
					{
						if (previous != null && !previous.Invoke(collider, depth))
						{
							return false;
						}
						Slot val = ((collider != null) ? ((IComponent)collider).Slot : null);
						return val != null && !((ContainerWorker<Component>)(object)targetRoot).IsDestroyed && val.IsChildOf(targetRoot, false);
					}
					catch
					{
						return false;
					}
				};
			}
			catch
			{
			}
		}
	}
	public static class WindowInput
	{
		[StructLayout((LayoutKind)0, CharSet = (CharSet)4)]
		private struct MONITORINFOEX
		{
			public int cbSize;

			public RECT rcMonitor;

			public RECT rcWork;

			public uint dwFlags;

			[MarshalAs((UnmanagedType)23, SizeConst = 32)]
			public string szDevice;
		}

		private struct INPUT
		{
			public uint type;

			public INPUTUNION u;
		}

		[StructLayout((LayoutKind)2, Size = 32)]
		private struct INPUTUNION
		{
			[FieldOffset(0)]
			public KEYBDINPUT ki;
		}

		private struct KEYBDINPUT
		{
			public ushort wVk;

			public ushort wScan;

			public uint dwFlags;

			public uint time;

			public nint dwExtraInfo;
		}

		private delegate void WinEventDelegate(nint hWinEventHook, uint eventType, nint hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime);

		private struct MSG
		{
			public nint hwnd;

			public uint message;

			public nuint wParam;

			public nint lParam;

			public uint time;

			public POINT pt;
		}

		private struct GUITHREADINFO
		{
			public int cbSize;

			public uint flags;

			public nint hwndActive;

			public nint hwndFocus;

			public nint hwndCapture;

			public nint hwndMenuOwner;

			public nint hwndMoveSize;

			public nint hwndCaret;

			public RECT rcCaret;
		}

		public struct POINT
		{
			public int X;

			public int Y;
		}

		private struct POINTER_INFO
		{
			public uint pointerType;

			public uint pointerId;

			public uint frameId;

			public uint pointerFlags;

			public nint sourceDevice;

			public nint hwndTarget;

			public POINT ptPixelLocation;

			public POINT ptHimetricLocation;

			public POINT ptPixelLocationRaw;

			public POINT ptHimetricLocationRaw;

			public uint dwTime;

			public uint historyCount;

			public int inputData;

			public uint dwKeyStates;

			public ulong PerformanceCount;

			public int ButtonChangeType;
		}

		private struct POINTER_TOUCH_INFO
		{
			public POINTER_INFO pointerInfo;

			public uint touchFlags;

			public uint touchMask;

			public RECT rcContact;

			public RECT rcContactRaw;

			public uint orientation;

			public uint pressure;
		}

		private struct RECT
		{
			public int Left;

			public int Top;

			public int Right;

			public int Bottom;

			public int Width => Right - Left;

			public int Height => Bottom - Top;
		}

		private sealed class FocusInputQueue
		{
			public nint Hwnd;

			public nint FocusRoot;

			public global::System.DateTime StartedUtc;

			public global::System.DateTime LastFocusRequestUtc;

			public readonly List<QueuedInput> Inputs = new List<QueuedInput>();
		}

		private readonly struct QueuedInput
		{
			public readonly Action Send;

			public readonly string Description;

			public QueuedInput(Action send, string description)
			{
				Send = send;
				Description = description;
			}
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static ThreadStart <0>__FocusHookThreadMain;
		}

		private const int SW_RESTORE = 9;

		private const uint INPUT_KEYBOARD = 1u;

		private const uint KEYEVENTF_KEYUP = 2u;

		private const uint KEYEVENTF_UNICODE = 4u;

		private static readonly HashSet<ushort> _heldModifiers = new HashSet<ushort>();

		internal static ulong LinuxInputSession;

		private static LinuxNativeBridge _linuxInput;

		private static readonly object _linuxInputLock = new object();

		private static readonly Dictionary<ushort, int> _vkKeysyms = new Dictionary<ushort, int>
		{
			[(ushort)8] = 65288,
			[(ushort)9] = 65289,
			[(ushort)13] = 65293,
			[(ushort)27] = 65307,
			[(ushort)32] = 32,
			[(ushort)33] = 65365,
			[(ushort)34] = 65366,
			[(ushort)35] = 65367,
			[(ushort)36] = 65360,
			[(ushort)37] = 65361,
			[(ushort)38] = 65362,
			[(ushort)39] = 65363,
			[(ushort)40] = 65364,
			[(ushort)46] = 65535,
			[(ushort)16] = 65505,
			[(ushort)160] = 65505,
			[(ushort)161] = 65506,
			[(ushort)17] = 65507,
			[(ushort)162] = 65507,
			[(ushort)163] = 65508,
			[(ushort)18] = 65513,
			[(ushort)164] = 65513,
			[(ushort)165] = 65514
		};

		private const uint MOUSEEVENTF_WHEEL = 2048u;

		private const uint GW_OWNER = 4u;

		private const uint GA_ROOTOWNER = 3u;

		private const uint GUI_INMENUMODE = 4u;

		private const uint GUI_POPUPMENUMODE = 16u;

		private static readonly nint HWND_TOP = global::System.IntPtr.Zero;

		private const uint SWP_NOSIZE = 1u;

		private const uint SWP_NOMOVE = 2u;

		private const uint SWP_SHOWWINDOW = 64u;

		private const int DWMWA_EXTENDED_FRAME_BOUNDS = 9;

		private const uint EVENT_SYSTEM_FOREGROUND = 3u;

		private const uint WINEVENT_OUTOFCONTEXT = 0u;

		private const uint WINEVENT_SKIPOWNPROCESS = 2u;

		private const int OBJECTID_WINDOW = 0;

		private const uint TOUCH_FEEDBACK_NONE = 3u;

		private const uint POINTER_FLAG_INRANGE = 2u;

		private const uint POINTER_FLAG_INCONTACT = 4u;

		private const uint POINTER_FLAG_DOWN = 65536u;

		private const uint POINTER_FLAG_UPDATE = 131072u;

		private const uint POINTER_FLAG_UP = 262144u;

		private const uint PT_TOUCH = 2u;

		private const uint TOUCH_FLAG_NONE = 0u;

		private const uint TOUCH_MASK_CONTACTAREA = 4u;

		private const uint TOUCH_MASK_ORIENTATION = 8u;

		private const uint TOUCH_MASK_PRESSURE = 2u;

		private static bool _touchInitialized;

		private static readonly object _initLock = new object();

		private const uint MAX_TOUCH_CONTACTS = 10u;

		private static readonly POINT[] _lastPosition = new POINT[10];

		private static readonly bool[] _moveFailLogged = new bool[10];

		private static readonly POINTER_TOUCH_INFO[] _touchArr = new POINTER_TOUCH_INFO[1];

		private static readonly object _sendLock = new object();

		private static readonly object _focusQueueLock = new object();

		private static readonly Dictionary<nint, FocusInputQueue> _focusQueues = new Dictionary<nint, FocusInputQueue>();

		private static readonly WinEventDelegate _foregroundEventCallback = OnForegroundEvent;

		private static Thread _focusHookThread;

		private static bool _focusHookStarted;

		private static nint _focusHook;

		private const int FocusQueueTimeoutMs = 500;

		private const int FocusQueueMaxEvents = 64;

		private static bool EnsureTouchInit()
		{
			if (_touchInitialized)
			{
				return true;
			}
			lock (_initLock)
			{
				if (_touchInitialized)
				{
					return true;
				}
				if (!InitializeTouchInjection(10u, 3u))
				{
					int lastWin32Error = Marshal.GetLastWin32Error();
					Log.Msg($"[WindowInput] InitializeTouchInjection FAILED err={lastWin32Error}");
					return false;
				}
				_touchInitialized = true;
				Log.Msg($"[WindowInput] Touch injection initialized (max={10}, feedback=NONE)");
				return true;
			}
		}

		internal static bool PrewarmTouchInjection()
		{
			StartFocusEventHook();
			return EnsureTouchInit();
		}

		[DllImport("user32.dll")]
		private static extern bool IsIconic(nint hWnd);

		[DllImport("user32.dll")]
		private static extern bool ShowWindow(nint hWnd, int nCmdShow);

		public static void RestoreIfMinimized(nint hWnd)
		{
			if (hWnd != (nint)global::System.IntPtr.Zero && IsIconic(hWnd))
			{
				Log.Msg($"[WindowInput] Restoring minimized window hwnd={hWnd}");
				ShowWindow(hWnd, 9);
			}
		}

		[DllImport("user32.dll", CharSet = (CharSet)4)]
		private static extern bool GetMonitorInfo(nint hMonitor, ref MONITORINFOEX lpmi);

		private static int NormalizedToPixel(float value, int size)
		{
			if (size <= 1 || float.IsNaN(value) || float.IsInfinity(value))
			{
				return 0;
			}
			int num = size - 1;
			float num2 = value * (float)size;
			if (num2 <= 0f)
			{
				return 0;
			}
			if (num2 >= (float)num)
			{
				return num;
			}
			return (int)num2;
		}

		private static bool TryGetWindowCaptureBounds(nint hWnd, out RECT bounds)
		{
			bounds = default(RECT);
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (DwmGetWindowAttribute(hWnd, 9, out bounds, Marshal.SizeOf<RECT>()) == 0 && bounds.Width > 0 && bounds.Height > 0)
			{
				return true;
			}
			if (GetWindowRect(hWnd, out bounds) && bounds.Width > 0)
			{
				return bounds.Height > 0;
			}
			return false;
		}

		private static POINT UvToScreen(nint hWnd, float u, float v, int clientW, int clientH, nint monitorHandle = 0)
		{
			int x = NormalizedToPixel(u, clientW);
			int y = NormalizedToPixel(v, clientH);
			if (hWnd != (nint)global::System.IntPtr.Zero)
			{
				if (TryGetWindowCaptureBounds(hWnd, out var bounds))
				{
					return new POINT
					{
						X = bounds.Left + NormalizedToPixel(u, bounds.Width),
						Y = bounds.Top + NormalizedToPixel(v, bounds.Height)
					};
				}
				POINT lpPoint = new POINT
				{
					X = x,
					Y = y
				};
				ClientToScreen(hWnd, ref lpPoint);
				return lpPoint;
			}
			POINT result = new POINT
			{
				X = x,
				Y = y
			};
			if (monitorHandle != (nint)global::System.IntPtr.Zero)
			{
				MONITORINFOEX lpmi = new MONITORINFOEX
				{
					cbSize = Marshal.SizeOf<MONITORINFOEX>()
				};
				if (GetMonitorInfo(monitorHandle, ref lpmi))
				{
					result.X += lpmi.rcMonitor.Left;
					result.Y += lpmi.rcMonitor.Top;
				}
			}
			return result;
		}

		private static nint FocusRoot(nint hWnd)
		{
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				return global::System.IntPtr.Zero;
			}
			nint ancestor = GetAncestor(hWnd, 3u);
			if (ancestor == (nint)global::System.IntPtr.Zero)
			{
				return hWnd;
			}
			return ancestor;
		}

		public static bool FocusWindow(nint hWnd)
		{
			return RequestFocus(hWnd);
		}

		public static bool IsFocusedForInput(nint hWnd)
		{
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			nint foregroundWindow = GetForegroundWindow();
			if (foregroundWindow == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (foregroundWindow == hWnd)
			{
				return true;
			}
			nint num = FocusRoot(hWnd);
			nint num2 = FocusRoot(foregroundWindow);
			if (num != (nint)global::System.IntPtr.Zero)
			{
				return num == num2;
			}
			return false;
		}

		public static bool EnsureFocusedForInput(nint hWnd)
		{
			if (IsFocusedForInput(hWnd))
			{
				return true;
			}
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			if (RequestFocus(hWnd))
			{
				return IsFocusedForInput(hWnd);
			}
			return false;
		}

		public static void SendWhenFocused(nint hWnd, Action sendInput, string description = "input")
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			if (sendInput == null)
			{
				return;
			}
			if (hWnd == (nint)global::System.IntPtr.Zero || IsFocusedForInput(hWnd))
			{
				sendInput.Invoke();
				return;
			}
			StartFocusEventHook();
			global::System.DateTime utcNow = global::System.DateTime.UtcNow;
			bool flag = false;
			lock (_focusQueueLock)
			{
				DropExpiredQueuesLocked(utcNow);
				nint num = FocusRoot(hWnd);
				FocusInputQueue focusInputQueue = default(FocusInputQueue);
				if (!_focusQueues.TryGetValue(num, ref focusInputQueue))
				{
					focusInputQueue = new FocusInputQueue
					{
						Hwnd = hWnd,
						FocusRoot = num,
						StartedUtc = utcNow,
						LastFocusRequestUtc = global::System.DateTime.MinValue
					};
					_focusQueues.Add(num, focusInputQueue);
					Log.Msg($"[WindowInput] Queueing {description} until focus hwnd={hWnd} root={num} foreground={GetForegroundWindow()}");
				}
				if (focusInputQueue.Inputs.Count >= 64)
				{
					Log.Msg($"[WindowInput] Focus queue overflow hwnd={hWnd}; dropping {focusInputQueue.Inputs.Count} queued events");
					focusInputQueue.Inputs.Clear();
					focusInputQueue.StartedUtc = utcNow;
				}
				focusInputQueue.Inputs.Add(new QueuedInput(sendInput, description));
				TimeSpan val = utcNow - focusInputQueue.LastFocusRequestUtc;
				if (((TimeSpan)(ref val)).TotalMilliseconds >= 100.0)
				{
					focusInputQueue.LastFocusRequestUtc = utcNow;
					flag = true;
				}
			}
			if (flag)
			{
				RequestFocus(hWnd);
			}
			FlushFocusedQueues();
		}

		public static void SendAtPointWhenTargetAcceptable(nint hWnd, float u, float v, int clientW, int clientH, nint monitorHandle, Action sendInput, string description = "input")
		{
			if (sendInput == null)
			{
				return;
			}
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				sendInput.Invoke();
				return;
			}
			POINT screenPoint = UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle);
			if (IsPointAcceptedForInput(hWnd, screenPoint, out var hitHwnd, out var reason))
			{
				if (!IsFocusedForInput(hWnd) && description.IndexOf("move", (StringComparison)5) < 0)
				{
					Log.Msg($"[WindowInput] Sending {description} without parent refocus; point hit target popup/family hwnd={hitHwnd} reason={reason}");
				}
				sendInput.Invoke();
			}
			else
			{
				SendWhenFocused(hWnd, sendInput, description);
			}
		}

		private static bool IsPointAcceptedForInput(nint hWnd, POINT screenPoint, out nint hitHwnd, out string reason)
		{
			hitHwnd = WindowFromPoint(screenPoint);
			reason = "none";
			if (hitHwnd == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (IsFocusedForInput(hWnd))
			{
				reason = "focused";
				return true;
			}
			if (IsTargetFamilyWindow(hWnd, hitHwnd))
			{
				reason = "target-family";
				return true;
			}
			if (IsTargetMenuActiveAtPoint(hWnd, hitHwnd))
			{
				reason = "target-menu";
				return true;
			}
			return false;
		}

		private static bool IsTargetFamilyWindow(nint targetHwnd, nint candidateHwnd)
		{
			if (targetHwnd == (nint)global::System.IntPtr.Zero || candidateHwnd == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (candidateHwnd == targetHwnd)
			{
				return true;
			}
			nint num = FocusRoot(targetHwnd);
			nint num2 = FocusRoot(candidateHwnd);
			if (num != (nint)global::System.IntPtr.Zero && num2 == num)
			{
				return true;
			}
			if (!OwnerChainContains(candidateHwnd, targetHwnd))
			{
				if (num != (nint)global::System.IntPtr.Zero)
				{
					return OwnerChainContains(candidateHwnd, num);
				}
				return false;
			}
			return true;
		}

		private static bool OwnerChainContains(nint hwnd, nint target)
		{
			if (hwnd == (nint)global::System.IntPtr.Zero || target == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			nint window = GetWindow(hwnd, 4u);
			int num = 0;
			while (window != (nint)global::System.IntPtr.Zero && num++ < 32)
			{
				if (window == target)
				{
					return true;
				}
				window = GetWindow(window, 4u);
			}
			return false;
		}

		private static bool IsTargetMenuActiveAtPoint(nint targetHwnd, nint hitHwnd)
		{
			uint processId;
			uint windowThreadProcessId = GetWindowThreadProcessId(targetHwnd, out processId);
			uint processId2;
			uint windowThreadProcessId2 = GetWindowThreadProcessId(hitHwnd, out processId2);
			if (windowThreadProcessId == 0 || windowThreadProcessId2 == 0)
			{
				return false;
			}
			if (processId != 0 && processId2 != 0 && processId != processId2)
			{
				return false;
			}
			GUITHREADINFO lpgui = new GUITHREADINFO
			{
				cbSize = Marshal.SizeOf<GUITHREADINFO>()
			};
			if (!GetGUIThreadInfo(windowThreadProcessId, ref lpgui))
			{
				return false;
			}
			if ((lpgui.flags & 0x14) == 0)
			{
				return false;
			}
			if (IsTargetFamilyWindow(targetHwnd, lpgui.hwndMenuOwner))
			{
				return true;
			}
			if (lpgui.hwndActive != (nint)global::System.IntPtr.Zero && IsTargetFamilyWindow(targetHwnd, lpgui.hwndActive))
			{
				return true;
			}
			if (lpgui.hwndFocus != (nint)global::System.IntPtr.Zero && IsTargetFamilyWindow(targetHwnd, lpgui.hwndFocus))
			{
				return true;
			}
			if (OwnerChainContains(hitHwnd, lpgui.hwndMenuOwner))
			{
				return true;
			}
			return false;
		}

		private static bool RequestFocus(nint hWnd)
		{
			if (hWnd == (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			nint num = FocusRoot(hWnd);
			if (num == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (IsFocusedForInput(hWnd))
			{
				return true;
			}
			RestoreIfMinimized(num);
			nint foregroundWindow = GetForegroundWindow();
			uint currentThreadId = GetCurrentThreadId();
			uint processId;
			uint windowThreadProcessId = GetWindowThreadProcessId(num, out processId);
			uint processId2;
			uint num2 = ((foregroundWindow != (nint)global::System.IntPtr.Zero) ? GetWindowThreadProcessId(foregroundWindow, out processId2) : 0u);
			bool flag = false;
			bool flag2 = false;
			try
			{
				if (num2 != 0 && num2 != currentThreadId)
				{
					flag = AttachThreadInput(currentThreadId, num2, fAttach: true);
				}
				if (windowThreadProcessId != 0 && windowThreadProcessId != currentThreadId && windowThreadProcessId != num2)
				{
					flag2 = AttachThreadInput(currentThreadId, windowThreadProcessId, fAttach: true);
				}
				BringWindowToTop(num);
				SetWindowPos(num, HWND_TOP, 0, 0, 0, 0, 67u);
				SetActiveWindow(num);
				SetFocus(num);
				bool flag3 = SetForegroundWindow(num);
				if (IsFocusedForInput(hWnd))
				{
					FlushFocusedQueues();
					return true;
				}
				int lastWin32Error = Marshal.GetLastWin32Error();
				nint foregroundWindow2 = GetForegroundWindow();
				Log.Msg($"[WindowInput] Focus request failed ok={flag3} err={lastWin32Error} hwnd={num} original={hWnd} foregroundBefore={foregroundWindow} foregroundAfter={foregroundWindow2} currentTid={currentThreadId} foregroundTid={num2} targetTid={windowThreadProcessId} targetPid={processId} attachForeground={flag} attachTarget={flag2}");
				return false;
			}
			finally
			{
				if (flag2)
				{
					AttachThreadInput(currentThreadId, windowThreadProcessId, fAttach: false);
				}
				if (flag)
				{
					AttachThreadInput(currentThreadId, num2, fAttach: false);
				}
			}
		}

		private static void StartFocusEventHook()
		{
			//IL_0042: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			if (_focusHookStarted)
			{
				return;
			}
			lock (_focusQueueLock)
			{
				if (!_focusHookStarted)
				{
					_focusHookStarted = true;
					object obj = <>O.<0>__FocusHookThreadMain;
					if (obj == null)
					{
						ThreadStart val = FocusHookThreadMain;
						<>O.<0>__FocusHookThreadMain = val;
						obj = (object)val;
					}
					_focusHookThread = new Thread((ThreadStart)obj)
					{
						IsBackground = true,
						Name = "DesktopBuddy Focus Event Hook"
					};
					_focusHookThread.Start();
				}
			}
		}

		private static void FocusHookThreadMain()
		{
			_focusHook = SetWinEventHook(3u, 3u, global::System.IntPtr.Zero, _foregroundEventCallback, 0u, 0u, 2u);
			if (_focusHook == (nint)global::System.IntPtr.Zero)
			{
				Log.Msg($"[WindowInput] SetWinEventHook(EVENT_SYSTEM_FOREGROUND) failed err={Marshal.GetLastWin32Error()}");
				return;
			}
			Log.Msg("[WindowInput] Foreground event hook installed");
			MSG lpMsg;
			while (GetMessage(out lpMsg, global::System.IntPtr.Zero, 0u, 0u))
			{
				TranslateMessage(ref lpMsg);
				DispatchMessage(ref lpMsg);
			}
		}

		private static void OnForegroundEvent(nint hWinEventHook, uint eventType, nint hwnd, int idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
		{
			if (eventType == 3 && idObject == 0)
			{
				FlushFocusedQueues();
			}
		}

		private static void FlushFocusedQueues()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			List<QueuedInput> val = null;
			global::System.DateTime utcNow = global::System.DateTime.UtcNow;
			lock (_focusQueueLock)
			{
				DropExpiredQueuesLocked(utcNow);
				Enumerator<nint, FocusInputQueue> enumerator = _focusQueues.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						KeyValuePair<nint, FocusInputQueue> current = enumerator.Current;
						if (IsFocusedForInput(current.Value.Hwnd))
						{
							if (val == null)
							{
								val = new List<QueuedInput>();
							}
							val.AddRange((global::System.Collections.Generic.IEnumerable<QueuedInput>)current.Value.Inputs);
							current.Value.Inputs.Clear();
						}
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				if (val != null)
				{
					List<nint> val2 = new List<nint>();
					enumerator = _focusQueues.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							KeyValuePair<nint, FocusInputQueue> current2 = enumerator.Current;
							if (current2.Value.Inputs.Count == 0)
							{
								val2.Add(current2.Key);
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
					Enumerator<nint> enumerator2 = val2.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							nint current3 = enumerator2.Current;
							_focusQueues.Remove(current3);
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
			if (val == null)
			{
				return;
			}
			Enumerator<QueuedInput> enumerator3 = val.GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					QueuedInput current4 = enumerator3.Current;
					try
					{
						current4.Send.Invoke();
					}
					catch (global::System.Exception ex)
					{
						Log.Msg("[WindowInput] Queued " + current4.Description + " failed: " + ex.Message);
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			Log.Msg($"[WindowInput] Flushed {val.Count} queued inputs after focus");
		}

		private static void DropExpiredQueuesLocked(global::System.DateTime now)
		{
			//IL_0007: 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_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			List<nint> val = null;
			Enumerator<nint, FocusInputQueue> enumerator = _focusQueues.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<nint, FocusInputQueue> current = enumerator.Current;
					TimeSpan val2 = now - current.Value.StartedUtc;
					if (!(((TimeSpan)(ref val2)).TotalMilliseconds < 500.0))
					{
						if (val == null)
						{
							val = new List<nint>();
						}
						val.Add(current.Key);
						Log.Msg($"[WindowInput] Dropping {current.Value.Inputs.Count} queued inputs after focus timeout hwnd={current.Value.Hwnd}");
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			if (val == null)
			{
				return;
			}
			Enumerator<nint> enumerator2 = val.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					nint current2 = enumerator2.Current;
					_focusQueues.Remove(current2);
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
		}

		[DllImport("user32.dll", SetLastError = true)]
		private static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);

		public static void SendString(string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return;
			}
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxTypeString(text);
				return;
			}
			Log.Msg("[Keyboard] SendString: \"" + text + "\"");
			INPUT[] array = new INPUT[text.Length * 2];
			int num = 0;
			foreach (char wScan in text)
			{
				array[num++] = new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 0,
							wScan = wScan,
							dwFlags = 4u
						}
					}
				};
				array[num++] = new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 0,
							wScan = wScan,
							dwFlags = 6u
						}
					}
				};
			}
			uint num2 = SendInput((uint)array.Length, array, Marshal.SizeOf<INPUT>());
			if (num2 != array.Length)
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				Log.Msg($"[Keyboard] SendString FAILED sent={num2}/{array.Length} err={lastWin32Error}");
			}
		}

		public static void SendVirtualKey(ushort vk)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxTapKey(vk);
				return;
			}
			INPUT[] array = new INPUT[2]
			{
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = vk
						}
					}
				},
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = vk,
							dwFlags = 2u
						}
					}
				}
			};
			uint num = SendInput((uint)array.Length, array, Marshal.SizeOf<INPUT>());
			if (num != array.Length)
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				Log.Msg($"[Keyboard] SendVirtualKey FAILED vk=0x{vk:X2} sent={num}/{array.Length} err={lastWin32Error}");
			}
		}

		public static void SendVirtualKeyDown(ushort vk)
		{
			if (!_heldModifiers.Contains(vk))
			{
				_heldModifiers.Add(vk);
				if (DesktopBuddyPlatform.IsLinux)
				{
					LinuxKey(vk, pressed: true);
					return;
				}
				INPUT[] pInputs = new INPUT[1]
				{
					new INPUT
					{
						type = 1u,
						u = new INPUTUNION
						{
							ki = new KEYBDINPUT
							{
								wVk = vk
							}
						}
					}
				};
				SendInput(1u, pInputs, Marshal.SizeOf<INPUT>());
			}
		}

		public static void SendPaste()
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxKey(162, pressed: true);
				LinuxTapKey(86);
				LinuxKey(162, pressed: false);
				return;
			}
			Log.Msg("[Keyboard] Sending Ctrl+V (paste)");
			INPUT[] array = new INPUT[4]
			{
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 162
						}
					}
				},
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 86
						}
					}
				},
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 86,
							dwFlags = 2u
						}
					}
				},
				new INPUT
				{
					type = 1u,
					u = new INPUTUNION
					{
						ki = new KEYBDINPUT
						{
							wVk = 162,
							dwFlags = 2u
						}
					}
				}
			};
			uint num = SendInput((uint)array.Length, array, Marshal.SizeOf<INPUT>());
			if (num != array.Length)
			{
				Log.Msg($"[Keyboard] SendPaste FAILED sent={num}/{array.Length} err={Marshal.GetLastWin32Error()}");
			}
		}

		public static void ReleaseAllModifiers()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (_heldModifiers.Count == 0)
			{
				return;
			}
			Enumerator<ushort> enumerator;
			if (DesktopBuddyPlatform.IsLinux)
			{
				enumerator = _heldModifiers.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						LinuxKey(enumerator.Current, pressed: false);
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				_heldModifiers.Clear();
				return;
			}
			INPUT[] array = new INPUT[_heldModifiers.Count];
			int num = 0;
			enumerator = _heldModifiers.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					ushort current = enumerator.Current;
					array[num++] = new INPUT
					{
						type = 1u,
						u = new INPUTUNION
						{
							ki = new KEYBDINPUT
							{
								wVk = current,
								dwFlags = 2u
							}
						}
					};
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			SendInput((uint)array.Length, array, Marshal.SizeOf<INPUT>());
			Log.Msg($"[Keyboard] Released {_heldModifiers.Count} modifiers");
			_heldModifiers.Clear();
		}

		private static LinuxNativeBridge LinuxInput()
		{
			if (_linuxInput != null)
			{
				return _linuxInput;
			}
			lock (_linuxInputLock)
			{
				if (_linuxInput == null)
				{
					LinuxNativeBridge linuxNativeBridge = new LinuxNativeBridge();
					linuxNativeBridge.TryLoad();
					_linuxInput = linuxNativeBridge;
				}
			}
			return _linuxInput;
		}

		internal static void LinuxMove(float u, float v)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				LinuxInput().InputMotion(linuxInputSession, u, v);
			}
		}

		internal static void LinuxTouchDown(uint slot, float u, float v)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				LinuxNativeBridge linuxNativeBridge = LinuxInput();
				int num = linuxNativeBridge.TouchDown(linuxInputSession, slot, u, v);
				if (num != 0)
				{
					Log.Msg($"[LinuxInput] touch down rc={num} session={linuxInputSession} slot={slot} err={linuxNativeBridge.GetInputLastError() ?? "(none)"}");
				}
			}
		}

		internal static void LinuxTouchMove(uint slot, float u, float v)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				LinuxInput().TouchMotion(linuxInputSession, slot, u, v);
			}
		}

		internal static void LinuxTouchUp(uint slot)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				LinuxInput().TouchUp(linuxInputSession, slot);
			}
		}

		internal static void LinuxScroll(int wheelDelta)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L && wheelDelta != 0)
			{
				LinuxInput().InputScroll(linuxInputSession, (wheelDelta > 0) ? 1 : (-1));
			}
		}

		internal static void LinuxTypeString(string text)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L && !string.IsNullOrEmpty(text))
			{
				LinuxNativeBridge linuxNativeBridge = LinuxInput();
				for (int i = 0; i < text.Length; i++)
				{
					int keysym = CharToKeysym(text[i]);
					linuxNativeBridge.InputKey(linuxInputSession, keysym, pressed: true);
					linuxNativeBridge.InputKey(linuxInputSession, keysym, pressed: false);
				}
			}
		}

		internal static void LinuxKey(ushort vk, bool pressed)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				int num = VkToKeysym(vk);
				if (num != 0)
				{
					LinuxInput().InputKey(linuxInputSession, num, pressed);
				}
			}
		}

		internal static void LinuxTapKey(ushort vk)
		{
			ulong linuxInputSession = LinuxInputSession;
			if (linuxInputSession != 0L)
			{
				int num = VkToKeysym(vk);
				if (num != 0)
				{
					LinuxNativeBridge linuxNativeBridge = LinuxInput();
					linuxNativeBridge.InputKey(linuxInputSession, num, pressed: true);
					linuxNativeBridge.InputKey(linuxInputSession, num, pressed: false);
				}
			}
		}

		private static int CharToKeysym(char c)
		{
			if (c > 'ÿ')
			{
				return 16777216 + c;
			}
			return c;
		}

		private static int VkToKeysym(ushort vk)
		{
			int result = default(int);
			if (_vkKeysyms.TryGetValue(vk, ref result))
			{
				return result;
			}
			if (vk >= 65 && vk <= 90)
			{
				return 97 + (vk - 65);
			}
			if (vk >= 48 && vk <= 57)
			{
				return vk;
			}
			return 0;
		}

		[DllImport("user32.dll")]
		private static extern bool ClientToScreen(nint hWnd, ref POINT lpPoint);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool GetWindowRect(nint hWnd, out RECT lpRect);

		[DllImport("dwmapi.dll", SetLastError = true)]
		private static extern int DwmGetWindowAttribute(nint hwnd, int dwAttribute, out RECT pvAttribute, int cbAttribute);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool SetForegroundWindow(nint hWnd);

		[DllImport("user32.dll")]
		private static extern nint GetForegroundWindow();

		[DllImport("kernel32.dll")]
		private static extern uint GetCurrentThreadId();

		[DllImport("user32.dll", SetLastError = true)]
		private static extern uint GetWindowThreadProcessId(nint hWnd, out uint processId);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool AttachThreadInput(uint idAttach, uint idAttachTo, bool fAttach);

		[DllImport("user32.dll")]
		private static extern nint GetAncestor(nint hWnd, uint gaFlags);

		[DllImport("user32.dll")]
		private static extern nint GetWindow(nint hWnd, uint uCmd);

		[DllImport("user32.dll")]
		private static extern nint WindowFromPoint(POINT point);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool GetGUIThreadInfo(uint idThread, ref GUITHREADINFO lpgui);

		[DllImport("user32.dll")]
		private static extern bool BringWindowToTop(nint hWnd);

		[DllImport("user32.dll")]
		private static extern nint SetActiveWindow(nint hWnd);

		[DllImport("user32.dll")]
		private static extern nint SetFocus(nint hWnd);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool SetWindowPos(nint hWnd, nint hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);

		[DllImport("user32.dll")]
		private static extern bool SetCursorPos(int X, int Y);

		[DllImport("user32.dll")]
		private static extern void mouse_event(uint dwFlags, int dx, int dy, int dwData, nint dwExtraInfo);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern nint SetWinEventHook(uint eventMin, uint eventMax, nint hmodWinEventProc, WinEventDelegate lpfnWinEventProc, uint idProcess, uint idThread, uint dwFlags);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool GetMessage(out MSG lpMsg, nint hWnd, uint wMsgFilterMin, uint wMsgFilterMax);

		[DllImport("user32.dll")]
		private static extern bool TranslateMessage(ref MSG lpMsg);

		[DllImport("user32.dll")]
		private static extern nint DispatchMessage(ref MSG lpMsg);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool InitializeTouchInjection(uint maxCount, uint dwMode);

		[DllImport("user32.dll", SetLastError = true)]
		private static extern bool InjectTouchInput(uint count, [In] POINTER_TOUCH_INFO[] contacts);

		public static void SendHover(nint hWnd, float u, float v, int clientW, int clientH, nint monitorHandle = 0)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxMove(u, v);
				return;
			}
			POINT pOINT = UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle);
			SetCursorPos(pOINT.X, pOINT.Y);
		}

		public static void SendTouchDown(nint hWnd, float u, float v, int clientW, int clientH, uint touchId = 0u, nint monitorHandle = 0)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxTouchDown(touchId, u, v);
				return;
			}
			lock (_sendLock)
			{
				if (EnsureTouchInit())
				{
					POINT pOINT = UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle);
					if (touchId < 10)
					{
						_lastPosition[touchId] = pOINT;
						_moveFailLogged[touchId] = false;
					}
					POINTER_TOUCH_INFO pOINTER_TOUCH_INFO = new POINTER_TOUCH_INFO
					{
						pointerInfo = 
						{
							pointerType = 2u,
							pointerId = touchId,
							ptPixelLocation = pOINT,
							pointerFlags = 65542u
						},
						touchFlags = 0u,
						touchMask = 14u,
						orientation = 90u,
						pressure = 32000u,
						rcContact = 
						{
							Top = pOINT.Y - 2,
							Bottom = pOINT.Y + 2,
							Left = pOINT.X - 2,
							Right = pOINT.X + 2
						}
					};
					_touchArr[0] = pOINTER_TOUCH_INFO;
					if (!InjectTouchInput(1u, _touchArr))
					{
						int lastWin32Error = Marshal.GetLastWin32Error();
						Log.Msg($"[Touch] Down FAILED id={touchId} screen=({pOINT.X},{pOINT.Y}) err={lastWin32Error}");
					}
					else
					{
						Log.Msg($"[Touch] Down OK id={touchId} screen=({pOINT.X},{pOINT.Y})");
					}
				}
			}
		}

		public static void SendTouchMove(nint hWnd, float u, float v, int clientW, int clientH, uint touchId = 0u, nint monitorHandle = 0)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxTouchMove(touchId, u, v);
				return;
			}
			lock (_sendLock)
			{
				if (_touchInitialized)
				{
					POINT pOINT = UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle);
					if (touchId < 10)
					{
						_lastPosition[touchId] = pOINT;
					}
					POINTER_TOUCH_INFO pOINTER_TOUCH_INFO = new POINTER_TOUCH_INFO
					{
						pointerInfo = 
						{
							pointerType = 2u,
							pointerId = touchId,
							ptPixelLocation = pOINT,
							pointerFlags = 131078u
						},
						touchFlags = 0u,
						touchMask = 14u,
						orientation = 90u,
						pressure = 32000u,
						rcContact = 
						{
							Top = pOINT.Y - 2,
							Bottom = pOINT.Y + 2,
							Left = pOINT.X - 2,
							Right = pOINT.X + 2
						}
					};
					_touchArr[0] = pOINTER_TOUCH_INFO;
					if (!InjectTouchInput(1u, _touchArr) && touchId < 10 && !_moveFailLogged[touchId])
					{
						_moveFailLogged[touchId] = true;
						int lastWin32Error = Marshal.GetLastWin32Error();
						Log.Msg($"[Touch] Move FAILED id={touchId} err={lastWin32Error} (further move errors suppressed)");
					}
				}
			}
		}

		public static void SendTouchUp(nint hWnd, float u, float v, int clientW, int clientH, uint touchId = 0u, nint monitorHandle = 0)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxTouchUp(touchId);
				return;
			}
			lock (_sendLock)
			{
				if (_touchInitialized)
				{
					POINT ptPixelLocation = ((touchId < 10) ? _lastPosition[touchId] : UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle));
					POINTER_TOUCH_INFO pOINTER_TOUCH_INFO = new POINTER_TOUCH_INFO
					{
						pointerInfo = 
						{
							pointerType = 2u,
							pointerId = touchId,
							ptPixelLocation = ptPixelLocation,
							pointerFlags = 262144u
						}
					};
					_touchArr[0] = pOINTER_TOUCH_INFO;
					if (!InjectTouchInput(1u, _touchArr))
					{
						int lastWin32Error = Marshal.GetLastWin32Error();
						Log.Msg($"[Touch] Up FAILED id={touchId} err={lastWin32Error}");
					}
					else
					{
						Log.Msg($"[Touch] Up OK id={touchId}");
					}
				}
			}
		}

		public static void SendScroll(nint hWnd, float u, float v, int clientW, int clientH, int wheelDelta, nint monitorHandle = 0)
		{
			if (DesktopBuddyPlatform.IsLinux)
			{
				LinuxMove(u, v);
				LinuxScroll(wheelDelta);
				return;
			}
			lock (_sendLock)
			{
				POINT pOINT = UvToScreen(hWnd, u, v, clientW, clientH, monitorHandle);
				SetCursorPos(pOINT.X, pOINT.Y);
				mouse_event(2048u, 0, 0, wheelDelta, global::System.IntPtr.Zero);
			}
		}
	}
	public sealed class BuiltInStreamServer : global::System.IDisposable
	{
		private sealed class StreamEntry
		{
			public readonly ILiveStreamSource Source;

			private int _clientCount;

			public StreamEntry(ILiveStreamSource source)
			{
				Source = source;
			}

			public int AddClient()
			{
				return Interlocked.Increment(ref _clientCount);
			}

			public int RemoveClient()
			{
				int num = Interlocked.Decrement(ref _clientCount);
				return Math.Max(0, num);
			}
		}

		[StructLayout((LayoutKind)3)]
		[CompilerGenerated]
		private struct <HandleRequestAsync>d__14 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public HttpListenerContext ctx;

			public BuiltInStreamServer <>4__this;

			private ConfiguredTaskAwaiter <>u__1;

			private void MoveNext()
			{
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: 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)
				int num = <>1__state;
				BuiltInStreamServer builtInStreamServer = <>4__this;
				try
				{
					try
					{
						ConfiguredTaskAwaiter val;
						if (num == 0)
						{
							val = <>u__1;
							<>u__1 = default(ConfiguredTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_00ac;
						}
						Uri url = ctx.Request.Url;
						string text = ((url != null) ? url.AbsolutePath : null) ?? "/";
						if (text.StartsWith("/stream/"))
						{
							ConfiguredTaskAwaitable val2 = builtInStreamServer.ServeStreamAsync(ctx, text).ConfigureAwait(false);
							val = ((ConfiguredTaskAwaitable)(ref val2)).GetAwaiter();
							if (!((ConfiguredTaskAwaiter)(ref val)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val;
								((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter, <HandleRequestAsync>d__14>(ref val, ref this);
								return;
							}
							goto IL_00ac;
						}
						ctx.Response.StatusCode = 404;
						ctx.Response.Close();
						goto end_IL_0011;
						IL_00ac:
						((ConfiguredTaskAwaiter)(ref val)).GetResult();
						end_IL_0011:;
					}
					catch (global::System.Exception ex)
					{
						Log.Msg("[BuiltInStreamServer] Request error: " + ex.Message);
						try
						{
							ctx.Response.Close();
						}
						catch (global::System.Exception ex2)
						{
							Log.Msg("[BuiltInStreamServer] Response close error: " + ex2.Message);
						}
					}
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		[StructLayout((LayoutKind)3)]
		[CompilerGenerated]
		private struct <ListenLoopAsync>d__13 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public BuiltInStreamServer <>4__this;

			private ConfiguredTaskAwaiter<HttpListenerContext> <>u__1;

			private void MoveNext()
			{
				//IL_009b: Expected O, but got Unknown
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: 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)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: 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)
				int num = <>1__state;
				BuiltInStreamServer builtInStreamServer = <>4__this;
				try
				{
					if (num == 0)
					{
						goto IL_0021;
					}
					Log.Msg("[BuiltInStreamServer] Async listen loop started");
					goto IL_00da;
					IL_00e7:
					Log.Msg("[BuiltInStreamServer] Async listen loop ended");
					goto end_IL_000e;
					IL_00da:
					if (builtInStreamServer._running)
					{
						goto IL_0021;
					}
					goto IL_00e7;
					IL_0021:
					try
					{
						ConfiguredTaskAwaiter<HttpListenerContext> val;
						if (num != 0)
						{
							val = builtInStreamServer._listener.GetContextAsync().ConfigureAwait(false).GetAwaiter();
							if (!val.IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val;
								((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<HttpListenerContext>, <ListenLoopAsync>d__13>(ref val, ref this);
								return;
							}
						}
						else
						{
							val = <>u__1;
							<>u__1 = default(ConfiguredTaskAwaiter<HttpListenerContext>);
							num = (<>1__state = -1);
						}
						HttpListenerContext result = val.GetResult();
						builtInStreamServer.HandleRequestAsync(result);
					}
					catch (HttpListenerException ex)
					{
						HttpListenerException ex2 = ex;
						Log.Msg("[BuiltInStreamServer] Listener stopped: " + ((global::System.Exception)(object)ex2).Message);
						goto IL_00e7;
					}
					catch (ObjectDisposedException)
					{
						Log.Msg("[BuiltInStreamServer] Listener disposed, stopping");
						goto IL_00e7;
					}
					catch (global::System.Exception ex4)
					{
						Log.Msg("[BuiltInStreamServer] Listen error: " + ex4.Message);
					}
					goto IL_00da;
					end_IL_000e:;
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		[StructLayout((LayoutKind)3)]
		[CompilerGenerated]
		private struct <ServeStreamAsync>d__15 : IAsyncStateMachine
		{
			public int <>1__state;

			public AsyncTaskMethodBuilder <>t__builder;

			public string urlPath;

			public HttpListenerContext ctx;

			public BuiltInStreamServer <>4__this;

			private int <streamId>5__2;

			private StreamEntry <entry>5__3;

			private ILiveStreamSource <encoder>5__4;

			private int <waitCount>5__5;

			private long <connectionId>5__6;

			private long <minimumKeyframePos>5__7;

			private int <keyframeWaitCount>5__8;

			private long <totalBytes>5__9;

			private long <readPos>5__10;

			private bool <aligned>5__11;

			private byte[] <buffer>5__12;

			private ConfiguredTaskAwaiter <>u__1;

			private int <read>5__13;

			private void MoveNext()
			{
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_06f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0700: Unknown result type (might be due to invalid IL or missing references)
				//IL_080b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0810: Unknown result type (might be due to invalid IL or missing references)
				//IL_0818: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0264: 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_026d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0272: Unknown result type (might be due to invalid IL or missing references)
				//IL_0287: Unknown result type (might be due to invalid IL or missing references)
				//IL_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_06ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_06be: Unknown result type (might be due to invalid IL or missing references)
				//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_07cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_07d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_07db: Unknown result type (might be due to invalid IL or missing references)
				//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_06da: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_07f2: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				BuiltInStreamServer builtInStreamServer = <>4__this;
				try
				{
					ConfiguredTaskAwaiter val;
					ConfiguredTaskAwaitable val2;
					switch (num)
					{
					default:
					{
						string[] array = urlPath.Split('/', (StringSplitOptions)1);
						if (array.Length < 2)
						{
							ctx.Response.StatusCode = 404;
							ctx.Response.Close();
						}
						else
						{
							if (int.TryParse(array[1], ref <streamId>5__2) && builtInStreamServer._streams.TryGetValue(<streamId>5__2, ref <entry>5__3))
							{
								<encoder>5__4 = <entry>5__3.Source;
								<waitCount>5__5 = 0;
								goto IL_0186;
							}
							Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} not found");
							ctx.Response.StatusCode = 404;
							ctx.Response.Close();
						}
						goto end_IL_000e;
					}
					case 0:
						val = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
						goto IL_016d;
					case 1:
						val = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
						goto IL_02be;
					case 2:
					case 3:
						break;
						IL_0186:
						if (!<encoder>5__4.IsRunning && <waitCount>5__5 < 50)
						{
							val2 = global::System.Threading.Tasks.Task.Delay(100).ConfigureAwait(false);
							val = ((ConfiguredTaskAwaitable)(ref val2)).GetAwaiter();
							if (!((ConfiguredTaskAwaiter)(ref val)).IsCompleted)
							{
								num = (<>1__state = 0);
								<>u__1 = val;
								((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter, <ServeStreamAsync>d__15>(ref val, ref this);
								return;
							}
							goto IL_016d;
						}
						if (<encoder>5__4.IsRunning)
						{
							<connectionId>5__6 = Interlocked.Increment(ref builtInStreamServer._nextConnectionId);
							<minimumKeyframePos>5__7 = <encoder>5__4.CurrentWritePosition;
							<keyframeWaitCount>5__8 = 0;
							goto IL_02d7;
						}
						Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} encoder not ready after {<waitCount>5__5 * 100}ms");
						ctx.Response.StatusCode = 503;
						ctx.Response.Close();
						goto end_IL_000e;
						IL_02be:
						((ConfiguredTaskAwaiter)(ref val)).GetResult();
						<keyframeWaitCount>5__8++;
						goto IL_02d7;
						IL_02d7:
						if (<encoder>5__4.IsRunning && !<encoder>5__4.HasReadableVideoKeyframeAtOrAfter(<minimumKeyframePos>5__7) && <keyframeWaitCount>5__8 < 300)
						{
							val2 = global::System.Threading.Tasks.Task.Delay(10).ConfigureAwait(false);
							val = ((ConfiguredTaskAwaitable)(ref val2)).GetAwaiter();
							if (!((ConfiguredTaskAwaiter)(ref val)).IsCompleted)
							{
								num = (<>1__state = 1);
								<>u__1 = val;
								((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter, <ServeStreamAsync>d__15>(ref val, ref this);
								return;
							}
							goto IL_02be;
						}
						if (<encoder>5__4.HasReadableVideoKeyframeAtOrAfter(<minimumKeyframePos>5__7))
						{
							if (<keyframeWaitCount>5__8 > 0)
							{
								Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} conn={<connectionId>5__6} fresh keyframe readable after {<keyframeWaitCount>5__8 * 10}ms from minPos={<minimumKeyframePos>5__7}: {<encoder>5__4.ReadableStreamState}");
							}
							int num2 = <entry>5__3.AddClient();
							Log.Msg($"[BuiltInStreamServer] Stream client added stream={<streamId>5__2} conn={<connectionId>5__6} clients={num2}");
							Log.Msg($"[BuiltInStreamServer] Serving stream {<streamId>5__2} conn={<connectionId>5__6} to {ctx.Request.RemoteEndPoint} local={ctx.Request.LocalEndPoint} {DescribeRequest(ctx.Request)}");
							ctx.Response.ContentType = "video/mp2t";
							ctx.Response.SendChunked = true;
							ctx.Response.StatusCode = 200;
							((NameValueCollection)ctx.Response.Headers)["Cache-Control"] = "no-store, no-cache, max-age=0";
							((NameValueCollection)ctx.Response.Headers)["Pragma"] = "no-cache";
							((NameValueCollection)ctx.Response.Headers)["X-Accel-Buffering"] = "no";
							<totalBytes>5__9 = 0L;
							<readPos>5__10 = 0L;
							<aligned>5__11 = false;
							<buffer>5__12 = new byte[65536];
							break;
						}
						Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} conn={<connectionId>5__6} has no fresh readable keyframe after {<keyframeWaitCount>5__8 * 10}ms from minPos={<minimumKeyframePos>5__7}: {<encoder>5__4.ReadableStreamState}");
						ctx.Response.StatusCode = 503;
						ctx.Response.Close();
						goto end_IL_000e;
						IL_016d:
						((ConfiguredTaskAwaiter)(ref val)).GetResult();
						<waitCount>5__5++;
						goto IL_0186;
					}
					try
					{
						if (num != 2)
						{
							if (num != 3)
							{
								goto IL_0842;
							}
							val = <>u__1;
							<>u__1 = default(ConfiguredTaskAwaiter);
							num = (<>1__state = -1);
							goto IL_0827;
						}
						val = <>u__1;
						<>u__1 = default(ConfiguredTaskAwaiter);
						num = (<>1__state = -1);
						goto IL_070f;
						IL_0827:
						((ConfiguredTaskAwaiter)(ref val)).GetResult();
						<totalBytes>5__9 += <read>5__13;
						goto IL_0842;
						IL_0842:
						if (builtInStreamServer._running && <encoder>5__4.IsRunning)
						{
							<read>5__13 = <encoder>5__4.ReadStream(<buffer>5__12, ref <readPos>5__10, ref <aligned>5__11, <minimumKeyframePos>5__7, out var _);
							if (<read>5__13 == 0)
							{
								val2 = <encoder>5__4.WaitForDataAsync(5).ConfigureAwait(false);
								val = ((ConfiguredTaskAwaitable)(ref val2)).GetAwaiter();
								if (!((ConfiguredTaskAwaiter)(ref val)).IsCompleted)
								{
									num = (<>1__state = 2);
									<>u__1 = val;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter, <ServeStreamAsync>d__15>(ref val, ref this);
									return;
								}
								goto IL_070f;
							}
							if (<read>5__13 >= 0)
							{
								val2 = ctx.Response.OutputStream.WriteAsync(<buffer>5__12, 0, <read>5__13).ConfigureAwait(false);
								val = ((ConfiguredTaskAwaitable)(ref val2)).GetAwaiter();
								if (!((ConfiguredTaskAwaiter)(ref val)).IsCompleted)
								{
									num = (<>1__state = 3);
									<>u__1 = val;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter, <ServeStreamAsync>d__15>(ref val, ref this);
									return;
								}
								goto IL_0827;
							}
							Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} conn={<connectionId>5__6} fell behind the ring; closing response for clean player reconnect. state=({<encoder>5__4.GetReaderDiagnostics(<readPos>5__10, <aligned>5__11)})");
						}
						goto end_IL_0662;
						IL_070f:
						((ConfiguredTaskAwaiter)(ref val)).GetResult();
						goto IL_0842;
						end_IL_0662:;
					}
					catch (global::System.Exception ex)
					{
						Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} conn={<connectionId>5__6} error: {((MemberInfo)ex.GetType()).Name}: {ex.Message} sent={<totalBytes>5__9} state=({<encoder>5__4.GetReaderDiagnostics(<readPos>5__10, <aligned>5__11)})");
					}
					finally
					{
						if (num < 0)
						{
							int num2 = <entry>5__3.RemoveClient();
							Log.Msg($"[BuiltInStreamServer] Stream client removed stream={<streamId>5__2} conn={<connectionId>5__6} clients={num2}");
							try
							{
								ctx.Response.Close();
							}
							catch (global::System.Exception ex2)
							{
								Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} response close error: {ex2.Message}");
							}
							Log.Msg($"[BuiltInStreamServer] Stream {<streamId>5__2} conn={<connectionId>5__6} ended, sent {<totalBytes>5__9} bytes state=({<encoder>5__4.GetReaderDiagnostics(<readPos>5__10, <aligned>5__11)})");
						}
					}
					end_IL_000e:;
				}
				catch (global::System.Exception exception)
				{
					<>1__state = -2;
					<entry>5__3 = null;
					<encoder>5__4 = null;
					<buffer>5__12 = null;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
					return;
				}
				<>1__state = -2;
				<entry>5__3 = null;
				<encoder>5__4 = null;
				<buffer>5__12 = null;
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
			}

			[DebuggerHidden]
			private void SetStateMachine(IAsyncStateMachine stateMachine)
			{
				((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
			}
		}

		private const int StreamBufferSize = 65536;

		private HttpListener _listener;

		private volatile bool _running;

		private readonly int _port;

		private long _nextConnectionId;

		private readonly ConcurrentDictionary<int, StreamEntry> _streams = new ConcurrentDictionary<int, StreamEntry>();

		public int Port => _port;

		public BuiltInStreamServer(int port = 48080)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			_port = port;
			_listener = new HttpListener();
			_running = true;
		}

		public void Start()
		{
			_listener.Prefixes.Add($"http://+:{_port}/");
			_listener.Start();
			Log.Msg($"[BuiltInStreamServer] Listening on http://+:{_port}/");
			ListenLoopAsync();
		}

		public FfmpegEncoder CreateEncoder(int streamId)
		{
			FfmpegEncoder ffmpegEncoder = new FfmpegEncoder(streamId);
			_streams[streamId] = new StreamEntry(ffmpegEncoder);
			Log.Msg($"[BuiltInStreamServer] Created encoder for stream {streamId}");
			return ffmpegEncoder;
		}

		public void RegisterSource(int streamId, ILiveStreamSource source)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			_streams[streamId] = new StreamEntry(source);
			Log.Msg($"[BuiltInStreamServer] Registered source {((MemberInfo)((object)source).GetType()).Name} for stream {streamId}");
		}

		public void StopEncoder(int streamId)
		{
			Log.Msg($"[CleanupTrace] BuiltInStreamServer.StopEncoder ENTER stream={streamId}");
			StreamEntry streamEntry = default(StreamEntry);
			if (_streams.TryRemove(streamId, ref streamEntry))
			{
				Log.Msg($"[CleanupTrace] BuiltInStreamServer.StopEncoder removed entry stream={streamId}; source.Dispose START");
				((global::System.IDisposable)streamEntry.Source).Dispose();
				Log.Msg($"[CleanupTrace] BuiltInStreamServer.StopEncoder EXIT stream={streamId}");
			}
		}

		[AsyncStateMachine(typeof(<ListenLoopAsync>d__13))]
		private global::System.Threading.Tasks.Task ListenLoopAsync()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<ListenLoopAsync>d__13 <ListenLoopAsync>d__ = default(<ListenLoopAsync>d__13);
			<ListenLoopAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<ListenLoopAsync>d__.<>4__this = this;
			<ListenLoopAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <ListenLoopAsync>d__.<>t__builder)).Start<<ListenLoopAsync>d__13>(ref <ListenLoopAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <ListenLoopAsync>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<HandleRequestAsync>d__14))]
		private global::System.Threading.Tasks.Task HandleRequestAsync(HttpListenerContext ctx)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<HandleRequestAsync>d__14 <HandleRequestAsync>d__ = default(<HandleRequestAsync>d__14);
			<HandleRequestAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<HandleRequestAsync>d__.<>4__this = this;
			<HandleRequestAsync>d__.ctx = ctx;
			<HandleRequestAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <HandleRequestAsync>d__.<>t__builder)).Start<<HandleRequestAsync>d__14>(ref <HandleRequestAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <HandleRequestAsync>d__.<>t__builder)).Task;
		}

		[AsyncStateMachine(typeof(<ServeStreamAsync>d__15))]
		private global::System.Threading.Tasks.Task ServeStreamAsync(HttpListenerContext ctx, string urlPath)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			<ServeStreamAsync>d__15 <ServeStreamAsync>d__ = default(<ServeStreamAsync>d__15);
			<ServeStreamAsync>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
			<ServeStreamAsync>d__.<>4__this = this;
			<ServeStreamAsync>d__.ctx = ctx;
			<ServeStreamAsync>d__.urlPath = urlPath;
			<ServeStreamAsync>d__.<>1__state = -1;
			((AsyncTaskMethodBuilder)(ref <ServeStreamAsync>d__.<>t__builder)).Start<<ServeStreamAsync>d__15>(ref <ServeStreamAsync>d__);
			return ((AsyncTaskMethodBuilder)(ref <ServeStreamAsync>d__.<>t__builder)).Task;
		}

		private static string DescribeRequest(HttpListenerRequest request)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			StringBuilder val = new StringBuilder();
			val.Append("method=").Append(request.HttpMethod);
			val.Append(" proto=").Append((object)request.ProtocolVersion);
			val.Append(" ua=\"").Append(request.UserAgent ?? "").Append('"');
			val.Append(" accept=\"").Append(request.Headers["Accept"] ?? "").Append('"');
			val.Append(" range=\"").Append(request.Headers["Range"] ?? "").Append('"');
			val.Append(" forwarded=\"").Append(request.Headers["X-Forwarded-For"] ?? "").Append('"');
			val.Append(" cfRay=\"").Append(request.Headers["Cf-Ray"] ?? request.Headers["CF-Ray"] ?? "").Append('"');
			return ((object)val).ToString();
		}

		public void Dispose()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			Log.Msg($"[CleanupTrace] BuiltInStreamServer.Dispose ENTER streams={_streams.Count}");
			_running = false;
			global::System.Collections.Generic.IEnumerator<KeyValuePair<int, StreamEntry>> enumerator = _streams.GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					KeyValuePair<int, StreamEntry> current = enumerator.Current;
					Log.Msg($"[CleanupTrace] BuiltInStreamServer.Dispose source.Dispose START stream={current.Key}");
					((global::System.IDisposable)current.Value.Source).Dispose();
					Log.Msg($"[CleanupTrace] BuiltInStreamServer.Dispose source.Dispose DONE stream={current.Key}");
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			_streams.Clear();
			Log.Msg("[CleanupTrace] BuiltInStreamServer.Dispose listener.Stop START");
			try
			{
				_listener.Stop();
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[BuiltInStreamServer] Listener stop error: " + ex.Message);
			}
			Log.Msg("[CleanupTrace] BuiltInStreamServer.Dispose listener.Close START");
			try
			{
				_listener.Close();
			}
			catch (global::System.Exception ex2)
			{
				Log.Msg("[BuiltInStreamServer] Listener close error: " + ex2.Message);
			}
			Log.Msg("[CleanupTrace] BuiltInStreamServer.Dispose EXIT");
		}
	}
	public class DesktopSession
	{
		public DesktopStreamer Streamer;

		public DesktopTextureProvider Texture;

		public RawImage TextureImage;

		public Canvas Canvas;

		public Slot Root;

		public bool UpdateInProgress;

		public bool UseTextureBridge;

		public bool BridgeRegistrationPending;

		public int SharedTextureSlot = -1;

		public int PendingBridgeDisplayIndex = -1;

		public bool BridgeDisplayIndexApplied;

		public int LastKnownW;

		public int LastKnownH;

		public Component LastActiveSource;

		public HashSet<uint> ActiveTouchIds = new HashSet<uint>();

		public int LastScrollSign;

		public double LastScrollTick;

		public int StreamId;

		public nint Hwnd;

		public uint ProcessId;

		public double TimeSinceChildCheck;

		public double TimeSinceValidCheck;

		public bool LastValidState = true;

		public TextRenderer TitleText;

		public string LastTitle;

		public HashSet<nint> SeenRelatedHwnds = new HashSet<nint>();

		public bool Cleaned;

		public double ResizeDebounceUntil;

		public int PendingResizeW;

		public int PendingResizeH;

		public int PendingVisualResizeW;

		public int PendingVisualResizeH;

		public BoxCollider Collider;

		public Slot TopBarRenderHost;

		public SettingsPanelState SettingsPanel;

		public Slot CullingPreviewSlot;

		public CurvedPlaneMesh PanelMesh;

		public float PanelCanvasScale;

		public string OwnerUserId;

		public ValueUserOverride<bool> ViewerStreamAllowed;

		public ValueUserOverride<bool> PreviewStreamAllowed;

		public ValueUserOverride<bool> StreamVisualAllowed;

		public ValueUserOverride<bool> FinalStreamAllowedOverride;

		public ValueField<bool> ViewerAllowedField;

		public ValueField<bool> PreviewAllowedField;

		public ValueField<bool> FinalStreamAllowedField;

		public BooleanValueDriver<Uri> StreamUrlDriver;

		public Uri StreamUrl;

		public readonly Dictionary<string, bool> ViewerStreamEnabledByUserId = new Dictionary<string, bool>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);

		public readonly Dictionary<string, bool> CullingAppliedStreamAllowedByUserId = new Dictionary<string, bool>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);

		public readonly Dictionary<string, double> CullingOutOfRangeSinceByUserId = new Dictionary<string, double>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);

		public readonly HashSet<string> CullingPresentUserIds = new HashSet<string>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);

		public readonly List<string> CullingStaleUserIds = new List<string>();

		public bool LocalPreviewingRemoteStream;

		public int CullingGateGeneration;

		public double CullingOutOfRangeSince = -1.0;

		public DesktopKeyboardSource KeyboardSource;

		public ulong LinuxInputSessionId;

		public FfmpegEncoder Encoder;

		internal ILiveStreamSource StreamSource;

		public int EncoderInitialStreamId;

		public int EncoderInitialSourceW;

		public int EncoderInitialSourceH;

		public bool StreamUsesMediaMtx;

		public AudioCapture StreamAudioCapture;

		public Action StartStreamAudioCapture;

		public VideoTextureProvider VideoTexture;

		public AudioOutput StreamAudioOutput;

		public Slider<float> StreamVolumeSlider;

		public bool FeedsVirtualCamera;

		public Slot VCamSlot;

		public Camera VCamCamera;

		public RenderTextureProvider VCamPreviewTexture;

		public bool VCamRenderPending;

		public long VCamLastSubmitTicks;

		public UI_UnlitMaterial VCamIndicator;

		public bool VCamLastLitState;

		public Slot VMicSlot;

		public AudioListener VMicListener;

		public UI_UnlitMaterial VMicIndicator;

		public bool VMicMuted;

		public Light AdaptiveLight;

		public D3D11AverageColorSampler AdaptiveLightSampler;

		public long AdaptiveLightLastSampleTicks;

		public DesktopAudioSource SpatialAudioSource;

		public AudioOutput SpatialAudioOutput;

		public bool OwnsAudioRedirect;

		public Action<int, int> OnResize;
	}
	public sealed class SettingsPanelState
	{
		public Slot RenderHost;

		public Slot RenderRoot;

		public Slot SurfaceSlot;

		public Canvas Canvas;

		public RectTransform ModalRect;

		public RenderTextureProvider RenderTexture;

		public Camera Camera;

		public CurvedPlaneMesh Mesh;

		public BlurMaterial BackgroundBlur;

		public StaticTexture2D BackgroundBlurMask;

		public int BackgroundBlurMaskWidth;

		public int BackgroundBlurMaskHeight;

		public Slot ContentRoot;

		public Slot TabRoot;

		public ScrollRect ContentScroll;

		public ScrollRect DebugLogScroll;

		public Text DebugLogText;

		public List<UiScrollbarState> Scrollbars = new List<UiScrollbarState>();

		public Slot OwnerRoot;

		public DesktopSession Session;

		public int RenderWidth;

		public int RenderHeight;

		public int ModalWidth;

		public int ModalHeight;

		public float CanvasScale;

		public SettingsPanelTab ActiveTab;

		public bool ViewerCullingPreviewEnabled;

		public string ViewerCullingMode = "frustum";

		public float ViewerFrustumAngle = 120f;

		public float ViewerFrustumDepth = 3f;

		public float ViewerDistance = 3f;

		public int DebugLogRefreshGeneration;

		public string DebugLogContent;

		public int ViewerListRefreshGeneration;

		public string ViewerListSignature;

		public int StickScrollGeneration;
	}
	public enum SettingsPanelTab
	{
		Viewers,
		General,
		Stream,
		Audio,
		Network,
		Devices,
		Debug,
		UpdateInfo
	}
	internal static class DesktopInputWiring
	{
		internal static DesktopCurvedScreenInput Wire(Slot root, nint hwnd, DesktopStreamer streamer, DesktopSession session, CurvedPlaneMesh screenMesh, Func<Grabbable> getGrabbable)
		{
			FieldInfo handlerField = typeof(InteractionLaser).GetField("_handler", (BindingFlags)36);
			DesktopCurvedScreenInput desktopCurvedScreenInput = ((ContainerWorker<Component>)(object)((Component)screenMesh).Slot).AttachComponent<DesktopCurvedScreenInput>(true, (Action<DesktopCurvedScreenInput>)null);
			desktopCurvedScreenInput.ScreenMesh = screenMesh;
			desktopCurvedScreenInput.Pressed = SendDesktopPressed;
			desktopCurvedScreenInput.Pressing = SendDesktopPressing;
			desktopCurvedScreenInput.Released = SendDesktopReleased;
			desktopCurvedScreenInput.Hovering = SendDesktopHovering;
			return desktopCurvedScreenInput;
			void ClaimSource(Component source)
			{
				if (source != session.LastActiveSource)
				{
					session.LastActiveSource = source;
				}
			}
			InteractionHandler FindHandler(Component source)
			{
				if (source == null)
				{
					return null;
				}
				InteractionLaser val = ((ContainerWorker<Component>)(object)source.Slot)?.GetComponent<InteractionLaser>((Predicate<InteractionLaser>)null, false);
				if (val != null && handlerField != (FieldInfo)null)
				{
					return (handlerField.GetValue((object)val) as SyncRef<InteractionHandler>)?.Target;
				}
				Slot slot = source.Slot;
				if (slot == null)
				{
					return null;
				}
				return slot.GetComponentInParents<InteractionHandler>((Predicate<InteractionHandler>)null, true, false);
			}
			uint GetTouchId(Component source)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Invalid comparison between Unknown and I4
				InteractionHandler val = FindHandler(source);
				if (val != null && (int)((SyncField<Chirality>)(object)val.Side).Value == 1)
				{
					return 1u;
				}
				return 0u;
			}
			bool IsActiveSource(Component source)
			{
				if (session.LastActiveSource == null || ((ComponentBase<Component>)(object)session.LastActiveSource).IsDestroyed)
				{
					return true;
				}
				return source == session.LastActiveSource;
			}
			void SendDesktopHovering(Component source, float2 point)
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Expected O, but got Unknown
				//IL_0167: 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_0276: Expected O, but got Unknown
				TargetLinuxInput();
				if (ShouldIgnoreDesktopInput())
				{
					return;
				}
				float hu = point.x;
				float hv = point.y;
				if (IsActiveSource(source))
				{
					WindowInput.SendHover(hwnd, hu, hv, streamer.Width, streamer.Height, streamer.MonitorHandle);
				}
				Mouse mouse = ((Worker)root).World.InputInterface.Mouse;
				if (mouse != null)
				{
					float y = mouse.ScrollWheelDelta.Value.y;
					if (y != 0f)
					{
						ClaimSource(source);
						int wheelDelta = ((y > 0f) ? 120 : (-120));
						WindowInput.SendAtPointWhenTargetAcceptable(hwnd, hu, hv, streamer.Width, streamer.Height, streamer.MonitorHandle, (Action)delegate
						{
							WindowInput.SendScroll(hwnd, hu, hv, streamer.Width, streamer.Height, wheelDelta, streamer.MonitorHandle);
						}, "mouse wheel");
					}
				}
				try
				{
					InteractionHandler val = FindHandler(source);
					IStandardController val2 = ((val != null) ? ((Worker)root).World.InputInterface.GetControllerNode(((SyncField<Chirality>)(object)val.Side).Value) : null);
					if (val2 != null)
					{
						float y2 = val2.Axis.Value.y;
						if (Math.Abs(y2) > 0.15f)
						{
							double worldTime = ((Worker)root).World.Time.WorldTime;
							bool flag = session.LastScrollSign == 0 || Math.Sign(y2) == session.LastScrollSign;
							if (worldTime != session.LastScrollTick && flag)
							{
								session.LastScrollTick = worldTime;
								session.LastScrollSign = Math.Sign(y2);
								ClaimSource(source);
								int wheelDelta2 = (int)(y2 * 120f);
								WindowInput.SendAtPointWhenTargetAcceptable(hwnd, hu, hv, streamer.Width, streamer.Height, streamer.MonitorHandle, (Action)delegate
								{
									WindowInput.SendScroll(hwnd, hu, hv, streamer.Width, streamer.Height, wheelDelta2, streamer.MonitorHandle);
								}, "controller wheel");
							}
						}
						else
						{
							session.LastScrollSign = 0;
						}
					}
				}
				catch
				{
				}
			}
			void SendDesktopPressed(Component source, float2 point)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Expected O, but got Unknown
				TargetLinuxInput();
				if (!ShouldIgnoreDesktopInput())
				{
					ClaimSource(source);
					float u = point.x;
					float v = point.y;
					uint touchId = GetTouchId(source);
					session.ActiveTouchIds.Add(touchId);
					WindowInput.SendAtPointWhenTargetAcceptable(hwnd, u, v, streamer.Width, streamer.Height, streamer.MonitorHandle, (Action)delegate
					{
						WindowInput.SendTouchDown(hwnd, u, v, streamer.Width, streamer.Height, touchId, streamer.MonitorHandle);
					}, $"touch down {touchId}");
				}
			}
			void SendDesktopPressing(Component source, float2 point)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				TargetLinuxInput();
				if (!ShouldIgnoreDesktopInput())
				{
					uint touchId = GetTouchId(source);
					if (session.ActiveTouchIds.Contains(touchId))
					{
						float u = point.x;
						float v = point.y;
						WindowInput.SendAtPointWhenTargetAcceptable(hwnd, u, v, streamer.Width, streamer.Height, streamer.MonitorHandle, (Action)delegate
						{
							WindowInput.SendTouchMove(hwnd, u, v, streamer.Width, streamer.Height, touchId, streamer.MonitorHandle);
						}, $"touch move {touchId}");
					}
				}
			}
			void SendDesktopReleased(Component source, float2 point)
			{
				//IL_002a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0094: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				TargetLinuxInput();
				if (!ShouldIgnoreDesktopInput())
				{
					uint touchId = GetTouchId(source);
					float u = point.x;
					float v = point.y;
					if (session.ActiveTouchIds.Remove(touchId))
					{
						WindowInput.SendAtPointWhenTargetAcceptable(hwnd, u, v, streamer.Width, streamer.Height, streamer.MonitorHandle, (Action)delegate
						{
							WindowInput.SendTouchUp(hwnd, u, v, streamer.Width, streamer.Height, touchId, streamer.MonitorHandle);
						}, $"touch up {touchId}");
					}
				}
			}
			bool ShouldIgnoreDesktopInput()
			{
				Grabbable val = getGrabbable?.Invoke();
				if (val == null || !val.IsGrabbed)
				{
					return DesktopBuddyMod.IsDesktopMode(((Worker)root).World);
				}
				return true;
			}
			void TargetLinuxInput()
			{
				if (DesktopBuddyPlatform.IsLinux)
				{
					WindowInput.LinuxInputSession = session.LinuxInputSessionId;
				}
			}
		}
	}
	internal sealed class RemoteStreamBuildContext
	{
		public Slot Root;

		public nint Hwnd;

		public int Width;

		public int Height;

		public float CanvasScale;

		public DesktopSession Session;

		public bool UseMediaMtx;

		public Slider<float> VolumeSlider;

		public float StreamOutputVolume;

		public Func<bool> IsPrivate;

		public Func<float> CurrentPanelCurvature;

		public uint LinuxPipeWireNodeId;
	}
	internal sealed class RemoteStreamVisual
	{
		public VideoTextureProvider VideoTexture;

		public CurvedPlaneMesh StreamPlane;

		public Canvas StreamCanvas;
	}
	internal static class TopBarControlStyles
	{
		internal static void StyleButton(Button button, UI_TextUnlitMaterial textMaterial, SpriteProvider roundedSprite, UI_UnlitMaterial elementMaterial)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			Text componentInChildren = ((Component)button).Slot.GetComponentInChildren<Text>((Predicate<Text>)null, false, false);
			if (componentInChildren != null)
			{
				((SyncField<float>)(object)componentInChildren.Size).Value = 18f;
				((SyncField<colorX>)(object)componentInChildren.Color).Value = new colorX(0.92f, 0.93f, 0.98f, 1f, (ColorProfile)1);
				((SyncRef<IAssetProvider<Material>>)(object)componentInChildren.Material).Target = (IAssetProvider<Material>)(object)textMaterial;
			}
			TextRenderer componentInChildren2 = ((Component)button).Slot.GetComponentInChildren<TextRenderer>((Predicate<TextRenderer>)null, false, false);
			if (componentInChildren2 != null)
			{
				((SyncField<colorX>)(object)componentInChildren2.Color).Value = new colorX(0.92f, 0.93f, 0.98f, 1f, (ColorProfile)1);
			}
			if (((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Count > 0)
			{
				ColorDriver obj = ((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[0];
				((SyncField<colorX>)(object)obj.NormalColor).Value = new colorX(0.12f, 0.13f, 0.17f, 0.88f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj.HighlightColor).Value = new colorX(0.24f, 0.18f, 0.42f, 0.95f, (ColorProfile)1);
				((SyncField<colorX>)(object)obj.PressColor).Value = new colorX(0.12f, 0.34f, 0.58f, 0.95f, (ColorProfile)1);
			}
			Image component = ((ContainerWorker<Component>)(object)((Component)button).Slot).GetComponent<Image>((Predicate<Image>)null, false);
			if (component != null)
			{
				((SyncField<colorX>)(object)component.Tint).Value = new colorX(0.12f, 0.13f, 0.17f, 0.88f, (ColorProfile)1);
				((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)component).Sprite).Target = (IAssetProvider<Sprite>)(object)roundedSprite;
				((SyncField<NineSliceSizing>)(object)((ImageBase)component).NineSliceSizing).Value = (NineSliceSizing)0;
				((SyncRef<IAssetProvider<Material>>)(object)((ImageBase)component).Material).Target = (IAssetProvider<Material>)(object)elementMaterial;
			}
		}
	}
	public interface ILiveStreamSource : global::System.IDisposable
	{
		bool IsRunning { get; }

		long CurrentWritePosition { get; }

		string ReadableStreamState { get; }

		bool IsSourceAlive => true;

		bool HasReadableVideoKeyframeAtOrAfter(long minimumKeyframePos);

		int ReadStream(byte[] buffer, ref long readPos, ref bool aligned, long minimumKeyframePos, out bool keyframeAligned);

		global::System.Threading.Tasks.Task WaitForDataAsync(int milliseconds);

		string GetReaderDiagnostics(long readPos, bool aligned);

		void Stop();
	}
	internal sealed class LinuxNativeStreamSource : ILiveStreamSource, global::System.IDisposable
	{
		private const int AudioSampleRate = 48000;

		private const int AudioChannels = 2;

		private readonly int _streamId;

		private readonly string _rtspUrl;

		private readonly LinuxNativeBridge _bridge = new LinuxNativeBridge();

		private ulong _nativeStreamId;

		private ulong _captureId;

		private ulong _audioCaptureId;

		private Thread _captureThread;

		private Thread _audioThread;

		private volatile bool _running;

		private int _disposed;

		private uint _nodeId;

		public bool IsRunning
		{
			get
			{
				DbLinuxStreamInfo info = GetInfo();
				if (_running && info.Running != 0)
				{
					return info.Broken == 0;
				}
				return false;
			}
		}

		public long CurrentWritePosition => GetInfo().WritePos;

		public bool IsSourceAlive
		{
			get
			{
				if (_captureId != 0L)
				{
					return _bridge.IsCaptureAlive(_captureId);
				}
				return true;
			}
		}

		public string ReadableStreamState
		{
			get
			{
				DbLinuxStreamInfo info = GetInfo();
				return $"native running={_running} native={_nativeStreamId} node={_nodeId} mode={((_rtspUrl == null) ? "mpegts" : "rtsp")} size={info.Width}x{info.Height} broken={info.Broken} keyframe={info.KeyframePos} writePos={info.WritePos} frames={info.Frames}";
			}
		}

		internal LinuxNativeStreamSource(int streamId, string rtspUrl = null)
		{
			_streamId = streamId;
			_rtspUrl = rtspUrl;
		}

		internal bool Start(uint pipeWireNodeId)
		{
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			if (_running)
			{
				return true;
			}
			if (pipeWireNodeId == 0)
			{
				Log.Msg($"[LinuxNativeStream:{_streamId}] Cannot start: missing PipeWire node id");
				return false;
			}
			_nodeId = pipeWireNodeId;
			int num = _bridge.StartStream(pipeWireNodeId, DesktopBuddyMod.RuntimeStreamFps, DesktopBuddyMod.RuntimeBitrateMbps, DesktopBuddyMod.RuntimeMaxStreamResolution, WgcCapture.RendererAdapterHintVendorId, DesktopBuddyMod.RuntimeEncoderPreference, _rtspUrl, audioEnabled: true, 48000, 2, out _nativeStreamId);
			if (num != 0 || _nativeStreamId == 0L)
			{
				string streamLastError = _bridge.GetStreamLastError();
				Log.Msg($"[LinuxNativeStream:{_streamId}] Native stream start failed status={num} node={pipeWireNodeId}{(string.IsNullOrWhiteSpace(streamLastError) ? string.Empty : (" error=" + streamLastError))}");
				return false;
			}
			num = _bridge.StartCapture(pipeWireNodeId, out _captureId);
			if (num != 0 || _captureId == 0L)
			{
				Log.Msg($"[LinuxNativeStream:{_streamId}] Native capture start failed status={num} node={pipeWireNodeId}");
				_bridge.StopStream(_nativeStreamId);
				_nativeStreamId = 0uL;
				return false;
			}
			_running = true;
			_captureThread = new Thread(new ThreadStart(CaptureLoop))
			{
				Name = $"DesktopBuddy:LinuxStream:{_streamId}",
				IsBackground = true
			};
			_captureThread.Start();
			int num2 = _bridge.StartAudioCapture(out _audioCaptureId);
			if (num2 == 0 && _audioCaptureId != 0L)
			{
				_audioThread = new Thread(new ThreadStart(AudioLoop))
				{
					Name = $"DesktopBuddy:LinuxAudio:{_streamId}",
					IsBackground = true
				};
				_audioThread.Start();
				Log.Msg($"[LinuxNativeStream:{_streamId}] Desktop audio capture started capture={_audioCaptureId}");
			}
			else
			{
				Log.Msg($"[LinuxNativeStream:{_streamId}] Desktop audio capture unavailable status={num2}; continuing video-only");
				_audioCaptureId = 0uL;
			}
			Log.Msg($"[LinuxNativeStream:{_streamId}] Native stream started node={pipeWireNodeId} native={_nativeStreamId} mode={((_rtspUrl == null) ? "mpegts" : "rtsp")}");
			return true;
		}

		private void AudioLoop()
		{
			float[] buffer = new float[8192];
			while (_running && _nativeStreamId != 0L && _audioCaptureId != 0L)
			{
				int num = _bridge.PollAudio(_audioCaptureId, buffer);
				if (num <= 0)
				{
					Thread.Sleep(4);
					continue;
				}
				int num2 = num / 2;
				if (num2 > 0)
				{
					_bridge.PushStreamAudio(_nativeStreamId, buffer, num2);
				}
			}
		}

		private void CaptureLoop()
		{
			int num = 0;
			int num2 = 0;
			while (_running && _nativeStreamId != 0L && _captureId != 0L)
			{
				DbLinuxFrame frame;
				switch (_bridge.PollFrame(_captureId, out frame))
				{
				case 1:
					Thread.Sleep(2);
					break;
				case 0:
					if (frame.Fd >= 0)
					{
						try
						{
							int num3 = _bridge.PushStreamFrame(_nativeStreamId, frame);
							if (num3 == 0)
							{
								num++;
								if (num == 1 || num % 120 == 0)
								{
									Log.Msg($"[LinuxNativeStream:{_streamId}] Encoded frames={num} {frame.Width}x{frame.Height}");
								}
							}
							else if (++num2 == 1 || num2 % 60 == 0)
							{
								Log.Msg($"[LinuxNativeStream:{_streamId}] Frame push failed status={num3} failures={num2}");
							}
						}
						finally
						{
							_bridge.CloseFrame(frame);
						}
						break;
					}
					goto default;
				default:
					Thread.Sleep(4);
					break;
				}
			}
		}

		public bool HasReadableVideoKeyframeAtOrAfter(long minimumKeyframePos)
		{
			DbLinuxStreamInfo info = GetInfo();
			if (_rtspUrl != null)
			{
				if (_running && info.Running != 0)
				{
					return info.Broken == 0;
				}
				return false;
			}
			if (_running && info.Running != 0 && info.Broken == 0 && info.KeyframePos >= minimumKeyframePos && info.KeyframePos >= 0)
			{
				return info.KeyframePos < info.WritePos;
			}
			return false;
		}

		public int ReadStream(byte[] buffer, ref long readPos, ref bool aligned, long minimumKeyframePos, out bool keyframeAligned)
		{
			keyframeAligned = aligned;
			if (_rtspUrl != null || !_running)
			{
				return 0;
			}
			return _bridge.ReadStream(_nativeStreamId, buffer, ref readPos, ref aligned, minimumKeyframePos, out keyframeAligned);
		}

		public global::System.Threading.Tasks.Task WaitForDataAsync(int milliseconds)
		{
			return global::System.Threading.Tasks.Task.Delay(milliseconds);
		}

		public string GetReaderDiagnostics(long readPos, bool aligned)
		{
			DbLinuxStreamInfo info = GetInfo();
			return $"readPos={readPos} writePos={info.WritePos} backlog={info.WritePos - readPos} aligned={aligned} latestKeyframe={info.KeyframePos} frames={info.Frames}";
		}

		public void Stop()
		{
			_running = false;
			try
			{
				Thread audioThread = _audioThread;
				if (audioThread != null)
				{
					audioThread.Join(1000);
				}
			}
			catch
			{
			}
			_audioThread = null;
			try
			{
				_bridge.StopAudioCapture(_audioCaptureId);
			}
			catch
			{
			}
			_audioCaptureId = 0uL;
			try
			{
				Thread captureThread = _captureThread;
				if (captureThread != null)
				{
					captureThread.Join(1000);
				}
			}
			catch
			{
			}
			_captureThread = null;
			try
			{
				_bridge.StopCapture(_captureId);
			}
			catch
			{
			}
			_captureId = 0uL;
			try
			{
				_bridge.StopStream(_nativeStreamId);
			}
			catch
			{
			}
			_nativeStreamId = 0uL;
		}

		public void Dispose()
		{
			if (Interlocked.Exchange(ref _disposed, 1) == 0)
			{
				Stop();
				_bridge.Dispose();
			}
		}

		private DbLinuxStreamInfo GetInfo()
		{
			try
			{
				return _bridge.GetStreamInfo(_nativeStreamId);
			}
			catch
			{
				return default(DbLinuxStreamInfo);
			}
		}
	}
	internal sealed class SharedStream
	{
		public int StreamId;

		public FfmpegEncoder Encoder;

		public ILiveStreamSource Source;

		public bool UsesMediaMtx;

		public AudioCapture Audio;

		public Action StartAudio;

		public Uri StreamUrl;

		public int RefCount;

		public DesktopSession DriverSession;
	}
	internal static class SharedStreamRegistry
	{
		internal static readonly Dictionary<nint, SharedStream> Streams = new Dictionary<nint, SharedStream>();

		private static int _nextStreamId;

		internal static int NextStreamId()
		{
			return Interlocked.Increment(ref _nextStreamId);
		}
	}
	public static class ContextMenuPatch
	{
		private enum MenuOptions
		{
			Default,
			Locomotion,
			Grabbing,
			LaserGrab,
			HandGrab
		}

		private delegate bool MonitorEnumProc(nint hMonitor, nint hdcMonitor, ref RECT lprcMonitor, nint dwData);

		private struct RECT
		{
			public int Left;

			public int Top;

			public int Right;

			public int Bottom;
		}

		[StructLayout((LayoutKind)0, CharSet = (CharSet)3)]
		private struct MONITORINFOEX
		{
			public int cbSize;

			public RECT rcMonitor;

			public RECT rcWork;

			public uint dwFlags;

			[MarshalAs((UnmanagedType)23, SizeConst = 32)]
			public string szDevice;
		}

		private record MonitorInfo(nint Handle, string Name, int Width, int Height)
		{
			[CompilerGenerated]
			protected virtual global::System.Type EqualityContract
			{
				[CompilerGenerated]
				get
				{
					return typeof(MonitorInfo);
				}
			}

			[CompilerGenerated]
			public override string ToString()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				StringBuilder val = new StringBuilder();
				val.Append("MonitorInfo");
				val.Append(" { ");
				if (PrintMembers(val))
				{
					val.Append(' ');
				}
				val.Append('}');
				return ((object)val).ToString();
			}

			[CompilerGenerated]
			protected virtual bool PrintMembers(StringBuilder builder)
			{
				RuntimeHelpers.EnsureSufficientExecutionStack();
				builder.Append("Handle = ");
				builder.Append(((object)Handle/*cast due to .constrained prefix*/).ToString());
				builder.Append(", Name = ");
				builder.Append((object)Name);
				builder.Append(", Width = ");
				builder.Append(((object)Width/*cast due to .constrained prefix*/).ToString());
				builder.Append(", Height = ");
				builder.Append(((object)Height/*cast due to .constrained prefix*/).ToString());
				return true;
			}

			[CompilerGenerated]
			public virtual bool Equals(MonitorInfo? other)
			{
				if ((object)this != other)
				{
					if ((object)other != null && EqualityContract == other.EqualityContract && EqualityComparer<nint>.Default.Equals(Handle, other.Handle) && EqualityComparer<string>.Default.Equals(Name, other.Name) && EqualityComparer<int>.Default.Equals(Width, other.Width))
					{
						return EqualityComparer<int>.Default.Equals(Height, other.Height);
					}
					return false;
				}
				return true;
			}
		}

		private sealed class LinuxSharedSource
		{
			public string Label;

			public string RestoreToken;

			public bool IsMonitor;
		}

		[HarmonyPatch(typeof(InteractionHandler), "OpenContextMenu")]
		private class ContextMenuOpenMenuPatch
		{
			public static void Postfix(InteractionHandler __instance, MenuOptions options)
			{
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Expected O, but got Unknown
				try
				{
					if (__instance == null || !__instance.IsOwnedByLocalUser)
					{
						return;
					}
					ContextMenu ctx = SyncRef<ContextMenu>.op_Implicit(__instance.ContextMenu);
					if (ctx == null || options != MenuOptions.Default)
					{
						return;
					}
					DesktopBuddyConfig config = DesktopBuddyMod.Config;
					if (config != null && !config.GetValue(DesktopBuddyMod.ShowContextMenuItem))
					{
						return;
					}
					DesktopBuddyMod.Msg("[ContextMenu] Postfix fired, adding Desktop item");
					LocaleString val = LocaleString.op_Implicit("Desktop");
					colorX? val2 = colorX.Cyan;
					StaticTexture2D desktopIconTexture = GetDesktopIconTexture(((Worker)__instance).World.Engine, ((Component)__instance).Slot);
					ContextMenuItem val3 = ((desktopIconTexture == null) ? ctx.AddItem(ref val, (Uri)null, ref val2) : ctx.AddItem(ref val, (IAssetProvider<ITexture2D>)(object)desktopIconTexture, ref val2));
					val3.Button.LocalPressed += (ButtonEventHandler)delegate
					{
						try
						{
							DesktopBuddyMod.Msg("[ContextMenu] Desktop item LocalPressed entered");
							if (DesktopBuddyMod.ShowSetupNoticeFromDesktopClick(((Worker)__instance).World))
							{
								DesktopBuddyMod.Msg("[ContextMenu] Setup notice shown from Desktop item");
								ctx.Close();
							}
							else if (DesktopBuddyPlatform.IsLinux)
							{
								DesktopBuddyMod.Msg("[ContextMenu] Linux Desktop item pressed, showing source list");
								ShowLinuxPickerPage(ctx);
							}
							else
							{
								DesktopBuddyMod.Msg("[ContextMenu] Desktop item pressed, showing picker");
								ShowPickerPage(ctx, 0);
							}
						}
						catch (global::System.Exception ex2)
						{
							DesktopBuddyMod.Msg($"[ContextMenu] Desktop item pressed error: {ex2}");
						}
					};
				}
				catch (global::System.Exception ex)
				{
					DesktopBuddyMod.Msg($"[ContextMenu] Postfix error: {ex}");
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_0
		{
			[StructLayout((LayoutKind)3)]
			private struct <<GetDesktopIconTexture>b__0>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass19_0 <>4__this;

				private <>c__DisplayClass19_1 <>8__1;

				private ConfiguredTaskAwaiter<Uri> <>u__1;

				private void MoveNext()
				{
					//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_0068: 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_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Unknown result type (might be due to invalid IL or missing references)
					//IL_008b: Unknown result type (might be due to invalid IL or missing references)
					//IL_008d: Unknown result type (might be due to invalid IL or missing references)
					//IL_014b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0155: Expected O, but got Unknown
					//IL_0150: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass19_0 <>c__DisplayClass19_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<Uri> val2;
							if (num != 0)
							{
								<>8__1 = new <>c__DisplayClass19_1();
								<>8__1.CS$<>8__locals1 = <>c__DisplayClass19_;
								Bitmap2D val = Bitmap2D.Load(<>c__DisplayClass19_.iconPath, (bool?)false, (AlphaHandling)0, 2147483647, 1f);
								val2 = <>c__DisplayClass19_.engine.LocalDB.SaveAssetAsync(val, "webp", 2147483647, true).ConfigureAwait(false).GetAwaiter();
								if (!val2.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val2;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<Uri>, <<GetDesktopIconTexture>b__0>d>(ref val2, ref this);
									return;
								}
							}
							else
							{
								val2 = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<Uri>);
								num = (<>1__state = -1);
							}
							Uri result = val2.GetResult();
							<>8__1.uri = result;
							if (<>8__1.uri != (Uri)null)
							{
								_desktopIconUri = <>8__1.uri;
								_desktopIconLoaded = true;
								DesktopBuddyMod.Msg($"[Icon] Desktop icon saved: {<>8__1.uri}");
								((Worker)<>c__DisplayClass19_.capturedTex).World.RunInUpdates(0, (Action)delegate
								{
									if (!((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.capturedTex).IsDestroyed)
									{
										((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)<>8__1.CS$<>8__locals1.capturedTex).URL).Value = <>8__1.uri;
									}
								});
							}
							<>8__1 = null;
						}
						catch (global::System.Exception ex)
						{
							DesktopBuddyMod.Msg("[Icon] Desktop icon save error: " + ex.Message);
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public Engine engine;

			public string iconPath;

			public StaticTexture2D capturedTex;

			[AsyncStateMachine(typeof(<<GetDesktopIconTexture>b__0>d))]
			internal global::System.Threading.Tasks.Task? <GetDesktopIconTexture>b__0()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<GetDesktopIconTexture>b__0>d <<GetDesktopIconTexture>b__0>d = default(<<GetDesktopIconTexture>b__0>d);
				<<GetDesktopIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<GetDesktopIconTexture>b__0>d.<>4__this = this;
				<<GetDesktopIconTexture>b__0>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<GetDesktopIconTexture>b__0>d.<>t__builder)).Start<<<GetDesktopIconTexture>b__0>d>(ref <<GetDesktopIconTexture>b__0>d);
				return ((AsyncTaskMethodBuilder)(ref <<GetDesktopIconTexture>b__0>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass19_1
		{
			public Uri uri;

			public <>c__DisplayClass19_0 CS$<>8__locals1;

			internal void <GetDesktopIconTexture>b__1()
			{
				if (!((ComponentBase<Component>)(object)CS$<>8__locals1.capturedTex).IsDestroyed)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)CS$<>8__locals1.capturedTex).URL).Value = uri;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass20_0
		{
			[StructLayout((LayoutKind)3)]
			private struct <<GetIconTexture>b__0>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass20_0 <>4__this;

				private ConfiguredTaskAwaiter<Uri> <>u__1;

				private void MoveNext()
				{
					//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Unknown result type (might be due to invalid IL or missing references)
					//IL_0049: Expected O, but got Unknown
					//IL_0067: Unknown result type (might be due to invalid IL or missing references)
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0070: 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_008a: Unknown result type (might be due to invalid IL or missing references)
					//IL_008c: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass20_0 <>c__DisplayClass20_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<Uri> val;
							if (num == 0)
							{
								val = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<Uri>);
								num = (<>1__state = -1);
								goto IL_00c1;
							}
							int width;
							int height;
							byte[] iconRGBA = WindowIconExtractor.GetIconRGBA(<>c__DisplayClass20_.capturedHwnd, out width, out height);
							if (iconRGBA != null && width > 0 && height > 0)
							{
								Bitmap2D val2 = new Bitmap2D(iconRGBA, width, height, (TextureFormat)18, false, (ColorProfile)1, false, (string)null);
								val = <>c__DisplayClass20_.engine.LocalDB.SaveAssetAsync(val2, "webp", 2147483647, true).ConfigureAwait(false).GetAwaiter();
								if (!val.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<Uri>, <<GetIconTexture>b__0>d>(ref val, ref this);
									return;
								}
								goto IL_00c1;
							}
							goto end_IL_0011;
							IL_00c1:
							Uri result = val.GetResult();
							if (result != (Uri)null)
							{
								_iconCache[<>c__DisplayClass20_.capturedHwnd] = result;
							}
							end_IL_0011:;
						}
						catch (global::System.Exception ex)
						{
							DesktopBuddyMod.Msg("[Icon] Save error: " + ex.Message);
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public Engine engine;

			public nint capturedHwnd;

			[AsyncStateMachine(typeof(<<GetIconTexture>b__0>d))]
			internal global::System.Threading.Tasks.Task? <GetIconTexture>b__0()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<GetIconTexture>b__0>d <<GetIconTexture>b__0>d = default(<<GetIconTexture>b__0>d);
				<<GetIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<GetIconTexture>b__0>d.<>4__this = this;
				<<GetIconTexture>b__0>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<GetIconTexture>b__0>d.<>t__builder)).Start<<<GetIconTexture>b__0>d>(ref <<GetIconTexture>b__0>d);
				return ((AsyncTaskMethodBuilder)(ref <<GetIconTexture>b__0>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_0
		{
			[StructLayout((LayoutKind)3)]
			private struct <<GetFileIconTexture>b__0>d : IAsyncStateMachine
			{
				public int <>1__state;

				public AsyncTaskMethodBuilder <>t__builder;

				public <>c__DisplayClass31_0 <>4__this;

				private <>c__DisplayClass31_1 <>8__1;

				private ConfiguredTaskAwaiter<Uri> <>u__1;

				private void MoveNext()
				{
					//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
					//IL_0068: 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_0071: Unknown result type (might be due to invalid IL or missing references)
					//IL_0076: Unknown result type (might be due to invalid IL or missing references)
					//IL_008b: Unknown result type (might be due to invalid IL or missing references)
					//IL_008d: Unknown result type (might be due to invalid IL or missing references)
					//IL_011c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0126: Expected O, but got Unknown
					//IL_0121: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					<>c__DisplayClass31_0 <>c__DisplayClass31_ = <>4__this;
					try
					{
						try
						{
							ConfiguredTaskAwaiter<Uri> val2;
							if (num != 0)
							{
								<>8__1 = new <>c__DisplayClass31_1();
								<>8__1.CS$<>8__locals1 = <>c__DisplayClass31_;
								Bitmap2D val = Bitmap2D.Load(<>c__DisplayClass31_.path, (bool?)false, (AlphaHandling)0, 2147483647, 1f);
								val2 = <>c__DisplayClass31_.engine.LocalDB.SaveAssetAsync(val, "webp", 2147483647, true).ConfigureAwait(false).GetAwaiter();
								if (!val2.IsCompleted)
								{
									num = (<>1__state = 0);
									<>u__1 = val2;
									((AsyncTaskMethodBuilder)(ref <>t__builder)).AwaitUnsafeOnCompleted<ConfiguredTaskAwaiter<Uri>, <<GetFileIconTexture>b__0>d>(ref val2, ref this);
									return;
								}
							}
							else
							{
								val2 = <>u__1;
								<>u__1 = default(ConfiguredTaskAwaiter<Uri>);
								num = (<>1__state = -1);
							}
							Uri result = val2.GetResult();
							<>8__1.uri = result;
							if (<>8__1.uri != (Uri)null)
							{
								_fileIconUris[<>c__DisplayClass31_.path] = <>8__1.uri;
								((Worker)<>c__DisplayClass31_.capturedTex).World.RunInUpdates(0, (Action)delegate
								{
									if (!((ComponentBase<Component>)(object)<>8__1.CS$<>8__locals1.capturedTex).IsDestroyed)
									{
										((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)<>8__1.CS$<>8__locals1.capturedTex).URL).Value = <>8__1.uri;
									}
								});
							}
							<>8__1 = null;
						}
						catch (global::System.Exception ex)
						{
							DesktopBuddyMod.Msg("[Icon] App icon load error: " + ex.Message);
						}
					}
					catch (global::System.Exception exception)
					{
						<>1__state = -2;
						((AsyncTaskMethodBuilder)(ref <>t__builder)).SetException(exception);
						return;
					}
					<>1__state = -2;
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetResult();
				}

				[DebuggerHidden]
				private void SetStateMachine(IAsyncStateMachine stateMachine)
				{
					((AsyncTaskMethodBuilder)(ref <>t__builder)).SetStateMachine(stateMachine);
				}
			}

			public string path;

			public Engine engine;

			public StaticTexture2D capturedTex;

			[AsyncStateMachine(typeof(<<GetFileIconTexture>b__0>d))]
			internal global::System.Threading.Tasks.Task? <GetFileIconTexture>b__0()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				<<GetFileIconTexture>b__0>d <<GetFileIconTexture>b__0>d = default(<<GetFileIconTexture>b__0>d);
				<<GetFileIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
				<<GetFileIconTexture>b__0>d.<>4__this = this;
				<<GetFileIconTexture>b__0>d.<>1__state = -1;
				((AsyncTaskMethodBuilder)(ref <<GetFileIconTexture>b__0>d.<>t__builder)).Start<<<GetFileIconTexture>b__0>d>(ref <<GetFileIconTexture>b__0>d);
				return ((AsyncTaskMethodBuilder)(ref <<GetFileIconTexture>b__0>d.<>t__builder)).Task;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass31_1
		{
			public Uri uri;

			public <>c__DisplayClass31_0 CS$<>8__locals1;

			internal void <GetFileIconTexture>b__1()
			{
				if (!((ComponentBase<Component>)(object)CS$<>8__locals1.capturedTex).IsDestroyed)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)CS$<>8__locals1.capturedTex).URL).Value = uri;
				}
			}
		}

		private const int PAGE_SIZE = 8;

		private const string DesktopIconFileName = "icon_transparent.png";

		private const string PlusIconFileName = "plus.png";

		private static readonly ConcurrentDictionary<nint, Uri> _iconCache = new ConcurrentDictionary<nint, Uri>();

		private static readonly ConcurrentDictionary<nint, byte> _iconCacheRequests = new ConcurrentDictionary<nint, byte>();

		private static Uri _desktopIconUri;

		private static bool _desktopIconLoaded;

		private static readonly string[] IgnoredSubstrings = new string[3] { "vrmonitor", "SteamVR Status", "rainmeter" };

		private static readonly FieldInfo _itemsRootField = typeof(ContextMenu).GetField("_itemsRoot", (BindingFlags)36);

		private static readonly object _linuxSourcesLock = new object();

		private static readonly List<LinuxSharedSource> _linuxSources = new List<LinuxSharedSource>();

		private static bool _linuxSourcesLoaded;

		private static readonly ConcurrentDictionary<string, Uri> _fileIconUris = new ConcurrentDictionary<string, Uri>();

		private static bool ShouldIgnore(string title)
		{
			if (WindowEnumerator.IsResoniteWindow(title))
			{
				return true;
			}
			string[] ignoredSubstrings = IgnoredSubstrings;
			foreach (string text in ignoredSubstrings)
			{
				if (title.Contains(text, (StringComparison)5))
				{
					return true;
				}
			}
			return false;
		}

		private static void ClearMenu(ContextMenu menu)
		{
			FieldInfo itemsRootField = _itemsRootField;
			SyncRef<Slot> obj = ((itemsRootField != null) ? itemsRootField.GetValue((object)menu) : null) as SyncRef<Slot>;
			if (obj != null)
			{
				Slot target = obj.Target;
				if (target != null)
				{
					target.DestroyChildren(false, true, false, (Predicate<Slot>)null);
				}
			}
		}

		[DllImport("user32.dll")]
		private static extern bool EnumDisplayMonitors(nint hdc, nint lprcClip, MonitorEnumProc lpfnEnum, nint dwData);

		[DllImport("user32.dll", CharSet = (CharSet)3)]
		private static extern bool GetMonitorInfo(nint hMonitor, ref MONITORINFOEX lpmi);

		private static List<MonitorInfo> GetMonitors()
		{
			List<MonitorInfo> monitors = new List<MonitorInfo>();
			EnumDisplayMonitors(global::System.IntPtr.Zero, global::System.IntPtr.Zero, delegate(nint hMon, nint hdc, ref RECT rc, nint data)
			{
				MONITORINFOEX lpmi = new MONITORINFOEX
				{
					cbSize = Marshal.SizeOf<MONITORINFOEX>()
				};
				GetMonitorInfo(hMon, ref lpmi);
				int width = lpmi.rcMonitor.Right - lpmi.rcMonitor.Left;
				int height = lpmi.rcMonitor.Bottom - lpmi.rcMonitor.Top;
				monitors.Add(new MonitorInfo(hMon, lpmi.szDevice, width, height));
				return true;
			}, global::System.IntPtr.Zero);
			return monitors;
		}

		internal static StaticTexture2D GetDesktopIconTexture(Engine engine, Slot slot)
		{
			<>c__DisplayClass19_0 CS$<>8__locals6 = new <>c__DisplayClass19_0();
			CS$<>8__locals6.engine = engine;
			try
			{
				StaticTexture2D val = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)slot).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
				if (_desktopIconLoaded && _desktopIconUri != (Uri)null)
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)val).URL).Value = _desktopIconUri;
					DesktopBuddyMod.Msg("[Icon] Using cached desktop icon");
					return val;
				}
				CS$<>8__locals6.iconPath = Path.Combine(Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? string.Empty, "icon_transparent.png");
				if (!File.Exists(CS$<>8__locals6.iconPath))
				{
					DesktopBuddyMod.Msg("[Icon] Desktop icon file not found: " + CS$<>8__locals6.iconPath);
					return val;
				}
				CS$<>8__locals6.capturedTex = val;
				global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass19_0.<<GetDesktopIconTexture>b__0>d))] () =>
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass19_0.<<GetDesktopIconTexture>b__0>d <<GetDesktopIconTexture>b__0>d = default(<>c__DisplayClass19_0.<<GetDesktopIconTexture>b__0>d);
					<<GetDesktopIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
					<<GetDesktopIconTexture>b__0>d.<>4__this = CS$<>8__locals6;
					<<GetDesktopIconTexture>b__0>d.<>1__state = -1;
					((AsyncTaskMethodBuilder)(ref <<GetDesktopIconTexture>b__0>d.<>t__builder)).Start<<>c__DisplayClass19_0.<<GetDesktopIconTexture>b__0>d>(ref <<GetDesktopIconTexture>b__0>d);
					return ((AsyncTaskMethodBuilder)(ref <<GetDesktopIconTexture>b__0>d.<>t__builder)).Task;
				}));
				return val;
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg("[Icon] Desktop icon error: " + ex.Message);
				return null;
			}
		}

		internal static StaticTexture2D GetIconTexture(nint hwnd, Engine engine, Slot slot)
		{
			<>c__DisplayClass20_0 CS$<>8__locals4 = new <>c__DisplayClass20_0();
			CS$<>8__locals4.engine = engine;
			try
			{
				Uri value = default(Uri);
				if (_iconCache.TryGetValue(hwnd, ref value))
				{
					StaticTexture2D obj = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)slot).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)obj).URL).Value = value;
					return obj;
				}
				CS$<>8__locals4.capturedHwnd = hwnd;
				if (!_iconCacheRequests.TryAdd(CS$<>8__locals4.capturedHwnd, (byte)0))
				{
					return null;
				}
				global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass20_0.<<GetIconTexture>b__0>d))] () =>
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass20_0.<<GetIconTexture>b__0>d <<GetIconTexture>b__0>d = default(<>c__DisplayClass20_0.<<GetIconTexture>b__0>d);
					<<GetIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
					<<GetIconTexture>b__0>d.<>4__this = CS$<>8__locals4;
					<<GetIconTexture>b__0>d.<>1__state = -1;
					((AsyncTaskMethodBuilder)(ref <<GetIconTexture>b__0>d.<>t__builder)).Start<<>c__DisplayClass20_0.<<GetIconTexture>b__0>d>(ref <<GetIconTexture>b__0>d);
					return ((AsyncTaskMethodBuilder)(ref <<GetIconTexture>b__0>d.<>t__builder)).Task;
				}));
				return null;
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg($"[Icon] Error for hwnd={hwnd}: {ex.Message}");
				return null;
			}
		}

		private static void ShowPickerPage(ContextMenu menu, int page)
		{
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_039f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Expected O, but got Unknown
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0561: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bb: Expected O, but got Unknown
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0431: Expected O, but got Unknown
			if (DesktopBuddyPlatform.IsLinux)
			{
				ShowLinuxPickerPage(menu);
				return;
			}
			DesktopBuddyMod.Msg($"[ContextMenu] ShowPickerPage page={page}");
			ClearMenu(menu);
			World world = ((Worker)menu).World;
			Engine engine = world.Engine;
			List<ValueTuple<string, colorX, Action, nint>> val = new List<ValueTuple<string, colorX, Action, nint>>();
			List<MonitorInfo> monitors = GetMonitors();
			DesktopBuddyMod.Msg($"[ContextMenu] Found {monitors.Count} monitors");
			for (int i = 0; i < monitors.Count; i++)
			{
				MonitorInfo mon = monitors[i];
				int idx = i;
				val.Add(new ValueTuple<string, colorX, Action, nint>($"Monitor {idx + 1} ({mon.Width}x{mon.Height})", new colorX(0.1f, 0.25f, 0.4f, 1f, (ColorProfile)1), (Action)delegate
				{
					menu.Close();
					DesktopBuddyMod.SpawnStreaming(world, global::System.IntPtr.Zero, $"Monitor {idx + 1}", mon.Handle, idx, DesktopBuddyMod.Config?.GetValue(DesktopBuddyMod.NewWindowsStartPrivate) ?? true);
				}, (nint)global::System.IntPtr.Zero));
			}
			List<WindowEnumerator.WindowInfo> openWindows = WindowEnumerator.GetOpenWindows();
			DesktopBuddyMod.Msg($"[ContextMenu] Found {openWindows.Count} windows");
			Enumerator<WindowEnumerator.WindowInfo> enumerator = openWindows.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					WindowEnumerator.WindowInfo current = enumerator.Current;
					if (!ShouldIgnore(current.Title))
					{
						nint handle = current.Handle;
						string title = current.Title;
						string text = ((title.Length > 30) ? (title.Substring(0, 27) + "...") : title);
						val.Add(new ValueTuple<string, colorX, Action, nint>(text, new colorX(0.15f, 0.15f, 0.25f, 1f, (ColorProfile)1), (Action)delegate
						{
							menu.Close();
							DesktopBuddyMod.SpawnStreaming(world, handle, title, 0, -1, DesktopBuddyMod.Config?.GetValue(DesktopBuddyMod.NewWindowsStartPrivate) ?? true);
						}, handle));
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			int num = (val.Count + 8 - 1) / 8;
			int num2 = page * 8;
			int num3 = Math.Min(num2 + 8, val.Count);
			DesktopBuddyMod.Msg($"[ContextMenu] Showing entries {num2}-{num3} of {val.Count} (page {page + 1}/{num})");
			for (int num4 = num2; num4 < num3; num4++)
			{
				ValueTuple<string, colorX, Action, nint> val2 = val[num4];
				LocaleString val3 = LocaleString.op_Implicit(val2.Item1);
				colorX? val4 = val2.Item2;
				Action act = val2.Item3;
				StaticTexture2D val5 = null;
				if (val2.Item4 != (nint)global::System.IntPtr.Zero)
				{
					val5 = GetIconTexture(val2.Item4, engine, ((Component)menu).Slot);
				}
				ContextMenuItem val6 = ((val5 == null) ? menu.AddItem(ref val3, (Uri)null, ref val4) : menu.AddItem(ref val3, (IAssetProvider<ITexture2D>)(object)val5, ref val4));
				val6.Button.LocalPressed += (ButtonEventHandler)delegate
				{
					act.Invoke();
				};
			}
			if (page > 0)
			{
				LocaleString val7 = LocaleString.op_Implicit($"< Prev (Page {page}/{num})");
				colorX? val8 = new colorX(0.3f, 0.3f, 0.1f, 1f, (ColorProfile)1);
				ContextMenuItem obj = menu.AddItem(ref val7, (Uri)null, ref val8);
				int prev = page - 1;
				obj.Button.LocalPressed += (ButtonEventHandler)delegate
				{
					ShowPickerPage(menu, prev);
				};
			}
			if (page < num - 1)
			{
				LocaleString val9 = LocaleString.op_Implicit($"Next > (Page {page + 2}/{num})");
				colorX? val10 = new colorX(0.3f, 0.3f, 0.1f, 1f, (ColorProfile)1);
				ContextMenuItem obj2 = menu.AddItem(ref val9, (Uri)null, ref val10);
				int next = page + 1;
				obj2.Button.LocalPressed += (ButtonEventHandler)delegate
				{
					ShowPickerPage(menu, next);
				};
			}
		}

		private static string B64(string s)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(s ?? string.Empty));
		}

		private static string UnB64(string s)
		{
			try
			{
				return Encoding.UTF8.GetString(Convert.FromBase64String(s));
			}
			catch
			{
				return string.Empty;
			}
		}

		private static void LoadLinuxSourcesOnce()
		{
			if (_linuxSourcesLoaded)
			{
				return;
			}
			_linuxSourcesLoaded = true;
			try
			{
				string text = DesktopBuddyMod.Config?.GetValue(DesktopBuddyMod.LinuxSharedSources);
				if (string.IsNullOrWhiteSpace(text))
				{
					return;
				}
				lock (_linuxSourcesLock)
				{
					_linuxSources.Clear();
					string[] array = text.Split('\n', (StringSplitOptions)0);
					foreach (string text2 in array)
					{
						if (string.IsNullOrWhiteSpace(text2))
						{
							continue;
						}
						string[] array2 = text2.Split('|', (StringSplitOptions)0);
						if (array2.Length >= 3)
						{
							string text3 = UnB64(array2[2]);
							if (!string.IsNullOrEmpty(text3))
							{
								_linuxSources.Add(new LinuxSharedSource
								{
									IsMonitor = (array2[0] == "1"),
									Label = UnB64(array2[1]),
									RestoreToken = text3
								});
							}
						}
					}
				}
				DesktopBuddyMod.Msg($"[ContextMenu] Loaded {_linuxSources.Count} saved Linux source(s)");
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg("[ContextMenu] Load sources error: " + ex.Message);
			}
		}

		private static void SaveLinuxSources()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				StringBuilder val = new StringBuilder();
				lock (_linuxSourcesLock)
				{
					Enumerator<LinuxSharedSource> enumerator = _linuxSources.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							LinuxSharedSource current = enumerator.Current;
							if (val.Length > 0)
							{
								val.Append('\n');
							}
							val.Append(current.IsMonitor ? '1' : '0').Append('|').Append(B64(current.Label))
								.Append('|')
								.Append(B64(current.RestoreToken));
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
				}
				DesktopBuddyMod.Config?.Set(DesktopBuddyMod.LinuxSharedSources, ((object)val).ToString());
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg("[ContextMenu] Save sources error: " + ex.Message);
			}
		}

		private static StaticTexture2D GetFileIconTexture(Engine engine, Slot slot, string path)
		{
			<>c__DisplayClass31_0 CS$<>8__locals7 = new <>c__DisplayClass31_0();
			CS$<>8__locals7.path = path;
			CS$<>8__locals7.engine = engine;
			try
			{
				if (string.IsNullOrEmpty(CS$<>8__locals7.path) || !File.Exists(CS$<>8__locals7.path))
				{
					return null;
				}
				StaticTexture2D val = TextureProviderSettings.ClampWrap<StaticTexture2D>(((ContainerWorker<Component>)(object)slot).AttachComponent<StaticTexture2D>(true, (Action<StaticTexture2D>)null));
				Uri value = default(Uri);
				if (_fileIconUris.TryGetValue(CS$<>8__locals7.path, ref value))
				{
					((SyncField<Uri>)(object)((StaticAssetProvider<Texture2D, BitmapMetadata, Texture2DVariantDescriptor>)(object)val).URL).Value = value;
					return val;
				}
				CS$<>8__locals7.capturedTex = val;
				global::System.Threading.Tasks.Task.Run((Func<global::System.Threading.Tasks.Task>)([AsyncStateMachine(typeof(<>c__DisplayClass31_0.<<GetFileIconTexture>b__0>d))] () =>
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass31_0.<<GetFileIconTexture>b__0>d <<GetFileIconTexture>b__0>d = default(<>c__DisplayClass31_0.<<GetFileIconTexture>b__0>d);
					<<GetFileIconTexture>b__0>d.<>t__builder = AsyncTaskMethodBuilder.Create();
					<<GetFileIconTexture>b__0>d.<>4__this = CS$<>8__locals7;
					<<GetFileIconTexture>b__0>d.<>1__state = -1;
					((AsyncTaskMethodBuilder)(ref <<GetFileIconTexture>b__0>d.<>t__builder)).Start<<>c__DisplayClass31_0.<<GetFileIconTexture>b__0>d>(ref <<GetFileIconTexture>b__0>d);
					return ((AsyncTaskMethodBuilder)(ref <<GetFileIconTexture>b__0>d.<>t__builder)).Task;
				}));
				return val;
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg("[Icon] App icon error: " + ex.Message);
				return null;
			}
		}

		private static void ShowLinuxPickerPage(ContextMenu menu)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			DesktopBuddyMod.Msg("[ContextMenu] Showing Linux source list");
			LoadLinuxSourcesOnce();
			ClearMenu(menu);
			Engine engine = ((Worker)menu).World.Engine;
			LocaleString val = LocaleString.op_Implicit("Share a desktop");
			colorX? val2 = new colorX(0.1f, 0.35f, 0.35f, 1f, (ColorProfile)1);
			string path = Path.Combine(Path.GetDirectoryName(typeof(DesktopBuddyMod).Assembly.Location) ?? string.Empty, "plus.png");
			StaticTexture2D fileIconTexture = GetFileIconTexture(engine, ((Component)menu).Slot, path);
			((fileIconTexture != null) ? menu.AddItem(ref val, (IAssetProvider<ITexture2D>)(object)fileIconTexture, ref val2) : menu.AddItem(ref val, (Uri)null, ref val2)).Button.LocalPressed += (ButtonEventHandler)delegate
			{
				menu.Close();
				OpenLinuxPortalPickerThenSpawn(((Worker)menu).World, null);
			};
			List<LinuxSharedSource> val3;
			lock (_linuxSourcesLock)
			{
				val3 = new List<LinuxSharedSource>((global::System.Collections.Generic.IEnumerable<LinuxSharedSource>)_linuxSources);
			}
			Enumerator<LinuxSharedSource> enumerator = val3.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					LinuxSharedSource current = enumerator.Current;
					LocaleString val4 = LocaleString.op_Implicit(current.Label);
					colorX? val5 = new colorX(0.1f, 0.25f, 0.4f, 1f, (ColorProfile)1);
					StaticTexture2D desktopIconTexture = GetDesktopIconTexture(engine, ((Component)menu).Slot);
					ContextMenuItem obj = ((desktopIconTexture != null) ? menu.AddItem(ref val4, (IAssetProvider<ITexture2D>)(object)desktopIconTexture, ref val5) : menu.AddItem(ref val4, (Uri)null, ref val5));
					LinuxSharedSource captured = current;
					obj.Button.LocalPressed += (ButtonEventHandler)delegate
					{
						menu.Close();
						OpenLinuxPortalPickerThenSpawn(((Worker)menu).World, captured);
					};
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}

		private static void OpenLinuxPortalPickerThenSpawn(World world, LinuxSharedSource reshare)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			string tokenIn = reshare?.RestoreToken;
			DesktopBuddyMod.Msg((tokenIn == null) ? "[ContextMenu] Opening Linux portal picker" : "[ContextMenu] Re-sharing saved Linux source (no dialog)");
			global::System.Threading.Tasks.Task.Run((Action)checked(delegate
			{
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Expected O, but got Unknown
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					using LinuxNativeBridge linuxNativeBridge = new LinuxNativeBridge();
					DbLinuxSelection selection;
					string newRestoreToken;
					bool isMonitor;
					ulong num = linuxNativeBridge.SessionStart(tokenIn, out selection, out newRestoreToken, out isMonitor);
					if (num == 0L || selection.NodeId == 0)
					{
						string inputLastError = linuxNativeBridge.GetInputLastError();
						DesktopBuddyMod.Msg($"[ContextMenu] Linux portal session failed inputSession={num} node={selection.NodeId} error={inputLastError ?? "(none)"}");
					}
					else
					{
						int num2 = ((selection.Width != 0) ? ((int)selection.Width) : 1280);
						int num3 = ((selection.Height != 0) ? ((int)selection.Height) : 720);
						DesktopBuddyMod.Msg($"[ContextMenu] Linux combined session={num} node={selection.NodeId} (capture + input share one portal session)");
						string title = RememberLinuxSource(reshare, newRestoreToken, isMonitor, num2, num3);
						LinuxPortalSelectionStore.Set(new LinuxPortalSelection(selection.NodeId, num2, num3, num));
						DesktopBuddyMod.Msg($"[ContextMenu] Linux portal selected node={selection.NodeId} size={num2}x{num3} monitor={isMonitor} token={((newRestoreToken != null) ? "yes" : "no")}");
						world.RunInUpdates(0, (Action)delegate
						{
							DesktopBuddyMod.SpawnStreaming(world, global::System.IntPtr.Zero, title, 0, -1, DesktopBuddyMod.Config?.GetValue(DesktopBuddyMod.NewWindowsStartPrivate) ?? false);
						});
					}
				}
				catch (global::System.Exception ex)
				{
					DesktopBuddyMod.Msg($"[ContextMenu] Linux portal picker error: {ex}");
				}
			}));
		}

		private static string RememberLinuxSource(LinuxSharedSource existing, string token, bool isMonitor, int width, int height)
		{
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			string text = (isMonitor ? $"Desktop ({width}×{height})" : $"Window ({width}×{height})");
			if (string.IsNullOrEmpty(token))
			{
				return existing?.Label ?? text;
			}
			lock (_linuxSourcesLock)
			{
				LinuxSharedSource linuxSharedSource = ((existing != null && _linuxSources.Contains(existing)) ? existing : null);
				if (linuxSharedSource == null)
				{
					Enumerator<LinuxSharedSource> enumerator = _linuxSources.GetEnumerator();
					try
					{
						while (enumerator.MoveNext())
						{
							LinuxSharedSource current = enumerator.Current;
							if (current.RestoreToken == token || (current.Label == text && current.IsMonitor == isMonitor))
							{
								linuxSharedSource = current;
								break;
							}
						}
					}
					finally
					{
						((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
					}
				}
				if (linuxSharedSource != null)
				{
					linuxSharedSource.RestoreToken = token;
					linuxSharedSource.Label = text;
					linuxSharedSource.IsMonitor = isMonitor;
				}
				else
				{
					linuxSharedSource = new LinuxSharedSource
					{
						Label = text,
						RestoreToken = token,
						IsMonitor = isMonitor
					};
					_linuxSources.Add(linuxSharedSource);
				}
			}
			SaveLinuxSources();
			return text;
		}
	}
	internal readonly struct UiGradientPalette
	{
		[field: CompilerGenerated]
		internal colorX Start
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		internal colorX Middle
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		internal colorX End
		{
			[CompilerGenerated]
			get;
		}

		internal UiGradientPalette(colorX start, colorX middle, colorX end)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Start = start;
			Middle = middle;
			End = end;
		}
	}
	internal static class UiPrimitiveStyles
	{
		internal static void DestroyLayoutControllers(Slot slot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			if (slot == null || ((ContainerWorker<Component>)(object)slot).IsDestroyed)
			{
				return;
			}
			Enumerator<HorizontalLayout> enumerator = ((ContainerWorker<Component>)(object)slot).GetComponents<HorizontalLayout>((Predicate<HorizontalLayout>)null, false).GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					((ComponentBase<Component>)(object)enumerator.Current).Destroy();
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<VerticalLayout> enumerator2 = ((ContainerWorker<Component>)(object)slot).GetComponents<VerticalLayout>((Predicate<VerticalLayout>)null, false).GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					((ComponentBase<Component>)(object)enumerator2.Current).Destroy();
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<GridLayout> enumerator3 = ((ContainerWorker<Component>)(object)slot).GetComponents<GridLayout>((Predicate<GridLayout>)null, false).GetEnumerator();
			try
			{
				while (enumerator3.MoveNext())
				{
					((ComponentBase<Component>)(object)enumerator3.Current).Destroy();
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator3/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<OverlappingLayout> enumerator4 = ((ContainerWorker<Component>)(object)slot).GetComponents<OverlappingLayout>((Predicate<OverlappingLayout>)null, false).GetEnumerator();
			try
			{
				while (enumerator4.MoveNext())
				{
					((ComponentBase<Component>)(object)enumerator4.Current).Destroy();
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator4/*cast due to .constrained prefix*/).Dispose();
			}
		}

		internal static SpriteProvider CreateRoundedSprite(Slot slot, World world, float fixedSize)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			SpriteProvider obj = TextureProviderSettings.ClampWrap<SpriteProvider>(((ContainerWorker<Component>)(object)slot).GetComponent<SpriteProvider>((Predicate<SpriteProvider>)null, false) ?? ((ContainerWorker<Component>)(object)slot).AttachComponent<SpriteProvider>(true, (Action<SpriteProvider>)null));
			((SyncRef<IAssetProvider<ITexture2D>>)(object)obj.Texture).Target = UIBuilder.GetCircleTexture(world);
			Sync<float4> borders = obj.Borders;
			float4 one = float4.One;
			((SyncField<float4>)(object)borders).Value = (ref one) * 0.49f;
			((SyncField<float>)(object)obj.FixedSize).Value = fixedSize;
			return obj;
		}

		internal static GradientImage ApplyDiagonalGradient(Image image, float fixedSize, float alpha, bool interactionTarget, UiGradientPalette palette)
		{
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: 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)
			if (image == null || ((Component)image).Slot == null || ((ContainerWorker<Component>)(object)((Component)image).Slot).IsDestroyed)
			{
				return null;
			}
			((ComponentBase<Component>)(object)image).Enabled = false;
			((SyncField<bool>)(object)((ImageBase)image).InteractionTarget).Value = false;
			GradientImage obj = ((ContainerWorker<Component>)(object)((Component)image).Slot).GetComponent<GradientImage>((Predicate<GradientImage>)null, false) ?? ((ContainerWorker<Component>)(object)((Component)image).Slot).AttachComponent<GradientImage>(true, (Action<GradientImage>)null);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)obj).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)image).Slot, ((Worker)((Component)image).Slot).World, fixedSize);
			((SyncField<NineSliceSizing>)(object)((ImageBase)obj).NineSliceSizing).Value = (NineSliceSizing)0;
			((SyncField<bool>)(object)((ImageBase)obj).PreserveAspect).Value = false;
			((SyncField<bool>)(object)((ImageBase)obj).InteractionTarget).Value = interactionTarget;
			colorX val = palette.Start;
			colorX value = ((colorX)(ref val)).SetA(alpha);
			val = palette.Middle;
			colorX value2 = ((colorX)(ref val)).SetA(alpha);
			val = palette.End;
			colorX value3 = ((colorX)(ref val)).SetA(alpha);
			((SyncField<colorX>)(object)obj.TintTopLeft).Value = value;
			((SyncField<colorX>)(object)obj.TintBottomLeft).Value = value2;
			((SyncField<colorX>)(object)obj.TintTopRight).Value = value2;
			((SyncField<colorX>)(object)obj.TintBottomRight).Value = value3;
			return obj;
		}

		internal static void ConfigureGradientButtonDriver(Button button, int index, Sync<colorX> target, colorX color)
		{
			if (button != null && target != null)
			{
				while (((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Count <= index)
				{
					((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers).Add();
				}
				ColorDriver obj = ((SyncElementList<ColorDriver>)(object)((InteractionElement)button).ColorDrivers)[index];
				((SyncRef<IField<colorX>>)(object)obj.ColorDrive).Target = (IField<colorX>)(object)target;
				obj.SetColors(ref color);
			}
		}

		internal static void StyleRoundedPill(Image image, colorX color, float fixedSize, bool interactionTarget)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (image != null)
			{
				((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)image).Sprite).Target = (IAssetProvider<Sprite>)(object)CreateRoundedSprite(((Component)image).Slot, ((Worker)((Component)image).Slot).World, fixedSize);
				((SyncField<NineSliceSizing>)(object)((ImageBase)image).NineSliceSizing).Value = (NineSliceSizing)0;
				((SyncField<colorX>)(object)image.Tint).Value = color;
				((SyncField<bool>)(object)((ImageBase)image).InteractionTarget).Value = interactionTarget;
			}
		}
	}
	public class UiScrollbarState
	{
		public ScrollRect Scroll;

		public Slot Root;

		public RectTransform ThumbRect;

		public Slider<float> Slider;

		public float TrackPadding = 8f;

		public float TrackHeight;

		public float ThumbHeight;
	}
	internal readonly struct UiScrollbarStyle
	{
		[field: CompilerGenerated]
		internal colorX FrameTint
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		internal colorX RailTint
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		internal colorX ThumbTint
		{
			[CompilerGenerated]
			get;
		}

		[field: CompilerGenerated]
		internal UiGradientPalette ThumbGradient
		{
			[CompilerGenerated]
			get;
		}

		internal UiScrollbarStyle(colorX frameTint, colorX railTint, colorX thumbTint, UiGradientPalette thumbGradient)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			FrameTint = frameTint;
			RailTint = railTint;
			ThumbTint = thumbTint;
			ThumbGradient = thumbGradient;
		}
	}
	internal static class UiScrollbars
	{
		internal static UIBuilder BeginRoundedScroll(UIBuilder ui, World world, global::System.Collections.Generic.IList<UiScrollbarState> scrollbars, Action scheduleGeometryUpdate, UiScrollbarStyle style, string name, float minHeight, Alignment alignment, out ScrollRect scroll, colorX? frameTint = null)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected O, but got Unknown
			ui.Style.MinHeight = minHeight;
			ui.Style.PreferredHeight = minHeight;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = ((minHeight <= 0f) ? 1f : (-1f));
			colorX val = (colorX)(((??)frameTint) ?? style.FrameTint);
			Image val2 = ui.Image(ref val, false);
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val2).Sprite).Target = (IAssetProvider<Sprite>)(object)UiPrimitiveStyles.CreateRoundedSprite(((Component)val2).Slot, world, 16f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val2).NineSliceSizing).Value = (NineSliceSizing)0;
			ui.NestInto(((UIComponent)val2).RectTransform);
			ui.LayoutTarget = ((Component)val2).Slot;
			ui.HorizontalLayout(10f, 12f, 10f, 12f, 12f, (Alignment?)(Alignment)4);
			ui.Style.MinWidth = 0f;
			ui.Style.PreferredWidth = 0f;
			ui.Style.MinHeight = 0f;
			ui.Style.PreferredHeight = 0f;
			ui.Style.FlexibleWidth = 1f;
			ui.Style.FlexibleHeight = 1f;
			Slot val3 = ui.Empty(name + "Viewport");
			Slot val4 = default(Slot);
			Mask val5 = default(Mask);
			Image val6 = default(Image);
			scroll = ScrollRect.CreateScrollRect<Image>(val3, ref val4, ref val5, ref val6);
			scroll.Alignment = alignment;
			((SyncField<bool>)(object)val5.ShowMaskGraphic).Value = false;
			((SyncField<colorX>)(object)val6.Tint).Value = colorX.White;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)val6).Sprite).Target = (IAssetProvider<Sprite>)(object)UiPrimitiveStyles.CreateRoundedSprite(val3, world, 14f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)val6).NineSliceSizing).Value = (NineSliceSizing)0;
			UIBuilder val7 = new UIBuilder(val4, (Slot)null)
			{
				LayoutTarget = val4
			};
			val7.VerticalLayout(10f, 4f, 4f, 4f, 4f, (Alignment?)(Alignment)0, (bool?)true, (bool?)false);
			val7.FitContent((SizeFit)0, (SizeFit)2);
			AddScrollbarSlider(ui, world, scrollbars, scheduleGeometryUpdate, style, name + "Scrollbar", scroll);
			ui.NestOut();
			return val7;
		}

		internal static void UpdateGeometry(global::System.Collections.Generic.IEnumerable<UiScrollbarState> scrollbars)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			if (scrollbars == null)
			{
				return;
			}
			global::System.Collections.Generic.IEnumerator<UiScrollbarState> enumerator = scrollbars.GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					UiScrollbarState current = enumerator.Current;
					if (current?.Root != null && !((ContainerWorker<Component>)(object)current.Root).IsDestroyed && current.Scroll != null && !((ComponentBase<Component>)(object)current.Scroll).IsDestroyed && current.ThumbRect != null && !((ComponentBase<Component>)(object)current.ThumbRect).IsDestroyed)
					{
						RectTransform component = ((ContainerWorker<Component>)(object)((Component)current.Scroll).Slot).GetComponent<RectTransform>((Predicate<RectTransform>)null, false);
						Rect val = (Rect)((component != null) ? component.LocalComputeRect : default(Rect));
						Slot parent = ((Component)current.Scroll).Slot.Parent;
						Rect? obj;
						if (parent == null)
						{
							obj = null;
						}
						else
						{
							RectTransform component2 = ((ContainerWorker<Component>)(object)parent).GetComponent<RectTransform>((Predicate<RectTransform>)null, false);
							obj = ((component2 != null) ? new Rect?(component2.LocalComputeRect) : ((Rect?)null));
						}
						Rect? val2 = obj;
						Rect valueOrDefault = val2.GetValueOrDefault();
						float num = Math.Abs(((Rect)(ref val)).height);
						float num2 = Math.Abs(((Rect)(ref valueOrDefault)).height);
						bool flag = num > num2 + 2f && num2 > 1f;
						current.Root.ActiveSelf = flag;
						if (flag)
						{
							float num3 = Math.Max(1f, num2 - 16f);
							float thumbHeight = Math.Clamp(num3 * num2 / Math.Max(num, num2), 34f, num3);
							float value = ((current.Slider == null || ((ComponentBase<Component>)(object)current.Slider).IsDestroyed) ? (1f - Math.Clamp(((SyncField<float2>)(object)current.Scroll.NormalizedPosition).Value.y, 0f, 1f)) : ((SyncField<float>)(object)current.Slider.Value).Value);
							current.TrackPadding = 8f;
							current.TrackHeight = num3;
							current.ThumbHeight = thumbHeight;
							SetThumbValue(current, value);
						}
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
		}

		private static void AddScrollbarSlider(UIBuilder ui, World world, global::System.Collections.Generic.IList<UiScrollbarState> scrollbars, Action scheduleGeometryUpdate, UiScrollbarStyle style, string name, ScrollRect scroll)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			ui.Style.MinWidth = 18f;
			ui.Style.PreferredWidth = 18f;
			ui.Style.MinHeight = 0f;
			ui.Style.PreferredHeight = 0f;
			ui.Style.FlexibleWidth = -1f;
			ui.Style.FlexibleHeight = 1f;
			Slot val = ui.Empty(name);
			((SyncField<colorX>)(object)((ContainerWorker<Component>)(object)val).AttachComponent<Image>(true, (Action<Image>)null).Tint).Value = colorX.Clear;
			Slider<float> slider = ((ContainerWorker<Component>)(object)val).AttachComponent<Slider<float>>(true, (Action<Slider<float>>)null);
			((SyncField<bool>)(object)slider.RequireLockInToInteract).Value = true;
			((SyncField<bool>)(object)slider.RequireInitialPress).Value = true;
			((SyncField<Direction<float>>)(object)slider.SlideDirection).Value = (Direction<float>)1;
			((SyncField<float2>)(object)slider.AnchorOffset).Value = new float2(0.5f, 0f);
			((SyncField<float>)(object)slider.Min).Value = 0f;
			((SyncField<float>)(object)slider.Max).Value = 1f;
			((SyncField<float>)(object)slider.Value).Value = 1f - Math.Clamp(((SyncField<float2>)(object)scroll?.NormalizedPosition).Value.y ?? 0f, 0f, 1f);
			Slot val2 = val.AddSlot("Rail", true);
			RectTransform componentOrAttach = ((ContainerWorker<Component>)(object)val2).GetComponentOrAttach<RectTransform>((Predicate<RectTransform>)null);
			((SyncField<float2>)(object)componentOrAttach.AnchorMin).Value = new float2(0.5f, 0f);
			((SyncField<float2>)(object)componentOrAttach.AnchorMax).Value = new float2(0.5f, 1f);
			((SyncField<float2>)(object)componentOrAttach.OffsetMin).Value = new float2(-5f, 8f);
			((SyncField<float2>)(object)componentOrAttach.OffsetMax).Value = new float2(5f, -8f);
			Image obj = ((ContainerWorker<Component>)(object)val2).AttachComponent<Image>(true, (Action<Image>)null);
			((SyncField<colorX>)(object)obj.Tint).Value = style.RailTint;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)obj).Sprite).Target = (IAssetProvider<Sprite>)(object)UiPrimitiveStyles.CreateRoundedSprite(val2, world, 8f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)obj).NineSliceSizing).Value = (NineSliceSizing)0;
			Slot val3 = val.AddSlot("Thumb", true);
			RectTransform componentOrAttach2 = ((ContainerWorker<Component>)(object)val3).GetComponentOrAttach<RectTransform>((Predicate<RectTransform>)null);
			Rect val4 = new Rect(-7f, -36f, 14f, 72f);
			float2 val5 = new float2(0.5f, ((SyncField<float>)(object)slider.Value).Value);
			componentOrAttach2.SetFixedRect(val4, ref val5);
			Image obj2 = ((ContainerWorker<Component>)(object)val3).AttachComponent<Image>(true, (Action<Image>)null);
			((SyncField<colorX>)(object)obj2.Tint).Value = style.ThumbTint;
			((SyncRef<IAssetProvider<Sprite>>)(object)((ImageBase)obj2).Sprite).Target = (IAssetProvider<Sprite>)(object)UiPrimitiveStyles.CreateRoundedSprite(val3, world, 8f);
			((SyncField<NineSliceSizing>)(object)((ImageBase)obj2).NineSliceSizing).Value = (NineSliceSizing)0;
			UiPrimitiveStyles.ApplyDiagonalGradient(obj2, 8f, 1f, interactionTarget: false, style.ThumbGradient);
			UiScrollbarState barState = new UiScrollbarState
			{
				Scroll = scroll,
				Root = val,
				ThumbRect = componentOrAttach2,
				Slider = slider
			};
			((SyncField<float>)(object)slider.Value).LocalFilter = (float candidate, IField<float> field) => Math.Clamp(candidate, 0f, 1f);
			((SyncField<float>)(object)slider.Value).OnValueChange += delegate(SyncField<float> field)
			{
				//IL_0042: 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_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				float num = Math.Clamp(field.Value, 0f, 1f);
				SetThumbValue(barState, num);
				if (scroll != null && !((ComponentBase<Component>)(object)scroll).IsDestroyed)
				{
					float2 value = ((SyncField<float2>)(object)scroll.NormalizedPosition).Value;
					((SyncField<float2>)(object)scroll.NormalizedPosition).Value = new float2(value.x, 1f - num);
				}
			};
			if (scroll != null)
			{
				((SyncField<float2>)(object)scroll.NormalizedPosition).OnValueChange += delegate(SyncField<float2> field)
				{
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					if (!((ComponentBase<Component>)(object)slider).IsDestroyed)
					{
						float value = 1f - Math.Clamp(field.Value.y, 0f, 1f);
						SetThumbValue(barState, value);
					}
				};
			}
			((global::System.Collections.Generic.ICollection<UiScrollbarState>)scrollbars)?.Add(barState);
			if (scheduleGeometryUpdate != null)
			{
				scheduleGeometryUpdate.Invoke();
			}
		}

		private static void SetThumbValue(UiScrollbarState bar, float value)
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (bar?.ThumbRect != null && !((ComponentBase<Component>)(object)bar.ThumbRect).IsDestroyed)
			{
				float num = Math.Clamp(value, 0f, 1f);
				float num2 = Math.Max(1f, bar.TrackHeight);
				float num3 = Math.Clamp((bar.ThumbHeight <= 0f) ? 34f : bar.ThumbHeight, 1f, num2);
				float num4 = Math.Max(0f, num2 - num3);
				float num5 = bar.TrackPadding + num4 * num;
				RectTransform thumbRect = bar.ThumbRect;
				Rect val = new Rect(-7f, num5, 14f, num3);
				float2 val2 = new float2(0.5f, 0f);
				thumbRect.SetFixedRect(val, ref val2);
			}
		}
	}
	internal static class UiStickScroll
	{
		internal static void StartLoop(Slot ownerRoot, Slot surfaceSlot, Slot renderRoot, Func<int> nextGeneration, Func<int> currentGeneration, float deadzone, float pixelsPerTick)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			Slot obj = ownerRoot;
			int generation;
			InteractionHandler cachedHandler;
			if (((obj != null) ? ((Worker)obj).World : null) != null)
			{
				generation = nextGeneration.Invoke();
				cachedHandler = null;
				((Worker)ownerRoot).World.RunInUpdates(1, new Action(Tick));
			}
			void Tick()
			{
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_0090: Expected O, but got Unknown
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				if (ownerRoot != null && !((ContainerWorker<Component>)(object)ownerRoot).IsDestroyed && surfaceSlot != null && !((ContainerWorker<Component>)(object)surfaceSlot).IsDestroyed && surfaceSlot.ActiveSelf && generation == currentGeneration.Invoke())
				{
					Process(((Worker)ownerRoot).World, renderRoot, deadzone, pixelsPerTick, ref cachedHandler);
					((Worker)ownerRoot).World.RunInUpdates(1, new Action(Tick));
				}
			}
		}

		internal static void Process(World world, Slot renderRoot, float deadzone, float pixelsPerTick)
		{
			InteractionHandler cachedHandler = null;
			Process(world, renderRoot, deadzone, pixelsPerTick, ref cachedHandler);
		}

		private static void Process(World world, Slot renderRoot, float deadzone, float pixelsPerTick, ref InteractionHandler cachedHandler)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			object obj;
			if (world == null)
			{
				obj = null;
			}
			else
			{
				User localUser = world.LocalUser;
				obj = ((localUser != null) ? localUser.Root : null);
			}
			UserRoot val = (UserRoot)obj;
			if (world == null || val == null || renderRoot == null || ((ContainerWorker<Component>)(object)renderRoot).IsDestroyed)
			{
				return;
			}
			if (cachedHandler == null || ((ComponentBase<Component>)(object)cachedHandler).IsDestroyed || (int)((SyncField<Chirality>)(object)cachedHandler.Side).Value != 1)
			{
				cachedHandler = val.GetRegisteredComponent<InteractionHandler>((Predicate<InteractionHandler>)((InteractionHandler h) => (int)((SyncField<Chirality>)(object)h.Side).Value == 1));
			}
			InteractionHandler val2 = cachedHandler;
			object obj2;
			if (val2 == null)
			{
				obj2 = null;
			}
			else
			{
				InteractionLaser laser = val2.Laser;
				obj2 = ((laser != null) ? laser.CurrentTouchable : null);
			}
			ITouchable val3 = (ITouchable)obj2;
			if (val3 == null)
			{
				return;
			}
			IAxisActionReceiver val4 = (IAxisActionReceiver)(object)((val3 is IAxisActionReceiver) ? val3 : null);
			if (val4 == null)
			{
				return;
			}
			Slot slot = ((IComponent)val3).Slot;
			if (slot == null || !slot.IsChildOf(renderRoot, true))
			{
				return;
			}
			IStandardController controllerNode = world.InputInterface.GetControllerNode((Chirality)1);
			if (controllerNode != null)
			{
				float y = controllerNode.Axis.Value.y;
				if (!(Math.Abs(y) <= deadzone))
				{
					val4.ProcessAxis((Component)(object)val2.Laser.TouchSource, new float2(0f, y * pixelsPerTick));
				}
			}
		}
	}
	internal static class TextureProviderSettings
	{
		private static readonly string[] WrapMemberNames = new string[8] { "WrapMode", "WrapModeU", "WrapModeV", "WrapModeW", "AddressMode", "AddressModeU", "AddressModeV", "AddressModeW" };

		internal static T ClampWrap<T>(T provider) where T : class
		{
			if (provider == null)
			{
				return null;
			}
			string[] wrapMemberNames = WrapMemberNames;
			foreach (string name in wrapMemberNames)
			{
				TrySetMember(provider, name);
			}
			return provider;
		}

		private static void TrySetMember(object provider, string name)
		{
			global::System.Type type = provider.GetType();
			FieldInfo field = type.GetField(name, (BindingFlags)52);
			if (field != (FieldInfo)null)
			{
				if (field.FieldType.IsEnum)
				{
					field.SetValue(provider, GetClampValue(field.FieldType));
				}
				else
				{
					SetValueOrSyncValue(field.GetValue(provider), null);
				}
				return;
			}
			PropertyInfo property = type.GetProperty(name, (BindingFlags)52);
			if (!(property == (PropertyInfo)null))
			{
				if (property.CanWrite && property.PropertyType.IsEnum)
				{
					property.SetValue(provider, GetClampValue(property.PropertyType));
				}
				else
				{
					SetValueOrSyncValue(property.GetValue(provider), property);
				}
			}
		}

		private static void SetValueOrSyncValue(object target, PropertyInfo sourceProperty)
		{
			if (target == null)
			{
				return;
			}
			global::System.Type type = target.GetType();
			if (type.IsEnum)
			{
				return;
			}
			PropertyInfo property = type.GetProperty("Value", (BindingFlags)52);
			if (property == (PropertyInfo)null || !property.CanWrite)
			{
				return;
			}
			global::System.Type propertyType = property.PropertyType;
			if (!propertyType.IsEnum)
			{
				return;
			}
			try
			{
				property.SetValue(target, GetClampValue(propertyType));
			}
			catch (global::System.Exception ex)
			{
				DesktopBuddyMod.Msg("[Texture] Could not clamp " + (((sourceProperty != null) ? ((MemberInfo)sourceProperty).Name : null) ?? ((MemberInfo)type).Name) + ": " + ex.Message);
			}
		}

		private static object GetClampValue(global::System.Type enumType)
		{
			if (global::System.Enum.IsDefined(enumType, (object)"Clamp"))
			{
				return global::System.Enum.Parse(enumType, "Clamp");
			}
			return global::System.Enum.ToObject(enumType, 1);
		}
	}
	internal static class Log
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__RunDiagnosticsBundleExport;
		}

		private const int RecentLineLimit = 500;

		private static readonly object RecentLinesLock = new object();

		private static readonly Queue<string> RecentLines = new Queue<string>(500);

		private static ManualLogSource _logger;

		internal static string FilePath => ResolveGameBepInExLogPath();

		internal static void Msg(string msg)
		{
			AddRecentLine(msg, isError: false);
			try
			{
				ManualLogSource logger = _logger;
				if (logger != null)
				{
					logger.LogInfo((object)msg);
				}
			}
			catch
			{
			}
		}

		internal static void Error(string msg)
		{
			AddRecentLine(msg, isError: true);
			try
			{
				ManualLogSource logger = _logger;
				if (logger != null)
				{
					logger.LogError((object)msg);
				}
			}
			catch
			{
			}
		}

		internal static void SetLogger(ManualLogSource logger)
		{
			_logger = logger;
		}

		internal static void StartSession()
		{
			Msg("DesktopBuddy session started");
		}

		internal static string[] GetRecentLines(int maxLines = 100)
		{
			maxLines = Math.Clamp(maxLines, 1, 100);
			lock (RecentLinesLock)
			{
				return Enumerable.ToArray<string>(Enumerable.Skip<string>((global::System.Collections.Generic.IEnumerable<string>)RecentLines, Math.Max(0, RecentLines.Count - maxLines)));
			}
		}

		internal static string ExportCombinedLog()
		{
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			string text = Path.Combine(Environment.GetFolderPath((SpecialFolder)40), "Downloads");
			if (!Directory.Exists(text))
			{
				text = ResolveBepInExProfileRoot(Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".") ?? Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".";
			}
			string text2 = Path.Combine(text, $"DesktopBuddy_Combined_{Environment.MachineName}_{global::System.DateTime.Now:yyyy-MM-dd_HH-mm-ss}.log");
			StringBuilder val = new StringBuilder();
			AppendLogSection(val, "Game BepInEx", ResolveGameBepInExLogPath());
			AppendLogSection(val, "Renderer BepInEx", ResolveRendererBepInExLogPath());
			File.WriteAllText(text2, ((object)val).ToString());
			Msg("[Log] Exported combined BepInEx log: " + text2);
			return text2;
		}

		internal static void ExportDiagnosticsBundle()
		{
			//IL_0010: 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_001b: Expected O, but got Unknown
			object obj = <>O.<0>__RunDiagnosticsBundleExport;
			if (obj == null)
			{
				Action val = RunDiagnosticsBundleExport;
				<>O.<0>__RunDiagnosticsBundleExport = val;
				obj = (object)val;
			}
			global::System.Threading.Tasks.Task.Run((Action)obj);
			Msg("[Log] Started DesktopBuddy diagnostics bundle export");
		}

		private static void RunDiagnosticsBundleExport()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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_006c: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			string text = Path.Combine(Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".", "CollectDesktopBuddyDiagnostics.ps1");
			if (!File.Exists(text))
			{
				Error("[Log] Diagnostics export failed: collector was not found at " + text);
				return;
			}
			ProcessStartInfo val = new ProcessStartInfo
			{
				FileName = "powershell.exe",
				Arguments = "-NoProfile -ExecutionPolicy Bypass -File \"" + text + "\"",
				UseShellExecute = false,
				CreateNoWindow = true,
				RedirectStandardOutput = true,
				RedirectStandardError = true
			};
			try
			{
				Process val2 = Process.Start(val);
				try
				{
					if (val2 == null)
					{
						Error("[Log] Diagnostics export failed: PowerShell did not start");
						return;
					}
					string text2 = ((TextReader)val2.StandardOutput).ReadToEnd();
					string text3 = ((TextReader)val2.StandardError).ReadToEnd();
					val2.WaitForExit();
					string text4 = ExtractDiagnosticsPath(text2);
					if (val2.ExitCode == 0 && !string.IsNullOrWhiteSpace(text4))
					{
						Msg("[Log] Diagnostics bundle exported: " + text4);
						OpenContainingFolder(text4);
					}
					else if (val2.ExitCode == 0)
					{
						Msg("[Log] Diagnostics bundle export finished, but no output path was reported");
						if (!string.IsNullOrWhiteSpace(text2))
						{
							Msg("[Log] Diagnostics output: " + text2.Trim());
						}
					}
					else
					{
						Error($"[Log] Diagnostics export failed exit={val2.ExitCode}: {(string.IsNullOrWhiteSpace(text3) ? text2.Trim() : text3.Trim())}");
					}
				}
				finally
				{
					((global::System.IDisposable)val2)?.Dispose();
				}
			}
			catch (global::System.Exception ex)
			{
				Error($"[Log] Diagnostics export failed: {ex}");
			}
		}

		private static string ExtractDiagnosticsPath(string stdout)
		{
			if (string.IsNullOrWhiteSpace(stdout))
			{
				return null;
			}
			global::System.Collections.Generic.IEnumerator<string> enumerator = Enumerable.Reverse<string>(stdout.Split(new char[2] { '\r', '\n' }, (StringSplitOptions)1)).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					string text = enumerator.Current.Trim();
					if (text.EndsWith(".zip", (StringComparison)5) && File.Exists(text))
					{
						return text;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			return null;
		}

		private static void OpenContainingFolder(string path)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			try
			{
				Process.Start(new ProcessStartInfo
				{
					FileName = "explorer.exe",
					Arguments = "/select,\"" + path + "\"",
					UseShellExecute = true
				});
			}
			catch (global::System.Exception ex)
			{
				Msg("[Log] Diagnostics bundle exported, but folder open failed: " + ex.Message);
			}
		}

		private static string ResolveGameBepInExLogPath()
		{
			string text = Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".";
			string text2 = ResolveBepInExProfileRoot(text);
			string text3 = ResolveResoniteRoot();
			global::System.Collections.Generic.IEnumerator<string> enumerator = Enumerable.Distinct<string>(Enumerable.Where<string>((global::System.Collections.Generic.IEnumerable<string>)new string[3] { text2, text3, text }, (Func<string, bool>)((string root) => !string.IsNullOrWhiteSpace(root))), (IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					string text4 = Path.Combine(enumerator.Current, "BepInEx", "LogOutput.log");
					if (File.Exists(text4))
					{
						return text4;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			if (string.IsNullOrWhiteSpace(text2))
			{
				return Path.Combine(text3, "BepInEx", "LogOutput.log");
			}
			return Path.Combine(text2, "BepInEx", "LogOutput.log");
		}

		private static string ResolveResoniteRoot()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			string text = Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".";
			for (DirectoryInfo val = new DirectoryInfo(text); val != null; val = val.Parent)
			{
				if (File.Exists(Path.Combine(((FileSystemInfo)val).FullName, "Resonite.exe")))
				{
					return ((FileSystemInfo)val).FullName;
				}
			}
			return text;
		}

		private static string ResolveRendererBepInExLogPath()
		{
			string text = Path.GetDirectoryName(typeof(Log).Assembly.Location) ?? ".";
			string text2 = ResolveBepInExProfileRoot(text);
			string text3 = ResolveResoniteRoot();
			global::System.Collections.Generic.IEnumerator<string> enumerator = Enumerable.Distinct<string>(Enumerable.Where<string>((global::System.Collections.Generic.IEnumerable<string>)new string[3] { text2, text3, text }, (Func<string, bool>)((string root) => !string.IsNullOrWhiteSpace(root))), (IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase).GetEnumerator();
			try
			{
				while (((global::System.Collections.IEnumerator)enumerator).MoveNext())
				{
					string text4 = Path.Combine(enumerator.Current, "Renderer", "BepInEx", "LogOutput.log");
					if (File.Exists(text4))
					{
						return text4;
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator)?.Dispose();
			}
			if (string.IsNullOrWhiteSpace(text2))
			{
				return Path.Combine(text3, "Renderer", "BepInEx", "LogOutput.log");
			}
			return Path.Combine(text2, "Renderer", "BepInEx", "LogOutput.log");
		}

		private static string ResolveBepInExProfileRoot(string startDir)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			for (DirectoryInfo val = new DirectoryInfo(startDir); val != null; val = val.Parent)
			{
				if (((FileSystemInfo)val).Name.Equals("BepInEx", (StringComparison)5) && Directory.Exists(Path.Combine(((FileSystemInfo)val).FullName, "plugins")))
				{
					DirectoryInfo parent = val.Parent;
					if (parent == null)
					{
						return null;
					}
					return ((FileSystemInfo)parent).FullName;
				}
			}
			return null;
		}

		private static void AppendLogSection(StringBuilder builder, string title, string path)
		{
			StringBuilder val = builder;
			StringBuilder obj = val;
			AppendInterpolatedStringHandler val2 = default(AppendInterpolatedStringHandler);
			((AppendInterpolatedStringHandler)(ref val2))..ctor(12, 1, val);
			((AppendInterpolatedStringHandler)(ref val2)).AppendLiteral("===== ");
			((AppendInterpolatedStringHandler)(ref val2)).AppendFormatted(title);
			((AppendInterpolatedStringHandler)(ref val2)).AppendLiteral(" =====");
			obj.AppendLine(ref val2);
			builder.AppendLine(path);
			try
			{
				if (File.Exists(path))
				{
					builder.AppendLine(ReadAllTextShared(path));
				}
				else
				{
					builder.AppendLine("(missing)");
				}
			}
			catch (global::System.Exception ex)
			{
				val = builder;
				StringBuilder obj2 = val;
				((AppendInterpolatedStringHandler)(ref val2))..ctor(18, 1, val);
				((AppendInterpolatedStringHandler)(ref val2)).AppendLiteral("(failed to read: ");
				((AppendInterpolatedStringHandler)(ref val2)).AppendFormatted(ex.Message);
				((AppendInterpolatedStringHandler)(ref val2)).AppendLiteral(")");
				obj2.AppendLine(ref val2);
			}
			builder.AppendLine();
		}

		private static void AddRecentLine(string message, bool isError)
		{
			string text = (isError ? "ERROR: " : "");
			string text2 = $"[{global::System.DateTime.Now:HH:mm:ss.fff}] {text}{message}";
			lock (RecentLinesLock)
			{
				if (RecentLines.Count >= 500)
				{
					RecentLines.Dequeue();
				}
				RecentLines.Enqueue(text2);
			}
		}

		private static string ReadAllTextShared(string path)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			FileStream val = new FileStream(path, (FileMode)3, (FileAccess)1, (FileShare)7);
			try
			{
				StreamReader val2 = new StreamReader((Stream)(object)val, Encoding.UTF8, true);
				try
				{
					return ((TextReader)val2).ReadToEnd();
				}
				finally
				{
					((global::System.IDisposable)val2)?.Dispose();
				}
			}
			finally
			{
				((global::System.IDisposable)val)?.Dispose();
			}
		}
	}
	public sealed class PerfTimer : global::System.IDisposable
	{
		private class StepStats
		{
			public long TotalTicks;

			public long MaxTicks;

			public long Count;
		}

		public readonly struct TimedScope : global::System.IDisposable
		{
			private readonly PerfTimer _timer;

			private readonly string _step;

			private readonly long _startTicks;

			public TimedScope(PerfTimer timer, string step)
			{
				_timer = timer;
				_step = step;
				_startTicks = ((timer != null) ? Stopwatch.GetTimestamp() : 0);
			}

			public void Dispose()
			{
				if (_timer != null)
				{
					long elapsedTicks = Stopwatch.GetTimestamp() - _startTicks;
					_timer.Record(_step, elapsedTicks);
				}
			}
		}

		private static readonly bool Enabled;

		private readonly Stopwatch _reportSw = (Enabled ? Stopwatch.StartNew() : null);

		private const int REPORT_INTERVAL_MS = 5000;

		private readonly Dictionary<string, StepStats> _steps = new Dictionary<string, StepStats>();

		private readonly Dictionary<string, long> _counters = new Dictionary<string, long>();

		private readonly object _lock = new object();

		private long _totalFrames;

		private long _droppedFrames;

		private int _recordsSinceCheck;

		public void Record(string step, long elapsedTicks)
		{
			if (!Enabled)
			{
				return;
			}
			lock (_lock)
			{
				StepStats stepStats = default(StepStats);
				if (!_steps.TryGetValue(step, ref stepStats))
				{
					stepStats = new StepStats();
					_steps[step] = stepStats;
				}
				stepStats.TotalTicks += elapsedTicks;
				if (elapsedTicks > stepStats.MaxTicks)
				{
					stepStats.MaxTicks = elapsedTicks;
				}
				stepStats.Count++;
			}
			if (++_recordsSinceCheck >= 100)
			{
				_recordsSinceCheck = 0;
				if (_reportSw.ElapsedMilliseconds >= 5000)
				{
					PrintReport();
					_reportSw.Restart();
				}
			}
		}

		public void RecordMs(string step, double ms)
		{
			Record(step, (long)(ms * (double)Stopwatch.Frequency / 1000.0));
		}

		public void IncrementFrames()
		{
			if (Enabled)
			{
				Interlocked.Increment(ref _totalFrames);
			}
		}

		public void IncrementDropped(string reason = null)
		{
			if (Enabled)
			{
				Interlocked.Increment(ref _droppedFrames);
				if (!string.IsNullOrEmpty(reason))
				{
					IncrementCounter("drop:" + reason, 1L);
				}
			}
		}

		public void IncrementCounter(string counter, long delta = 1L)
		{
			if (!Enabled)
			{
				return;
			}
			lock (_lock)
			{
				long num = default(long);
				if (_counters.TryGetValue(counter, ref num))
				{
					_counters[counter] = num + delta;
				}
				else
				{
					_counters[counter] = delta;
				}
			}
		}

		public TimedScope Time(string step)
		{
			if (!Enabled)
			{
				return default(TimedScope);
			}
			return new TimedScope(this, step);
		}

		private void PrintReport()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, StepStats> val;
			Dictionary<string, long> val2;
			long num;
			long num2;
			Enumerator<string, StepStats> enumerator;
			lock (_lock)
			{
				val = new Dictionary<string, StepStats>();
				enumerator = _steps.GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						KeyValuePair<string, StepStats> current = enumerator.Current;
						val[current.Key] = new StepStats
						{
							TotalTicks = current.Value.TotalTicks,
							MaxTicks = current.Value.MaxTicks,
							Count = current.Value.Count
						};
						current.Value.TotalTicks = 0L;
						current.Value.MaxTicks = 0L;
						current.Value.Count = 0L;
					}
				}
				finally
				{
					((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
				}
				val2 = new Dictionary<string, long>((IDictionary<string, long>)(object)_counters);
				_counters.Clear();
				num = Interlocked.Exchange(ref _totalFrames, 0L);
				num2 = Interlocked.Exchange(ref _droppedFrames, 0L);
			}
			if (val.Count == 0 && num == 0L)
			{
				return;
			}
			double num3 = (double)Stopwatch.Frequency / 1000.0;
			List<string> val3 = new List<string>();
			val3.Add($"[Perf] === 5s Report: {num} frames, {num2} dropped ===");
			enumerator = val.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<string, StepStats> current2 = enumerator.Current;
					if (current2.Value.Count != 0L)
					{
						double num4 = (double)current2.Value.TotalTicks / (double)current2.Value.Count / num3;
						double num5 = (double)current2.Value.MaxTicks / num3;
						double num6 = (double)current2.Value.TotalTicks / num3;
						val3.Add($"[Perf]   {current2.Key}: avg={num4:F2}ms max={num5:F2}ms total={num6:F0}ms n={current2.Value.Count}");
					}
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
			Enumerator<string, long> enumerator2 = val2.GetEnumerator();
			try
			{
				while (enumerator2.MoveNext())
				{
					KeyValuePair<string, long> current3 = enumerator2.Current;
					val3.Add($"[Perf]   {current3.Key}: count={current3.Value}");
				}
			}
			finally
			{
				((global::System.IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
			}
			Log.Msg(string.Join("\n", (global::System.Collections.Generic.IEnumerable<string>)val3));
		}

		public void Dispose()
		{
		}
	}
	internal static class LinuxVirtualCameraSetup
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__3_0;

			internal void <Run>b__3_0()
			{
				try
				{
					RunSetup();
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[VirtualCamera] Setup error: " + ex.Message);
				}
				finally
				{
					Interlocked.Exchange(ref _running, 0);
				}
			}
		}

		internal const string CameraLabel = "DesktopBuddy - Camera";

		private const string SetupScript = "#!/bin/sh\nset -e\nLABEL='DesktopBuddy - Camera'\nif ! modinfo v4l2loopback >/dev/null 2>&1; then\n  echo 'The v4l2loopback kernel module is not installed.' >&2\n  echo 'Install it with your package manager, then run this setup again:' >&2\n  echo '  Arch / CachyOS : sudo pacman -S v4l2loopback-dkms' >&2\n  echo '  Debian / Ubuntu: sudo apt install v4l2loopback-dkms' >&2\n  echo '  Fedora         : sudo dnf install v4l2loopback' >&2\n  exit 1\nfi\nprintf 'options v4l2loopback exclusive_caps=1 card_label=\\\"%s\\\"\\n' \"$LABEL\" > /etc/modprobe.d/desktopbuddy-camera.conf\nprintf 'v4l2loopback\\n' > /etc/modules-load.d/desktopbuddy-camera.conf\nmodprobe -r v4l2loopback 2>/dev/null || true\nmodprobe v4l2loopback exclusive_caps=1 card_label=\"$LABEL\"\necho 'DesktopBuddy virtual camera configured'\n";

		private static int _running;

		internal static void Run()
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			if (Interlocked.Exchange(ref _running, 1) == 1)
			{
				Log.Msg("[VirtualCamera] Setup already running");
				return;
			}
			object obj = <>c.<>9__3_0;
			if (obj == null)
			{
				Action val = delegate
				{
					try
					{
						RunSetup();
					}
					catch (global::System.Exception ex)
					{
						Log.Msg("[VirtualCamera] Setup error: " + ex.Message);
					}
					finally
					{
						Interlocked.Exchange(ref _running, 0);
					}
				};
				<>c.<>9__3_0 = val;
				obj = (object)val;
			}
			global::System.Threading.Tasks.Task.Run((Action)obj);
		}

		private static void RunSetup()
		{
			//IL_002a: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			string text = Path.Combine(Path.GetTempPath(), "desktopbuddy-vcam-setup.sh");
			File.WriteAllText(text, "#!/bin/sh\nset -e\nLABEL='DesktopBuddy - Camera'\nif ! modinfo v4l2loopback >/dev/null 2>&1; then\n  echo 'The v4l2loopback kernel module is not installed.' >&2\n  echo 'Install it with your package manager, then run this setup again:' >&2\n  echo '  Arch / CachyOS : sudo pacman -S v4l2loopback-dkms' >&2\n  echo '  Debian / Ubuntu: sudo apt install v4l2loopback-dkms' >&2\n  echo '  Fedora         : sudo dnf install v4l2loopback' >&2\n  exit 1\nfi\nprintf 'options v4l2loopback exclusive_caps=1 card_label=\\\"%s\\\"\\n' \"$LABEL\" > /etc/modprobe.d/desktopbuddy-camera.conf\nprintf 'v4l2loopback\\n' > /etc/modules-load.d/desktopbuddy-camera.conf\nmodprobe -r v4l2loopback 2>/dev/null || true\nmodprobe v4l2loopback exclusive_caps=1 card_label=\"$LABEL\"\necho 'DesktopBuddy virtual camera configured'\n".Replace("\r\n", "\n"));
			ProcessStartInfo val = new ProcessStartInfo
			{
				FileName = "pkexec",
				UseShellExecute = false,
				RedirectStandardOutput = true,
				RedirectStandardError = true,
				CreateNoWindow = true
			};
			val.ArgumentList.Add("sh");
			val.ArgumentList.Add(text);
			Log.Msg("[VirtualCamera] Requesting admin rights to load and configure v4l2loopback (DesktopBuddy - Camera)");
			try
			{
				Process val2 = Process.Start(val);
				try
				{
					if (val2 == null)
					{
						Log.Msg("[VirtualCamera] Setup failed: pkexec did not start (is polkit installed?)");
						return;
					}
					string text2 = ((TextReader)val2.StandardOutput).ReadToEnd();
					string text3 = ((TextReader)val2.StandardError).ReadToEnd();
					val2.WaitForExit();
					if (val2.ExitCode == 0)
					{
						Log.Msg("[VirtualCamera] Virtual camera setup complete. Re-enable the camera or restart Resonite.");
						if (!string.IsNullOrWhiteSpace(text2))
						{
							Log.Msg("[VirtualCamera] " + text2.Trim());
						}
					}
					else
					{
						Log.Msg($"[VirtualCamera] Setup failed exit={val2.ExitCode}: {(string.IsNullOrWhiteSpace(text3) ? text2.Trim() : text3.Trim())}");
					}
				}
				finally
				{
					((global::System.IDisposable)val2)?.Dispose();
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[VirtualCamera] Setup failed to launch pkexec: " + ex.Message);
			}
			finally
			{
				try
				{
					File.Delete(text);
				}
				catch
				{
				}
			}
		}
	}
	internal static class SoftCam
	{
		private const string DllName = "softcam64";

		private const string FilterClsid = "{AEF3B972-5FA5-4647-9571-358EB472BC9E}";

		static SoftCam()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			NativeLibrary.SetDllImportResolver(typeof(SoftCam).Assembly, (DllImportResolver)delegate(string name, Assembly asm, DllImportSearchPath? path)
			{
				if (name != "softcam64")
				{
					return global::System.IntPtr.Zero;
				}
				string text = FindDll();
				nint num = default(nint);
				return (text != null && NativeLibrary.TryLoad(text, ref num)) ? num : ((nint)global::System.IntPtr.Zero);
			});
		}

		internal static bool IsFilterRegistered()
		{
			try
			{
				RegistryKey val = Registry.ClassesRoot.OpenSubKey("CLSID\\{AEF3B972-5FA5-4647-9571-358EB472BC9E}");
				try
				{
					return val != null;
				}
				finally
				{
					((global::System.IDisposable)val)?.Dispose();
				}
			}
			catch
			{
				return false;
			}
		}

		internal static string FindDll()
		{
			string text = DesktopBuddyRuntimePaths.FindFile("softcam64.dll");
			if (File.Exists(text))
			{
				return Path.GetFullPath(text);
			}
			Log.Msg("[SoftCam] Missing softcam64.dll at " + text);
			return null;
		}

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		internal static extern nint scCreateCamera(int width, int height, float framerate);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		internal static extern nint scCreateCameraEx(int width, int height, float framerate, int pixelFormat, int frameFlags);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		internal static extern void scDeleteCamera(nint camera);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		internal static extern void scSendFrame(nint camera, nint imageBits);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		internal static extern void scSendFrameEx(nint camera, nint imageBits, int sourceStride);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		[return: MarshalAs((UnmanagedType)2)]
		internal static extern bool scWaitForConnection(nint camera, float timeout);

		[DllImport("softcam64", CallingConvention = (CallingConvention)2)]
		[return: MarshalAs((UnmanagedType)2)]
		internal static extern bool scIsConnected(nint camera);
	}
	internal static class VBCable
	{
		private static readonly Guid CLSID_MMDeviceEnumerator = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");

		private static readonly Guid IID_IMMDeviceEnumerator = new Guid("A95664D2-9614-4F35-A746-DE8DB63617E6");

		[DllImport("ole32.dll")]
		private static extern int CoCreateInstance(ref Guid rclsid, nint pUnkOuter, uint dwClsContext, ref Guid riid, out nint ppv);

		internal static bool HasCableInputDevice()
		{
			try
			{
				return FindCableInputDeviceId() != null;
			}
			catch
			{
				return false;
			}
		}

		internal unsafe static string FindCableInputDeviceId()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: 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)
			Guid rclsid = CLSID_MMDeviceEnumerator;
			Guid riid = IID_IMMDeviceEnumerator;
			if (CoCreateInstance(ref rclsid, global::System.IntPtr.Zero, 1u, ref riid, out var ppv) < 0 || ppv == (nint)global::System.IntPtr.Zero)
			{
				return null;
			}
			try
			{
				nint num = default(nint);
				if (((delegate* unmanaged[Stdcall]<nint, int, uint, ref nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)ppv) + (nint)3 * (nint)sizeof(nint))))(ppv, 0, 1u, ref num) < 0 || num == (nint)global::System.IntPtr.Zero)
				{
					return null;
				}
				try
				{
					nint* ptr = *(nint**)num;
					uint num2 = default(uint);
					((delegate* unmanaged[Stdcall]<nint, ref uint, int>)ptr[3])(num, ref num2);
					nint num4 = default(nint);
					nint num6 = default(nint);
					nint num7 = default(nint);
					for (uint num3 = 0u; num3 < num2; num3++)
					{
						((delegate* unmanaged[Stdcall]<nint, uint, ref nint, int>)ptr[4])(num, num3, ref num4);
						if (num4 == (nint)global::System.IntPtr.Zero)
						{
							continue;
						}
						try
						{
							nint num5 = *(nint*)num4;
							((delegate* unmanaged[Stdcall]<nint, ref nint, int>)(*(global::System.IntPtr*)(num5 + (nint)5 * (nint)sizeof(nint))))(num4, ref num6);
							string result = Marshal.PtrToStringUni((global::System.IntPtr)num6);
							Marshal.FreeCoTaskMem((global::System.IntPtr)num6);
							((delegate* unmanaged[Stdcall]<nint, uint, ref nint, int>)(*(global::System.IntPtr*)(num5 + (nint)4 * (nint)sizeof(nint))))(num4, 0u, ref num7);
							if (num7 != (nint)global::System.IntPtr.Zero)
							{
								string deviceFriendlyName = GetDeviceFriendlyName(num7);
								Marshal.Release((global::System.IntPtr)num7);
								if (deviceFriendlyName != null && deviceFriendlyName.Contains("CABLE Input", (StringComparison)5))
								{
									return result;
								}
							}
						}
						finally
						{
							Marshal.Release((global::System.IntPtr)num4);
						}
					}
				}
				finally
				{
					Marshal.Release((global::System.IntPtr)num);
				}
			}
			finally
			{
				Marshal.Release((global::System.IntPtr)ppv);
			}
			return null;
		}

		private unsafe static string GetDeviceFriendlyName(nint propertyStore)
		{
			//IL_0013: 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)
			byte* ptr = stackalloc byte[20];
			Guid val = default(Guid);
			((Guid)(ref val))..ctor("A45C254E-DF1C-4EFD-8020-67D146A850E0");
			global::System.Runtime.CompilerServices.Unsafe.Write(ptr, val);
			((int*)ptr)[4] = 14;
			delegate* unmanaged[Stdcall]<nint, byte*, byte*, int> delegate* = (delegate* unmanaged[Stdcall]<nint, byte*, byte*, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)propertyStore) + (nint)5 * (nint)sizeof(nint)));
			byte* ptr2 = stackalloc byte[24];
			for (int i = 0; i < 24; i++)
			{
				ptr2[i] = 0;
			}
			if (delegate*(propertyStore, ptr, ptr2) < 0)
			{
				return null;
			}
			if (*(ushort*)ptr2 == 31)
			{
				return Marshal.PtrToStringUni(*(global::System.IntPtr*)(ptr2 + 8));
			}
			return null;
		}
	}
	internal sealed class VirtualCamera : global::System.IDisposable
	{
		private nint _camera;

		private int _width;

		private int _height;

		private byte[] _bgrBuffer;

		private GCHandle _pinnedBgr;

		private volatile bool _disposed;

		private Thread _connectionThread;

		private bool _extendedApiAvailable = true;

		private bool _usingExtendedApi;

		private int _pixelFormat;

		private int _frameFlags;

		internal bool _logNextFrame = true;

		private readonly bool _linux = DesktopBuddyPlatform.IsLinux;

		private readonly LinuxNativeBridge _linuxBridge = (DesktopBuddyPlatform.IsLinux ? new LinuxNativeBridge() : null);

		private int _v4l2Fd = -1;

		private const int IdleWidth = 1280;

		private const int IdleHeight = 720;

		private const int SoftcamPixelFormatBgr24 = 0;

		internal volatile bool ManuallyDisabled;

		[field: CompilerGenerated]
		internal bool ConsumerConnected
		{
			[CompilerGenerated]
			get;
			[CompilerGenerated]
			private set;
		}

		internal bool IsActive => _camera != (nint)global::System.IntPtr.Zero;

		internal bool StartIdle()
		{
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Expected O, but got Unknown
			if (_camera != (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			if (_linux)
			{
				try
				{
					_v4l2Fd = _linuxBridge.VcamOpen(1280, 720);
					if (_v4l2Fd < 0)
					{
						Log.Msg("[VirtualCamera] v4l2loopback 'DesktopBuddy - Camera' not found; run virtual camera setup in the Devices tab");
						return false;
					}
					_camera = 1;
					_width = 1280;
					_height = 720;
					_pixelFormat = 0;
					AllocBuffer(1280, 720);
					Log.Msg($"[VirtualCamera] v4l2 camera opened fd={_v4l2Fd} {1280}x{720}");
					_connectionThread = new Thread(new ThreadStart(ConnectionPollLoop))
					{
						Name = "VirtualCamera:Poll",
						IsBackground = true
					};
					_connectionThread.Start();
					return true;
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[VirtualCamera] Linux StartIdle failed: " + ex.Message);
					return false;
				}
			}
			try
			{
				_camera = CreateCamera(1280, 720, 0, 0);
				if (_camera == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg("[VirtualCamera] scCreateCamera returned null (another instance running?)");
					return false;
				}
				_width = 1280;
				_height = 720;
				if (!_usingExtendedApi || _pixelFormat == 0)
				{
					AllocBuffer(1280, 720);
				}
				Log.Msg($"[VirtualCamera] Idle camera created: {1280}x{720}");
				_connectionThread = new Thread(new ThreadStart(ConnectionPollLoop))
				{
					Name = "VirtualCamera:Poll",
					IsBackground = true
				};
				_connectionThread.Start();
				return true;
			}
			catch (global::System.Exception ex2)
			{
				Log.Msg("[VirtualCamera] StartIdle failed: " + ex2.Message);
				return false;
			}
		}

		private void ConnectionPollLoop()
		{
			while (!_disposed)
			{
				Thread.Sleep(500);
				if (_disposed || _camera == (nint)global::System.IntPtr.Zero)
				{
					break;
				}
				if (_linux)
				{
					ConsumerConnected = _v4l2Fd >= 0;
					continue;
				}
				try
				{
					ConsumerConnected = SoftCam.scIsConnected(_camera);
				}
				catch
				{
					ConsumerConnected = false;
				}
			}
		}

		internal unsafe void SendFrame(global::System.Span<byte> pixelData, int srcWidth, int srcHeight, TextureFormat format)
		{
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			if (_disposed || pixelData.Length == 0 || _camera == (nint)global::System.IntPtr.Zero)
			{
				return;
			}
			int num = srcWidth & -4;
			int num2 = srcHeight & -4;
			if (num < 4 || num2 < 4)
			{
				return;
			}
			if (_linux)
			{
				if (num != _width || num2 != _height)
				{
					_linuxBridge.VcamClose(_v4l2Fd);
					_v4l2Fd = _linuxBridge.VcamOpen(num, num2);
					if (_v4l2Fd < 0)
					{
						Log.Msg("[VirtualCamera] v4l2 reopen failed on resize");
						_camera = global::System.IntPtr.Zero;
						return;
					}
					_width = num;
					_height = num2;
					AllocBuffer(num, num2);
					_logNextFrame = true;
				}
				fixed (byte* src = pixelData)
				{
					fixed (byte* bgrBuffer = _bgrBuffer)
					{
						ConvertToBgr24(src, bgrBuffer, srcWidth, srcHeight, format);
					}
				}
				if (_linuxBridge.VcamWrite(_v4l2Fd, _bgrBuffer, _bgrBuffer.Length) < 0)
				{
					Log.Msg("[VirtualCamera] v4l2 write failed");
				}
				return;
			}
			int num3 = 0;
			int num4 = 0;
			if (num != _width || num2 != _height || num3 != _pixelFormat || num4 != _frameFlags)
			{
				Log.Msg($"[VirtualCamera] Resize/reformat {_width}x{_height}/{_pixelFormat}/{_frameFlags} -> {num}x{num2}/{num3}/{num4}");
				SoftCam.scDeleteCamera(_camera);
				_camera = CreateCamera(num, num2, num3, num4);
				if (_camera == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg("[VirtualCamera] Resize failed");
					return;
				}
				_width = num;
				_height = num2;
				if (!_usingExtendedApi || _pixelFormat == 0)
				{
					AllocBuffer(num, num2);
				}
				_logNextFrame = true;
			}
			fixed (byte* src2 = pixelData)
			{
				fixed (byte* bgrBuffer2 = _bgrBuffer)
				{
					ConvertToBgr24(src2, bgrBuffer2, srcWidth, srcHeight, format);
				}
			}
			try
			{
				SoftCam.scSendFrame(_camera, ((GCHandle)(ref _pinnedBgr)).AddrOfPinnedObject());
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[VirtualCamera] scSendFrame error: " + ex.Message);
			}
		}

		private nint CreateCamera(int width, int height, int pixelFormat, int frameFlags)
		{
			_pixelFormat = pixelFormat;
			_frameFlags = frameFlags;
			_usingExtendedApi = false;
			if (_extendedApiAvailable)
			{
				try
				{
					nint num = SoftCam.scCreateCameraEx(width, height, 0f, pixelFormat, frameFlags);
					if (num != (nint)global::System.IntPtr.Zero)
					{
						_usingExtendedApi = true;
						return num;
					}
				}
				catch (EntryPointNotFoundException)
				{
					_extendedApiAvailable = false;
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg("[VirtualCamera] scCreateCameraEx failed: " + ex2.Message);
				}
			}
			_pixelFormat = 0;
			_frameFlags = 0;
			return SoftCam.scCreateCamera(width, height, 0f);
		}

		private unsafe void ConvertToBgr24(byte* src, byte* dst, int w, int h, TextureFormat format)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Invalid comparison between Unknown and I4
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Invalid comparison between Unknown and I4
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Invalid comparison between Unknown and I4
			int width = _width;
			int height = _height;
			int num = width * 3;
			int num2 = (((int)format == 16) ? 3 : (((int)format == 25) ? 2 : 4));
			int num3 = w * num2;
			for (int i = 0; i < height; i++)
			{
				byte* ptr = src + (_linux ? i : (height - 1 - i)) * num3;
				byte* ptr2 = dst + i * num;
				if ((int)format == 17)
				{
					for (int j = 0; j < width; j++)
					{
						byte* ptr3 = ptr + j * 4;
						byte* num4 = ptr2 + j * 3;
						*num4 = ptr3[3];
						num4[1] = ptr3[2];
						num4[2] = ptr3[1];
					}
				}
				else if ((int)format == 19)
				{
					for (int k = 0; k < width; k++)
					{
						byte* ptr4 = ptr + k * 4;
						byte* num5 = ptr2 + k * 3;
						*num5 = *ptr4;
						num5[1] = ptr4[1];
						num5[2] = ptr4[2];
					}
				}
				else if ((int)format == 25)
				{
					ushort* ptr5 = (ushort*)ptr;
					for (int l = 0; l < width; l++)
					{
						ushort num6 = ptr5[l];
						byte* num7 = ptr2 + l * 3;
						*num7 = (byte)((num6 & 0x1F) * 255 / 31);
						num7[1] = (byte)(((num6 >> 5) & 0x3F) * 255 / 63);
						num7[2] = (byte)(((num6 >> 11) & 0x1F) * 255 / 31);
					}
				}
				else
				{
					for (int m = 0; m < width; m++)
					{
						byte* ptr6 = ptr + m * num2;
						byte* num8 = ptr2 + m * 3;
						*num8 = ptr6[2];
						num8[1] = ptr6[1];
						num8[2] = *ptr6;
					}
				}
			}
		}

		private void AllocBuffer(int w, int h)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (((GCHandle)(ref _pinnedBgr)).IsAllocated)
			{
				((GCHandle)(ref _pinnedBgr)).Free();
			}
			_bgrBuffer = new byte[w * h * 3];
			_pinnedBgr = GCHandle.Alloc((object)_bgrBuffer, (GCHandleType)3);
		}

		internal void Stop()
		{
			ManuallyDisabled = true;
			Log.Msg("[VirtualCamera] Rendering disabled");
		}

		public void Dispose()
		{
			if (_disposed)
			{
				return;
			}
			_disposed = true;
			if (_linux)
			{
				if (_v4l2Fd >= 0)
				{
					try
					{
						_linuxBridge.VcamClose(_v4l2Fd);
					}
					catch (global::System.Exception ex)
					{
						Log.Msg("[VirtualCamera] v4l2 close error: " + ex.Message);
					}
					_v4l2Fd = -1;
				}
				try
				{
					_linuxBridge?.Dispose();
				}
				catch
				{
				}
				_camera = global::System.IntPtr.Zero;
			}
			else if (_camera != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					SoftCam.scDeleteCamera(_camera);
				}
				catch (global::System.Exception ex2)
				{
					Log.Msg("[VirtualCamera] scDeleteCamera error: " + ex2.Message);
				}
				_camera = global::System.IntPtr.Zero;
			}
			if (((GCHandle)(ref _pinnedBgr)).IsAllocated)
			{
				((GCHandle)(ref _pinnedBgr)).Free();
			}
			_bgrBuffer = null;
			Log.Msg("[VirtualCamera] Disposed");
		}
	}
	internal sealed class VirtualMic : global::System.IDisposable
	{
		private static readonly Guid CLSID_MMDeviceEnumerator = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");

		private static readonly Guid IID_IMMDeviceEnumerator = new Guid("A95664D2-9614-4F35-A746-DE8DB63617E6");

		private static readonly Guid IID_IAudioClient = new Guid("1CB9AD4C-DBFA-4C32-B178-C2F568A703B2");

		private static readonly Guid IID_IAudioRenderClient = new Guid("F294ACFC-3146-4483-A7BF-ADDCA7C260E2");

		private const int AudioClient_Initialize = 3;

		private const int AudioClient_GetBufferSize = 4;

		private const int AudioClient_GetCurrentPadding = 6;

		private const int AudioClient_Start = 10;

		private const int AudioClient_Stop = 11;

		private const int AudioClient_SetEventHandle = 13;

		private const int AudioClient_GetService = 14;

		private const int AUDCLNT_STREAMFLAGS_EVENTCALLBACK = 262144;

		private const int RenderClient_GetBuffer = 3;

		private const int RenderClient_ReleaseBuffer = 4;

		private nint _audioClient;

		private nint _renderClient;

		private nint _renderEvent;

		private uint _bufferFrameCount;

		private Thread _renderThread;

		private volatile bool _disposed;

		private float[] _gameAudioRing;

		private long _gameAudioWritePos;

		private long _gameAudioReadPos;

		private const int GAME_RING_SAMPLES = 192000;

		private float[] _scratch;

		internal volatile bool Muted;

		internal bool IsActive => _renderClient != (nint)global::System.IntPtr.Zero;

		[DllImport("kernel32.dll")]
		private static extern nint CreateEventW(nint lpEventAttributes, bool bManualReset, bool bInitialState, nint lpName);

		[DllImport("kernel32.dll")]
		private static extern uint WaitForSingleObject(nint hHandle, uint dwMilliseconds);

		[DllImport("kernel32.dll")]
		private static extern bool CloseHandle(nint hObject);

		[DllImport("ole32.dll")]
		private static extern int CoCreateInstance(ref Guid rclsid, nint pUnkOuter, uint dwClsContext, ref Guid riid, out nint ppv);

		[DllImport("ole32.dll")]
		private static extern int CoInitializeEx(nint pvReserved, uint dwCoInit);

		internal unsafe bool Start()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Expected O, but got Unknown
			//IL_0557: Unknown result type (might be due to invalid IL or missing references)
			//IL_055c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Expected O, but got Unknown
			try
			{
				CoInitializeEx(global::System.IntPtr.Zero, 0u);
				string text = VBCable.FindCableInputDeviceId();
				if (text == null)
				{
					Log.Msg("[VirtualMic] CABLE Input device not found");
					return false;
				}
				Log.Msg("[VirtualMic] Opening device: " + text);
				Guid rclsid = CLSID_MMDeviceEnumerator;
				Guid riid = IID_IMMDeviceEnumerator;
				int num = CoCreateInstance(ref rclsid, global::System.IntPtr.Zero, 1u, ref riid, out var ppv);
				if (num < 0)
				{
					Log.Msg($"[VirtualMic] CoCreateInstance failed: 0x{num:X8}");
					return false;
				}
				Log.Msg("[VirtualMic] MMDeviceEnumerator created");
				try
				{
					nint num2 = *(nint*)ppv;
					nint num3 = Marshal.StringToCoTaskMemUni(text);
					nint num4 = default(nint);
					num = ((delegate* unmanaged[Stdcall]<nint, nint, ref nint, int>)(*(global::System.IntPtr*)(num2 + (nint)5 * (nint)sizeof(nint))))(ppv, num3, ref num4);
					Marshal.FreeCoTaskMem((global::System.IntPtr)num3);
					if (num < 0 || num4 == (nint)global::System.IntPtr.Zero)
					{
						Log.Msg($"[VirtualMic] GetDevice failed: 0x{num:X8}");
						return false;
					}
					Log.Msg("[VirtualMic] Device opened");
					try
					{
						delegate* unmanaged[Stdcall]<nint, Guid*, uint, nint, ref nint, int> delegate* = (delegate* unmanaged[Stdcall]<nint, Guid*, uint, nint, ref nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)num4) + (nint)3 * (nint)sizeof(nint)));
						Guid iID_IAudioClient = IID_IAudioClient;
						num = delegate*(num4, &iID_IAudioClient, 1u, global::System.IntPtr.Zero, ref _audioClient);
						if (num < 0 || _audioClient == (nint)global::System.IntPtr.Zero)
						{
							Log.Msg($"[VirtualMic] Activate IAudioClient failed: 0x{num:X8}");
							return false;
						}
						Log.Msg($"[VirtualMic] IAudioClient activated: 0x{_audioClient:X}");
					}
					finally
					{
						Marshal.Release((global::System.IntPtr)num4);
					}
				}
				finally
				{
					Marshal.Release((global::System.IntPtr)ppv);
				}
				byte* ptr = stackalloc byte[40];
				*(short*)ptr = -2;
				((short*)ptr)[1] = 2;
				((int*)ptr)[1] = 48000;
				((int*)ptr)[2] = 384000;
				((short*)ptr)[6] = 8;
				((short*)ptr)[7] = 32;
				((short*)ptr)[8] = 22;
				((short*)ptr)[9] = 32;
				((int*)ptr)[5] = 3;
				global::System.Runtime.CompilerServices.Unsafe.Write(ptr + 24, new Guid("00000003-0000-0010-8000-00aa00389b71"));
				nint* audioClient = *(nint**)_audioClient;
				num = ((delegate* unmanaged[Stdcall]<nint, int, uint, long, long, byte*, nint, int>)audioClient[3])(_audioClient, 0, 262144u, 200000L, 0L, ptr, global::System.IntPtr.Zero);
				if (num < 0)
				{
					Log.Msg($"[VirtualMic] IAudioClient::Initialize failed: 0x{num:X8}");
					Cleanup();
					return false;
				}
				Log.Msg("[VirtualMic] IAudioClient initialized (event mode)");
				_renderEvent = CreateEventW(global::System.IntPtr.Zero, bManualReset: false, bInitialState: false, global::System.IntPtr.Zero);
				num = ((delegate* unmanaged[Stdcall]<nint, nint, int>)audioClient[13])(_audioClient, _renderEvent);
				if (num < 0)
				{
					Log.Msg($"[VirtualMic] SetEventHandle failed: 0x{num:X8}");
					Cleanup();
					return false;
				}
				Log.Msg("[VirtualMic] WASAPI event handle set");
				num = ((delegate* unmanaged[Stdcall]<nint, ref uint, int>)audioClient[4])(_audioClient, ref _bufferFrameCount);
				if (num < 0)
				{
					Log.Msg($"[VirtualMic] GetBufferSize failed: 0x{num:X8}");
					Cleanup();
					return false;
				}
				Log.Msg($"[VirtualMic] Buffer size: {_bufferFrameCount} frames");
				delegate* unmanaged[Stdcall]<nint, Guid*, ref nint, int> delegate*2 = (delegate* unmanaged[Stdcall]<nint, Guid*, ref nint, int>)audioClient[14];
				Guid iID_IAudioRenderClient = IID_IAudioRenderClient;
				num = delegate*2(_audioClient, &iID_IAudioRenderClient, ref _renderClient);
				if (num < 0 || _renderClient == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg($"[VirtualMic] GetService IAudioRenderClient failed: 0x{num:X8}");
					Cleanup();
					return false;
				}
				Log.Msg($"[VirtualMic] IAudioRenderClient: 0x{_renderClient:X}");
				num = ((delegate* unmanaged[Stdcall]<nint, int>)audioClient[10])(_audioClient);
				if (num < 0)
				{
					Log.Msg($"[VirtualMic] IAudioClient::Start failed: 0x{num:X8}");
					Cleanup();
					return false;
				}
				Log.Msg("[VirtualMic] IAudioClient started");
				_gameAudioRing = new float[192000];
				_gameAudioWritePos = 0L;
				_gameAudioReadPos = 0L;
				_scratch = new float[_bufferFrameCount * 2];
				_renderThread = new Thread(new ThreadStart(RenderLoop))
				{
					Name = "VirtualMic:Render",
					IsBackground = true
				};
				_renderThread.Start();
				Log.Msg($"[VirtualMic] Started: 48kHz float32 stereo, buffer={_bufferFrameCount} frames");
				return true;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg($"[VirtualMic] Start failed: {ex}");
				Cleanup();
				return false;
			}
		}

		internal void WriteGameAudio(global::System.Span<float> samples)
		{
			if (!_disposed && !Muted && samples.Length != 0)
			{
				AudioRingBuffer.WriteLatest(samples, _gameAudioRing, ref _gameAudioWritePos);
			}
		}

		private int ReadGameAudio(float[] output, int maxSamples)
		{
			return AudioRingBuffer.Read(_gameAudioRing, Volatile.Read(ref _gameAudioWritePos), ref _gameAudioReadPos, output, maxSamples);
		}

		private unsafe void RenderLoop()
		{
			uint num = default(uint);
			nint num4 = default(nint);
			nint num6 = default(nint);
			while (!_disposed)
			{
				WaitForSingleObject(_renderEvent, 100u);
				if (_disposed || _renderClient == (nint)global::System.IntPtr.Zero)
				{
					break;
				}
				try
				{
					((delegate* unmanaged[Stdcall]<nint, ref uint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_audioClient) + (nint)6 * (nint)sizeof(nint))))(_audioClient, ref num);
					uint num2 = _bufferFrameCount - num;
					if (num2 == 0)
					{
						continue;
					}
					int maxSamples = (int)(num2 * 2);
					int num3 = ReadGameAudio(_scratch, maxSamples);
					if (num3 <= 0 || Muted)
					{
						nint* renderClient = *(nint**)_renderClient;
						if (((delegate* unmanaged[Stdcall]<nint, uint, ref nint, int>)renderClient[3])(_renderClient, num2, ref num4) >= 0)
						{
							((delegate* unmanaged[Stdcall]<nint, uint, uint, int>)renderClient[4])(_renderClient, num2, 2u);
						}
						continue;
					}
					uint num5 = (uint)(num3 / 2);
					nint* renderClient2 = *(nint**)_renderClient;
					if (((delegate* unmanaged[Stdcall]<nint, uint, ref nint, int>)renderClient2[3])(_renderClient, num5, ref num6) < 0)
					{
						continue;
					}
					fixed (float* scratch = _scratch)
					{
						Buffer.MemoryCopy((void*)scratch, (void*)num6, (long)(num5 * 2 * 4), (long)(num3 * 4));
					}
					((delegate* unmanaged[Stdcall]<nint, uint, uint, int>)renderClient2[4])(_renderClient, num5, 0u);
				}
				catch (global::System.Exception ex)
				{
					Log.Msg("[VirtualMic] Render error: " + ex.Message);
				}
			}
		}

		private unsafe void Cleanup()
		{
			if (_audioClient != (nint)global::System.IntPtr.Zero)
			{
				try
				{
					((delegate* unmanaged[Stdcall]<nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_audioClient) + (nint)11 * (nint)sizeof(nint))))(_audioClient);
				}
				catch
				{
				}
			}
			if (_renderClient != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)_renderClient);
				_renderClient = global::System.IntPtr.Zero;
			}
			if (_audioClient != (nint)global::System.IntPtr.Zero)
			{
				Marshal.Release((global::System.IntPtr)_audioClient);
				_audioClient = global::System.IntPtr.Zero;
			}
			if (_renderEvent != (nint)global::System.IntPtr.Zero)
			{
				CloseHandle(_renderEvent);
				_renderEvent = global::System.IntPtr.Zero;
			}
		}

		public void Dispose()
		{
			Log.Msg($"[CleanupTrace] VirtualMic.Dispose ENTER disposed={_disposed}");
			if (!_disposed)
			{
				_disposed = true;
				Log.Msg("[CleanupTrace] VirtualMic.Dispose renderThread.Join START");
				Thread renderThread = _renderThread;
				if (renderThread != null)
				{
					renderThread.Join(2000);
				}
				Log.Msg("[CleanupTrace] VirtualMic.Dispose renderThread.Join DONE");
				Log.Msg("[CleanupTrace] VirtualMic.Dispose Cleanup START");
				Cleanup();
				Log.Msg("[CleanupTrace] VirtualMic.Dispose Cleanup DONE");
				_scratch = null;
				_gameAudioRing = null;
				Log.Msg("[VirtualMic] Disposed");
				Log.Msg("[CleanupTrace] VirtualMic.Dispose EXIT");
			}
		}
	}
	internal static class AudioRouter
	{
		private const int VT_SetPersistedDefaultAudioEndpoint = 25;

		private const string DEVINTERFACE_AUDIO_RENDER = "#{e6327cad-dcec-4949-ae8a-991e976a79d2}";

		private const string MMDEVAPI_TOKEN = "\\\\?\\SWD#MMDEVAPI#";

		private static readonly Guid IID_IAudioPolicyConfig_Pre21H2 = new Guid("2A59116D-6C4F-45E0-A74F-707E3FEF9258");

		private static readonly Guid IID_IAudioPolicyConfig_21H2 = new Guid("AB3D4648-E242-459F-B02F-541C70306324");

		private static nint _factory;

		private static bool _initFailed;

		[DllImport("combase.dll")]
		private static extern int RoGetActivationFactory(nint activatableClassId, ref Guid iid, out nint factory);

		[DllImport("combase.dll")]
		private static extern int WindowsCreateString([MarshalAs((UnmanagedType)21)] string src, uint length, out nint hstring);

		[DllImport("combase.dll")]
		private static extern int WindowsDeleteString(nint hstring);

		internal static void PrewarmFactory()
		{
			EnsureFactory();
		}

		private static bool EnsureFactory()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (_factory != (nint)global::System.IntPtr.Zero)
			{
				return true;
			}
			if (_initFailed)
			{
				return false;
			}
			try
			{
				WindowsCreateString("Windows.Media.Internal.AudioPolicyConfig", (uint)"Windows.Media.Internal.AudioPolicyConfig".Length, out var hstring);
				Guid iid = IID_IAudioPolicyConfig_21H2;
				int num = RoGetActivationFactory(hstring, ref iid, out _factory);
				if (num < 0 || _factory == (nint)global::System.IntPtr.Zero)
				{
					iid = IID_IAudioPolicyConfig_Pre21H2;
					num = RoGetActivationFactory(hstring, ref iid, out _factory);
				}
				WindowsDeleteString(hstring);
				if (num < 0 || _factory == (nint)global::System.IntPtr.Zero)
				{
					Log.Msg($"[AudioRouter] RoGetActivationFactory failed: 0x{num:X8}");
					_initFailed = true;
					return false;
				}
				Log.Msg("[AudioRouter] IAudioPolicyConfig factory acquired");
				return true;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[AudioRouter] Init failed: " + ex.Message);
				_initFailed = true;
				return false;
			}
		}

		internal unsafe static void SetProcessOutputDevice(uint processId, string deviceEndpointId)
		{
			if (!EnsureFactory())
			{
				return;
			}
			try
			{
				nint hstring = global::System.IntPtr.Zero;
				if (!string.IsNullOrEmpty(deviceEndpointId))
				{
					string text = "\\\\?\\SWD#MMDEVAPI#" + deviceEndpointId + "#{e6327cad-dcec-4949-ae8a-991e976a79d2}";
					Log.Msg("[AudioRouter] Full device path: " + text);
					WindowsCreateString(text, (uint)text.Length, out hstring);
				}
				delegate* unmanaged[Stdcall]<nint, uint, int, int, nint, int> delegate* = (delegate* unmanaged[Stdcall]<nint, uint, int, int, nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_factory) + (nint)25 * (nint)sizeof(nint)));
				int num = delegate*(_factory, processId, 0, 0, hstring);
				int num2 = delegate*(_factory, processId, 0, 1, hstring);
				if (hstring != (nint)global::System.IntPtr.Zero)
				{
					WindowsDeleteString(hstring);
				}
				if (num < 0 || num2 < 0)
				{
					Log.Msg($"[AudioRouter] SetPersistedDefaultAudioEndpoint failed: console=0x{num:X8} multimedia=0x{num2:X8}");
				}
				else
				{
					Log.Msg($"[AudioRouter] Redirected PID {processId} to {deviceEndpointId}");
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[AudioRouter] SetProcessOutputDevice error: " + ex.Message);
			}
		}

		internal unsafe static void ResetProcessToDefault(uint processId)
		{
			if (!EnsureFactory())
			{
				return;
			}
			try
			{
				delegate* unmanaged[Stdcall]<nint, uint, int, int, nint, int> delegate* = (delegate* unmanaged[Stdcall]<nint, uint, int, int, nint, int>)(*(global::System.IntPtr*)((nint)(*(global::System.IntPtr*)_factory) + (nint)25 * (nint)sizeof(nint)));
				delegate*(_factory, processId, 0, 0, global::System.IntPtr.Zero);
				delegate*(_factory, processId, 0, 1, global::System.IntPtr.Zero);
				Log.Msg($"[AudioRouter] Reset PID {processId} to system default");
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[AudioRouter] ResetProcessToDefault error: " + ex.Message);
			}
		}
	}
	public static class WindowEnumerator
	{
		private delegate bool EnumWindowsProc(nint hWnd, nint lParam);

		public struct RECT
		{
			public int Left;

			public int Top;

			public int Right;

			public int Bottom;
		}

		public record WindowInfo(nint Handle, string Title, uint ProcessId)
		{
			[CompilerGenerated]
			protected virtual global::System.Type EqualityContract
			{
				[CompilerGenerated]
				get
				{
					return typeof(WindowInfo);
				}
			}

			[CompilerGenerated]
			public override string ToString()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Expected O, but got Unknown
				StringBuilder val = new StringBuilder();
				val.Append("WindowInfo");
				val.Append(" { ");
				if (PrintMembers(val))
				{
					val.Append(' ');
				}
				val.Append('}');
				return ((object)val).ToString();
			}

			[CompilerGenerated]
			protected virtual bool PrintMembers(StringBuilder builder)
			{
				RuntimeHelpers.EnsureSufficientExecutionStack();
				builder.Append("Handle = ");
				builder.Append(((object)Handle/*cast due to .constrained prefix*/).ToString());
				builder.Append(", Title = ");
				builder.Append((object)Title);
				builder.Append(", ProcessId = ");
				builder.Append(((object)ProcessId/*cast due to .constrained prefix*/).ToString());
				return true;
			}

			[CompilerGenerated]
			public virtual bool Equals(WindowInfo? other)
			{
				if ((object)this != other)
				{
					if ((object)other != null && EqualityContract == other.EqualityContract && EqualityComparer<nint>.Default.Equals(Handle, other.Handle) && EqualityComparer<string>.Default.Equals(Title, other.Title))
					{
						return EqualityComparer<uint>.Default.Equals(ProcessId, other.ProcessId);
					}
					return false;
				}
				return true;
			}
		}

		private const int DWMWA_CLOAKED = 14;

		private static readonly HashSet<string> _ignoredClasses;

		private const uint GW_OWNER = 4u;

		private const uint GA_ROOTOWNER = 3u;

		private const int GWL_STYLE = -16;

		private const int GWL_EXSTYLE = -20;

		private const long WS_CHILD = 1073741824L;

		private const long WS_EX_TOOLWINDOW = 128L;

		private const long WS_EX_APPWINDOW = 262144L;

		[ThreadStatic]
		private static StringBuilder _classBuf;

		[ThreadStatic]
		private static StringBuilder _titleBuf;

		[DllImport("user32.dll")]
		private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, nint lParam);

		[DllImport("user32.dll")]
		private static extern bool IsWindowVisible(nint hWnd);

		[DllImport("user32.dll")]
		private static extern bool IsWindow(nint hWnd);

		[DllImport("user32.dll", CharSet = (CharSet)3, SetLastError = true)]
		private static extern int GetWindowTextW(nint hWnd, StringBuilder lpString, int nMaxCount);

		[DllImport("user32.dll")]
		private static extern int GetWindowTextLength(nint hWnd);

		[DllImport("user32.dll")]
		public static extern uint GetWindowThreadProcessId(nint hWnd, out uint lpdwProcessId);

		[DllImport("user32.dll")]
		private static extern nint GetShellWindow();

		[DllImport("dwmapi.dll")]
		private static extern int DwmGetWindowAttribute(nint hwnd, int dwAttribute, out bool pvAttribute, int cbAttribute);

		[DllImport("user32.dll")]
		private static extern bool GetWindowRect(nint hWnd, out RECT lpRect);

		[DllImport("user32.dll", CharSet = (CharSet)3)]
		private static extern int GetClassNameW(nint hWnd, StringBuilder lpClassName, int nMaxCount);

		[DllImport("user32.dll")]
		private static extern nint GetWindow(nint hWnd, uint uCmd);

		[DllImport("user32.dll")]
		private static extern nint GetAncestor(nint hWnd, uint gaFlags);

		[DllImport("user32.dll", EntryPoint = "GetWindowLongPtrW", SetLastError = true)]
		private static extern nint GetWindowLongPtr64(nint hWnd, int nIndex);

		[DllImport("user32.dll", EntryPoint = "GetWindowLongW", SetLastError = true)]
		private static extern int GetWindowLong32(nint hWnd, int nIndex);

		public static bool IsResoniteWindow(string title)
		{
			if (string.IsNullOrEmpty(title))
			{
				return false;
			}
			if (!title.Equals("Resonite", (StringComparison)5))
			{
				return title.StartsWith("Resonite ", (StringComparison)5);
			}
			return true;
		}

		public static List<WindowInfo> GetOpenWindows()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			List<WindowInfo> windows = new List<WindowInfo>();
			nint shellWindow = GetShellWindow();
			if (_titleBuf == null)
			{
				_titleBuf = new StringBuilder(256);
			}
			EnumWindows(delegate(nint hWnd, nint _)
			{
				if (hWnd == shellWindow)
				{
					return true;
				}
				if (!IsWindowVisible(hWnd))
				{
					return true;
				}
				DwmGetWindowAttribute(hWnd, 14, out var pvAttribute, Marshal.SizeOf<bool>());
				if (pvAttribute)
				{
					return true;
				}
				int windowTextLength = GetWindowTextLength(hWnd);
				if (windowTextLength == 0)
				{
					return true;
				}
				_titleBuf.Clear().EnsureCapacity(windowTextLength + 1);
				GetWindowTextW(hWnd, _titleBuf, _titleBuf.Capacity);
				string text = ((object)_titleBuf).ToString();
				if (string.IsNullOrWhiteSpace(text))
				{
					return true;
				}
				if (!IsStandaloneTopLevelWindow(hWnd))
				{
					return true;
				}
				GetWindowThreadProcessId(hWnd, out var lpdwProcessId);
				windows.Add(new WindowInfo(hWnd, text, lpdwProcessId));
				return true;
			}, global::System.IntPtr.Zero);
			return windows;
		}

		public static List<WindowInfo> GetProcessWindows(uint processId)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			List<WindowInfo> windows = new List<WindowInfo>();
			nint shellWindow = GetShellWindow();
			if (_classBuf == null)
			{
				_classBuf = new StringBuilder(64);
			}
			if (_titleBuf == null)
			{
				_titleBuf = new StringBuilder(256);
			}
			EnumWindows(delegate(nint hWnd, nint _)
			{
				if (hWnd == shellWindow)
				{
					return true;
				}
				if (!IsWindowVisible(hWnd))
				{
					return true;
				}
				GetWindowThreadProcessId(hWnd, out var lpdwProcessId);
				if (lpdwProcessId != processId)
				{
					return true;
				}
				DwmGetWindowAttribute(hWnd, 14, out var pvAttribute, Marshal.SizeOf<bool>());
				if (pvAttribute)
				{
					return true;
				}
				_classBuf.Clear();
				GetClassNameW(hWnd, _classBuf, _classBuf.Capacity);
				if (_ignoredClasses.Contains(((object)_classBuf).ToString()))
				{
					return true;
				}
				if (!IsStandaloneTopLevelWindow(hWnd))
				{
					return true;
				}
				int windowTextLength = GetWindowTextLength(hWnd);
				string title = "";
				if (windowTextLength > 0)
				{
					_titleBuf.Clear().EnsureCapacity(windowTextLength + 1);
					GetWindowTextW(hWnd, _titleBuf, _titleBuf.Capacity);
					title = ((object)_titleBuf).ToString();
				}
				windows.Add(new WindowInfo(hWnd, title, lpdwProcessId));
				return true;
			}, global::System.IntPtr.Zero);
			return windows;
		}

		public static bool IsStandaloneTopLevelWindow(nint hwnd)
		{
			if (hwnd == (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			if (!IsWindow(hwnd))
			{
				return false;
			}
			if (!IsWindowVisible(hwnd))
			{
				return false;
			}
			long num = ((global::System.IntPtr)GetWindowLongPtr(hwnd, -16)).ToInt64();
			long num2 = ((global::System.IntPtr)GetWindowLongPtr(hwnd, -20)).ToInt64();
			if ((num & 0x40000000) != 0L)
			{
				return false;
			}
			if (GetWindow(hwnd, 4u) != (nint)global::System.IntPtr.Zero)
			{
				return false;
			}
			nint ancestor = GetAncestor(hwnd, 3u);
			if (ancestor != (nint)global::System.IntPtr.Zero && ancestor != hwnd)
			{
				return false;
			}
			bool flag = (num2 & 0x80) != 0;
			bool flag2 = (num2 & 0x40000) != 0;
			if (flag && !flag2)
			{
				return false;
			}
			return true;
		}

		public static bool TryValidateStandaloneProcessWindow(nint hwnd, uint expectedProcessId, out string title, out string reason)
		{
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			title = "";
			reason = "";
			if (hwnd == (nint)global::System.IntPtr.Zero)
			{
				reason = "zero hwnd";
				return false;
			}
			if (!IsWindow(hwnd))
			{
				reason = "invalid hwnd";
				return false;
			}
			if (!IsWindowVisible(hwnd))
			{
				reason = "not visible";
				return false;
			}
			GetWindowThreadProcessId(hwnd, out var lpdwProcessId);
			if (expectedProcessId != 0 && lpdwProcessId != expectedProcessId)
			{
				reason = $"pid mismatch expected={expectedProcessId} actual={lpdwProcessId}";
				return false;
			}
			DwmGetWindowAttribute(hwnd, 14, out var pvAttribute, Marshal.SizeOf<bool>());
			if (pvAttribute)
			{
				reason = "cloaked";
				return false;
			}
			if (!IsStandaloneTopLevelWindow(hwnd))
			{
				reason = "not standalone top-level";
				return false;
			}
			int windowTextLength = GetWindowTextLength(hwnd);
			if (windowTextLength > 0)
			{
				if (_titleBuf == null)
				{
					_titleBuf = new StringBuilder(256);
				}
				_titleBuf.Clear().EnsureCapacity(windowTextLength + 1);
				GetWindowTextW(hwnd, _titleBuf, _titleBuf.Capacity);
				title = ((object)_titleBuf).ToString();
			}
			return true;
		}

		private static nint GetWindowLongPtr(nint hwnd, int index)
		{
			if (global::System.IntPtr.Size != 8)
			{
				return new global::System.IntPtr(GetWindowLong32(hwnd, index));
			}
			return GetWindowLongPtr64(hwnd, index);
		}

		public static bool TryGetWindowRect(nint hwnd, out int x, out int y, out int width, out int height)
		{
			if (GetWindowRect(hwnd, out var lpRect))
			{
				x = lpRect.Left;
				y = lpRect.Top;
				width = lpRect.Right - lpRect.Left;
				height = lpRect.Bottom - lpRect.Top;
				return true;
			}
			x = (y = (width = (height = 0)));
			return false;
		}

		static WindowEnumerator()
		{
			HashSet<string> obj = new HashSet<string>((IEqualityComparer<string>)(object)StringComparer.OrdinalIgnoreCase);
			obj.Add("Shell_TrayWnd");
			obj.Add("Shell_SecondaryTrayWnd");
			obj.Add("Progman");
			obj.Add("WorkerW");
			obj.Add("NotifyIconOverflowWindow");
			obj.Add("Windows.UI.Core.CoreWindow");
			_ignoredClasses = obj;
		}
	}
	public static class WindowIconExtractor
	{
		private struct ICONINFO
		{
			public bool fIcon;

			public int xHotspot;

			public int yHotspot;

			public nint hbmMask;

			public nint hbmColor;
		}

		private struct BITMAP
		{
			public int bmType;

			public int bmWidth;

			public int bmHeight;

			public int bmWidthBytes;

			public ushort bmPlanes;

			public ushort bmBitsPixel;

			public nint bmBits;
		}

		private struct BITMAPINFOHEADER
		{
			public uint biSize;

			public int biWidth;

			public int biHeight;

			public ushort biPlanes;

			public ushort biBitCount;

			public uint biCompression;

			public uint biSizeImage;

			public int biXPelsPerMeter;

			public int biYPelsPerMeter;

			public uint biClrUsed;

			public uint biClrImportant;
		}

		private struct BITMAPINFO
		{
			public BITMAPINFOHEADER bmiHeader;
		}

		private const uint SMTO_ABORTIFHUNG = 2u;

		private const uint PROCESS_QUERY_LIMITED_INFORMATION = 4096u;

		private const uint WM_GETICON = 127u;

		private const int ICON_BIG = 1;

		private const int ICON_SMALL2 = 2;

		private const int GCL_HICON = -14;

		private const int GCL_HICONSM = -34;

		[DllImport("user32.dll")]
		private static extern nint SendMessageTimeoutW(nint hWnd, uint Msg, nint wParam, nint lParam, uint fuFlags, uint uTimeout, out nint lpdwResult);

		[DllImport("user32.dll")]
		private static extern nint GetClassLongPtr(nint hWnd, int nIndex);

		[DllImport("user32.dll")]
		private static extern bool GetIconInfo(nint hIcon, out ICONINFO piconinfo);

		[DllImport("gdi32.dll")]
		private static extern int GetObject(nint hgdiobj, int cbBuffer, ref BITMAP lpvObject);

		[DllImport("gdi32.dll")]
		private static extern int GetDIBits(nint hdc, nint hbmp, uint uStartScan, uint cScanLines, byte[] lpvBits, ref BITMAPINFO lpbi, uint uUsage);

		[DllImport("gdi32.dll")]
		private static extern nint CreateCompatibleDC(nint hdc);

		[DllImport("gdi32.dll")]
		private static extern bool DeleteDC(nint hdc);

		[DllImport("gdi32.dll")]
		private static extern bool DeleteObject(nint hObject);

		[DllImport("user32.dll")]
		private static extern bool DestroyIcon(nint hIcon);

		[DllImport("user32.dll")]
		private static extern uint GetWindowThreadProcessId(nint hWnd, out uint lpdwProcessId);

		[DllImport("kernel32.dll")]
		private static extern nint OpenProcess(uint dwDesiredAccess, bool bInheritHandle, uint dwProcessId);

		[DllImport("kernel32.dll", CharSet = (CharSet)3)]
		private static extern bool QueryFullProcessImageNameW(nint hProcess, uint dwFlags, StringBuilder lpExeName, ref uint lpdwSize);

		[DllImport("kernel32.dll")]
		private static extern bool CloseHandle(nint hObject);

		public static byte[] GetIconRGBA(nint hwnd, out int width, out int height)
		{
			width = (height = 0);
			nint lpdwResult = global::System.IntPtr.Zero;
			Stopwatch val = Stopwatch.StartNew();
			if (SendMessageTimeoutW(hwnd, 127u, 1, global::System.IntPtr.Zero, 2u, 200u, out lpdwResult) == (nint)global::System.IntPtr.Zero && lpdwResult == (nint)global::System.IntPtr.Zero)
			{
				long elapsedMilliseconds = val.ElapsedMilliseconds;
				if (elapsedMilliseconds >= 180)
				{
					GetWindowThreadProcessId(hwnd, out var lpdwProcessId);
					string text = "unknown";
					try
					{
						Process processById = Process.GetProcessById((int)lpdwProcessId);
						text = ((processById != null) ? processById.ProcessName : null) ?? "unknown";
					}
					catch (global::System.Exception ex)
					{
						Log.Msg($"[IconExtractor] Process name lookup failed for pid={lpdwProcessId}: {ex.Message}");
					}
					Log.Msg($"[IconExtractor] WM_GETICON timed out after {elapsedMilliseconds}ms for hwnd={hwnd} pid={lpdwProcessId} process={text}");
				}
				SendMessageTimeoutW(hwnd, 127u, 2, global::System.IntPtr.Zero, 2u, 200u, out lpdwResult);
			}
			if (lpdwResult == (nint)global::System.IntPtr.Zero)
			{
				lpdwResult = GetClassLongPtr(hwnd, -14);
			}
			if (lpdwResult == (nint)global::System.IntPtr.Zero)
			{
				lpdwResult = GetClassLongPtr(hwnd, -34);
			}
			if (lpdwResult == (nint)global::System.IntPtr.Zero)
			{
				return null;
			}
			return ExtractIconPixels(lpdwResult, out width, out height, destroyIcon: false);
		}

		public static string GetExecutablePath(nint hwnd)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			if (hwnd == (nint)global::System.IntPtr.Zero)
			{
				return null;
			}
			try
			{
				GetWindowThreadProcessId(hwnd, out var lpdwProcessId);
				if (lpdwProcessId == 0)
				{
					return null;
				}
				nint num = OpenProcess(4096u, bInheritHandle: false, lpdwProcessId);
				if (num == (nint)global::System.IntPtr.Zero)
				{
					return null;
				}
				try
				{
					StringBuilder val = new StringBuilder(1024);
					uint lpdwSize = (uint)val.Capacity;
					return (QueryFullProcessImageNameW(num, 0u, val, ref lpdwSize) && lpdwSize != 0) ? ((object)val).ToString() : null;
				}
				finally
				{
					CloseHandle(num);
				}
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[IconExtractor] Executable path error: " + ex.Message);
				return null;
			}
		}

		private static byte[] ExtractIconPixels(nint hIcon, out int width, out int height, bool destroyIcon)
		{
			width = (height = 0);
			if (hIcon == (nint)global::System.IntPtr.Zero)
			{
				return null;
			}
			if (!GetIconInfo(hIcon, out var piconinfo))
			{
				if (destroyIcon)
				{
					DestroyIcon(hIcon);
				}
				return null;
			}
			try
			{
				if (piconinfo.hbmColor == (nint)global::System.IntPtr.Zero)
				{
					return null;
				}
				BITMAP lpvObject = default(BITMAP);
				GetObject(piconinfo.hbmColor, Marshal.SizeOf<BITMAP>(), ref lpvObject);
				if (lpvObject.bmWidth <= 0 || lpvObject.bmHeight <= 0)
				{
					return null;
				}
				width = lpvObject.bmWidth;
				height = lpvObject.bmHeight;
				BITMAPINFO lpbi = new BITMAPINFO
				{
					bmiHeader = new BITMAPINFOHEADER
					{
						biSize = (uint)Marshal.SizeOf<BITMAPINFOHEADER>(),
						biWidth = width,
						biHeight = -height,
						biPlanes = 1,
						biBitCount = 32,
						biCompression = 0u
					}
				};
				byte[] array = new byte[width * height * 4];
				nint hdc = CreateCompatibleDC(global::System.IntPtr.Zero);
				try
				{
					GetDIBits(hdc, piconinfo.hbmColor, 0u, (uint)height, array, ref lpbi, 0u);
				}
				finally
				{
					DeleteDC(hdc);
				}
				for (int i = 0; i < array.Length; i += 4)
				{
					byte b = array[i];
					array[i] = array[i + 2];
					array[i + 2] = b;
				}
				return array;
			}
			finally
			{
				if (piconinfo.hbmColor != (nint)global::System.IntPtr.Zero)
				{
					DeleteObject(piconinfo.hbmColor);
				}
				if (piconinfo.hbmMask != (nint)global::System.IntPtr.Zero)
				{
					DeleteObject(piconinfo.hbmMask);
				}
				if (destroyIcon)
				{
					DestroyIcon(hIcon);
				}
			}
		}
	}
	internal static class WindowVolume
	{
		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int GetDefaultAudioEndpointDelegate(nint self, int dataFlow, int role, out nint device);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int ActivateDelegate(nint self, ref Guid iid, uint clsCtx, nint activationParams, out nint obj);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int GetSessionEnumeratorDelegate(nint self, out nint enumerator);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int GetCountDelegate(nint self, out int count);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int GetSessionDelegate(nint self, int index, out nint session);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int GetProcessIdDelegate(nint self, out uint pid);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int SetMasterVolumeDelegate(nint self, float level, ref Guid eventContext);

		[UnmanagedFunctionPointer(/*Could not decode attribute arguments.*/)]
		private delegate int SetMasterVolumeLevelScalarDelegate(nint self, float level, ref Guid eventContext);

		private static readonly Guid CLSID_MMDeviceEnumerator = new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E");

		private static readonly Guid IID_IMMDeviceEnumerator = new Guid("A95664D2-9614-4F35-A746-DE8DB63617E6");

		private static readonly Guid IID_IAudioSessionManager2 = new Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F");

		private static readonly Guid IID_IAudioEndpointVolume = new Guid("5CDF2C82-841E-4546-9722-0CF74078229A");

		private static readonly Guid IID_ISimpleAudioVolume = new Guid("87CE5498-68D6-44E5-9215-6DA47EF883D8");

		private static readonly Guid IID_IAudioSessionControl2 = new Guid("BFB7FF88-7239-4FC9-8FA2-07C950BE9C6D");

		[DllImport("ole32.dll")]
		private static extern int CoCreateInstance(ref Guid clsid, nint outer, uint clsCtx, ref Guid iid, out nint obj);

		public static bool SetProcessVolume(uint processId, float volume)
		{
			//IL_002a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			volume = Math.Clamp(volume, 0f, 1f);
			nint obj = global::System.IntPtr.Zero;
			nint device = global::System.IntPtr.Zero;
			nint obj2 = global::System.IntPtr.Zero;
			nint enumerator = global::System.IntPtr.Zero;
			try
			{
				Guid clsid = CLSID_MMDeviceEnumerator;
				Guid iid = IID_IMMDeviceEnumerator;
				int num = CoCreateInstance(ref clsid, global::System.IntPtr.Zero, 23u, ref iid, out obj);
				if (num < 0)
				{
					Log.Msg($"[WindowVolume] CoCreateInstance failed: 0x{num:X8}");
					return false;
				}
				num = VTable<GetDefaultAudioEndpointDelegate>(obj, 4)(obj, 0, 1, out device);
				if (num < 0)
				{
					return false;
				}
				Guid iid2 = IID_IAudioSessionManager2;
				num = VTable<ActivateDelegate>(device, 3)(device, ref iid2, 23u, global::System.IntPtr.Zero, out obj2);
				if (num < 0)
				{
					return false;
				}
				num = VTable<GetSessionEnumeratorDelegate>(obj2, 5)(obj2, out enumerator);
				if (num < 0)
				{
					return false;
				}
				num = VTable<GetCountDelegate>(enumerator, 3)(enumerator, out var count);
				if (num < 0)
				{
					return false;
				}
				string text = null;
				try
				{
					text = Process.GetProcessById((int)processId).ProcessName.ToLowerInvariant();
				}
				catch (global::System.Exception ex)
				{
					Log.Msg($"[WindowVolume] Process name lookup failed for pid={processId}: {ex.Message}");
				}
				for (int i = 0; i < count; i++)
				{
					nint session = global::System.IntPtr.Zero;
					nint zero = global::System.IntPtr.Zero;
					nint zero2 = global::System.IntPtr.Zero;
					try
					{
						num = VTable<GetSessionDelegate>(enumerator, 4)(enumerator, i, out session);
						if (num < 0 || session == (nint)global::System.IntPtr.Zero)
						{
							continue;
						}
						Guid iID_IAudioSessionControl = IID_IAudioSessionControl2;
						num = Marshal.QueryInterface((global::System.IntPtr)session, ref iID_IAudioSessionControl, ref zero);
						if (num < 0 || zero == (nint)global::System.IntPtr.Zero)
						{
							continue;
						}
						num = VTable<GetProcessIdDelegate>(zero, 14)(zero, out var pid);
						if (num < 0 || pid == 0)
						{
							continue;
						}
						bool flag = pid == processId;
						if (!flag && text != null)
						{
							try
							{
								flag = Process.GetProcessById((int)pid).ProcessName.ToLowerInvariant() == text;
							}
							catch (global::System.Exception ex2)
							{
								Log.Msg($"[WindowVolume] Process match check failed for pid={pid}: {ex2.Message}");
							}
						}
						if (!flag)
						{
							continue;
						}
						Guid iID_ISimpleAudioVolume = IID_ISimpleAudioVolume;
						num = Marshal.QueryInterface((global::System.IntPtr)session, ref iID_ISimpleAudioVolume, ref zero2);
						if (num >= 0 && zero2 != (nint)global::System.IntPtr.Zero)
						{
							Guid eventContext = Guid.Empty;
							num = VTable<SetMasterVolumeDelegate>(zero2, 3)(zero2, volume, ref eventContext);
							if (num >= 0)
							{
								return true;
							}
						}
					}
					finally
					{
						if (zero2 != (nint)global::System.IntPtr.Zero)
						{
							Marshal.Release((global::System.IntPtr)zero2);
						}
						if (zero != (nint)global::System.IntPtr.Zero)
						{
							Marshal.Release((global::System.IntPtr)zero);
						}
						if (session != (nint)global::System.IntPtr.Zero)
						{
							Marshal.Release((global::System.IntPtr)session);
						}
					}
				}
			}
			catch (global::System.Exception ex3)
			{
				Log.Msg("[WindowVolume] SetProcessVolume failed: " + ex3.Message);
			}
			finally
			{
				if (enumerator != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)enumerator);
				}
				if (obj2 != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)obj2);
				}
				if (device != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)device);
				}
				if (obj != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)obj);
				}
			}
			return false;
		}

		public static bool SetMasterVolume(float volume)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			volume = Math.Clamp(volume, 0f, 1f);
			nint obj = global::System.IntPtr.Zero;
			nint device = global::System.IntPtr.Zero;
			nint obj2 = global::System.IntPtr.Zero;
			try
			{
				Guid clsid = CLSID_MMDeviceEnumerator;
				Guid iid = IID_IMMDeviceEnumerator;
				if (CoCreateInstance(ref clsid, global::System.IntPtr.Zero, 23u, ref iid, out obj) < 0)
				{
					return false;
				}
				if (VTable<GetDefaultAudioEndpointDelegate>(obj, 4)(obj, 0, 1, out device) < 0)
				{
					return false;
				}
				Guid iid2 = IID_IAudioEndpointVolume;
				if (VTable<ActivateDelegate>(device, 3)(device, ref iid2, 23u, global::System.IntPtr.Zero, out obj2) < 0)
				{
					return false;
				}
				Guid eventContext = Guid.Empty;
				return VTable<SetMasterVolumeLevelScalarDelegate>(obj2, 7)(obj2, volume, ref eventContext) >= 0;
			}
			catch (global::System.Exception ex)
			{
				Log.Msg("[WindowVolume] SetMasterVolume failed: " + ex.Message);
			}
			finally
			{
				if (obj2 != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)obj2);
				}
				if (device != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)device);
				}
				if (obj != (nint)global::System.IntPtr.Zero)
				{
					Marshal.Release((global::System.IntPtr)obj);
				}
			}
			return false;
		}

		private static T VTable<T>(nint comObj, int slot) where T : global::System.Delegate
		{
			return Marshal.GetDelegateForFunctionPointer<T>(Marshal.ReadIntPtr(Marshal.ReadIntPtr((global::System.IntPtr)comObj), slot * global::System.IntPtr.Size));
		}
	}
	public static class PluginMetadata
	{
		public const string GUID = "DesktopBuddy";

		public const string NAME = "DesktopBuddy";

		public const string VERSION = "1.0.0";

		public const string AUTHORS = "DesktopBuddy";

		public const string REPOSITORY_URL = "";
	}
	internal static class BuildInfo
	{
		internal const string GitSha = "e5251e3";
	}
	internal static class DesktopBuddyVersionInfo
	{
		internal const string Version = "1.1.0";
	}
}
namespace DesktopBuddy.Shared
{
	internal static class SharedTextureBridgeProtocol
	{
		private const string BaseOwnerId = "DesktopBuddy.SharedTexture.v2";

		private const string BaseQueueName = "DesktopBuddy.SharedTexture.v2";

		private static readonly string QueueScope = GetQueueScope();

		public static readonly string OwnerId = GetScopedName("DesktopBuddy.SharedTexture.v2");

		public static readonly string QueueName = GetScopedName("DesktopBuddy.SharedTexture.v2");

		public const string StartMessageId = "Start";

		public const string StopMessageId = "Stop";

		public const string RunningMessageId = "Running";

		public const string StoppedMessageId = "Stopped";

		public const string RendererDeviceMessageId = "RendererDevice";

		public const int MaxTextureSlots = 4096;

		public const int MagicIndexBase = 10000;

		private static string GetScopedName(string baseName)
		{
			if (!string.IsNullOrEmpty(QueueScope))
			{
				return baseName + "." + QueueScope;
			}
			return baseName;
		}

		private static string GetQueueScope()
		{
			string text = GetArgumentValue("-shmprefix") ?? GetArgumentValue("--shmprefix");
			if (string.IsNullOrWhiteSpace(text))
			{
				return string.Empty;
			}
			return "shm" + ComputeStableHash(text).ToString("X16");
		}

		private static string GetArgumentValue(string name)
		{
			string[] commandLineArgs;
			try
			{
				commandLineArgs = Environment.GetCommandLineArgs();
			}
			catch
			{
				return null;
			}
			for (int i = 0; i < commandLineArgs.Length; i++)
			{
				string text = commandLineArgs[i];
				if (text == null)
				{
					continue;
				}
				if (string.Equals(text, name, (StringComparison)5))
				{
					if (i + 1 < commandLineArgs.Length)
					{
						return commandLineArgs[i + 1];
					}
					return null;
				}
				string text2 = name + "=";
				if (text.StartsWith(text2, (StringComparison)5))
				{
					return text.Substring(text2.Length);
				}
			}
			return null;
		}

		private static ulong ComputeStableHash(string value)
		{
			ulong num = 14695981039346656037uL;
			for (int i = 0; i < value.Length; i++)
			{
				num ^= value[i];
				num *= 1099511628211L;
			}
			return num;
		}
	}
	internal sealed class SimpleMemoryPackerPool : IMemoryPackerEntityPool
	{
		public static readonly SimpleMemoryPackerPool Instance = new SimpleMemoryPackerPool();

		private SimpleMemoryPackerPool()
		{
		}

		T IMemoryPackerEntityPool.Borrow<T>()
		{
			return new T();
		}

		void IMemoryPackerEntityPool.Return<T>(T value)
		{
		}
	}
	internal sealed class SharedTextureStartMessage : IMemoryPackable
	{
		public int SlotId;

		public int Generation;

		public long SharedTextureHandle;

		public string SharedTextureName;

		public int SharedTextureWidth;

		public int SharedTextureHeight;

		public void Pack(ref MemoryPacker packer)
		{
			((MemoryPacker)(ref packer)).Write<int>(SlotId);
			((MemoryPacker)(ref packer)).Write<int>(Generation);
			((MemoryPacker)(ref packer)).Write<long>(SharedTextureHandle);
			((MemoryPacker)(ref packer)).Write(SharedTextureName);
			((MemoryPacker)(ref packer)).Write<int>(SharedTextureWidth);
			((MemoryPacker)(ref packer)).Write<int>(SharedTextureHeight);
		}

		public void Unpack(ref MemoryUnpacker unpacker)
		{
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SlotId);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Generation);
			((MemoryUnpacker)(ref unpacker)).Read<long>(ref SharedTextureHandle);
			((MemoryUnpacker)(ref unpacker)).Read(ref SharedTextureName);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SharedTextureWidth);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SharedTextureHeight);
		}
	}
	internal sealed class SharedTextureStopMessage : IMemoryPackable
	{
		public int SlotId;

		public int Generation;

		public void Pack(ref MemoryPacker packer)
		{
			((MemoryPacker)(ref packer)).Write<int>(SlotId);
			((MemoryPacker)(ref packer)).Write<int>(Generation);
		}

		public void Unpack(ref MemoryUnpacker unpacker)
		{
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SlotId);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Generation);
		}
	}
	internal sealed class SharedTextureRunningMessage : IMemoryPackable
	{
		public int SlotId;

		public int Generation;

		public int Width;

		public int Height;

		public void Pack(ref MemoryPacker packer)
		{
			((MemoryPacker)(ref packer)).Write<int>(SlotId);
			((MemoryPacker)(ref packer)).Write<int>(Generation);
			((MemoryPacker)(ref packer)).Write<int>(Width);
			((MemoryPacker)(ref packer)).Write<int>(Height);
		}

		public void Unpack(ref MemoryUnpacker unpacker)
		{
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SlotId);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Generation);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Width);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Height);
		}
	}
	internal sealed class SharedTextureStoppedMessage : IMemoryPackable
	{
		public int SlotId;

		public int Generation;

		public void Pack(ref MemoryPacker packer)
		{
			((MemoryPacker)(ref packer)).Write<int>(SlotId);
			((MemoryPacker)(ref packer)).Write<int>(Generation);
		}

		public void Unpack(ref MemoryUnpacker unpacker)
		{
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref SlotId);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref Generation);
		}
	}
	internal sealed class SharedTextureRendererDeviceMessage : IMemoryPackable
	{
		public long AdapterLuid;

		public int VendorId;

		public string Description;

		public void Pack(ref MemoryPacker packer)
		{
			((MemoryPacker)(ref packer)).Write<long>(AdapterLuid);
			((MemoryPacker)(ref packer)).Write<int>(VendorId);
			((MemoryPacker)(ref packer)).Write(Description);
		}

		public void Unpack(ref MemoryUnpacker unpacker)
		{
			((MemoryUnpacker)(ref unpacker)).Read<long>(ref AdapterLuid);
			((MemoryUnpacker)(ref unpacker)).Read<int>(ref VendorId);
			((MemoryUnpacker)(ref unpacker)).Read(ref Description);
		}
	}
}