Linux: SteamVR overlay support (#1299)

* fix: open folder and select item on linux

* feat: linux wrist overlay

* feat: linux hmd overlay

* feat: replace unix sockets with shm on linux

* fix: reduce linux wrist overlay fps

* fix: hide electron offscreen windows

* fix: destroy electron offscreen windows when not in use

* fix: open folder and select item on linux

* feat: cpu, uptime and device monitoring on linux

* feat: native wayland gl context with x11 fallback on linux

* fix: use platform agnostic wording for common folders

* fix: crash dumps folder button on linux

* fix: enable missing VR notification options on linux

* fix: update cef, eslint config to include updated AppApiVr names

* merge: rebase linux VR changes to upstream

* Clean up

* Load custom file contents rather than path

Fixes loading custom file in debug mode

* fix: call SetVR on linux as well

* fix: AppApiVrElectron init, properly create and dispose of shm

* Handle avatar history error

* Lint

* Change overlay dispose logic

* macOS DOTNET_ROOT

* Remove moving dotnet bin

* Fix

* fix: init overlay on SteamVR restart

* Fix fetching empty instance, fix user dialog not fetching

* Trim direct access inputs

* Make icon higher res, because mac build would fail 😂

* macOS fixes

* will it build? that's the question

* fix: ensure offscreen windows are ready before vrinit

* will it build? that's the question

* will it build? that's the question

* meow

* one, more, time

* Fix crash and overlay ellipsis

* a

---------

Co-authored-by: Natsumi <cmcooper123@hotmail.com>

Dotnet/Overlay/Cef/OffScreenBrowser.cs

@@ -0,0 +1,164 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using CefSharp;
+using CefSharp.Enums;
+using CefSharp.OffScreen;
+using CefSharp.Structs;
+using SharpDX.Direct3D11;
+using System;
+using System.Threading;
+using NLog;
+using SharpDX.Direct3D;
+using SharpDX.Mathematics.Interop;
+using Range = CefSharp.Structs.Range;
+
+namespace VRCX
+{
+    public class OffScreenBrowser : ChromiumWebBrowser, IRenderHandler
+    {
+        private Device _device;
+        private Device1 _device1;
+        private DeviceMultithread _deviceMultithread;
+        private Query _query;
+        private Texture2D _renderTarget;
+
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        public OffScreenBrowser(string address, int width, int height)
+            : base(address, automaticallyCreateBrowser: false)
+        {
+            var windowInfo = new WindowInfo();
+            windowInfo.SetAsWindowless(IntPtr.Zero);
+            windowInfo.WindowlessRenderingEnabled = true;
+            windowInfo.SharedTextureEnabled = true;
+            windowInfo.Width = width;
+            windowInfo.Height = height;
+
+            var browserSettings = new BrowserSettings()
+            {
+                DefaultEncoding = "UTF-8",
+                WindowlessFrameRate = 60
+            };
+
+            CreateBrowser(windowInfo, browserSettings);
+
+            Size = new System.Drawing.Size(width, height);
+            RenderHandler = this;
+
+            JavascriptBindings.ApplyVrJavascriptBindings(JavascriptObjectRepository);
+        }
+
+        public void UpdateRender(Device device, Texture2D renderTarget)
+        {
+            _device = device;
+            _device1 = _device.QueryInterface<Device1>();
+
+            _deviceMultithread?.Dispose();
+            _deviceMultithread = _device.QueryInterfaceOrNull<DeviceMultithread>();
+            _deviceMultithread?.SetMultithreadProtected(true);
+
+            _renderTarget = renderTarget;
+
+            _query?.Dispose();
+            _query = new Query(_device, new QueryDescription
+            {
+                Type = QueryType.Event,
+                Flags = QueryFlags.None
+            });
+        }
+
+        public new void Dispose()
+        {
+            RenderHandler = null;
+            base.Dispose();
+        }
+
+        ScreenInfo? IRenderHandler.GetScreenInfo()
+        {
+            return new ScreenInfo
+            {
+                DeviceScaleFactor = 1.0F
+            };
+        }
+
+        bool IRenderHandler.GetScreenPoint(int viewX, int viewY, out int screenX, out int screenY)
+        {
+            screenX = viewX;
+            screenY = viewY;
+            return false;
+        }
+
+        Rect IRenderHandler.GetViewRect()
+        {
+            return new Rect(0, 0, Size.Width, Size.Height);
+        }
+
+        void IRenderHandler.OnAcceleratedPaint(PaintElementType type, Rect dirtyRect, AcceleratedPaintInfo paintInfo)
+        {
+            if (type != PaintElementType.View)
+                return;
+
+            if (_device == null)
+                return;
+
+            try
+            {
+                using Texture2D cefTexture = _device1.OpenSharedResource1<Texture2D>(paintInfo.SharedTextureHandle);
+                _device.ImmediateContext.CopyResource(cefTexture, _renderTarget);
+                _device.ImmediateContext.End(_query);
+                _device.ImmediateContext.Flush();
+            }
+            catch (Exception e)
+            {
+                logger.Error(e);
+                _device = null;
+                return;
+            }
+
+            RawBool q = _device.ImmediateContext.GetData<RawBool>(_query, AsynchronousFlags.DoNotFlush);
+
+            while (!q)
+            {
+                Thread.Yield();
+                q = _device.ImmediateContext.GetData<RawBool>(_query, AsynchronousFlags.DoNotFlush);
+            }
+        }
+
+        void IRenderHandler.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo)
+        {
+        }
+
+        void IRenderHandler.OnImeCompositionRangeChanged(Range selectedRange, Rect[] characterBounds)
+        {
+        }
+
+        void IRenderHandler.OnPaint(PaintElementType type, Rect dirtyRect, IntPtr buffer, int width, int height)
+        {
+        }
+
+        void IRenderHandler.OnPopupShow(bool show)
+        {
+        }
+
+        void IRenderHandler.OnPopupSize(Rect rect)
+        {
+        }
+
+        void IRenderHandler.OnVirtualKeyboardRequested(IBrowser browser, TextInputMode inputMode)
+        {
+        }
+
+        bool IRenderHandler.StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y)
+        {
+            return false;
+        }
+
+        void IRenderHandler.UpdateDragCursor(DragOperationsMask operation)
+        {
+        }
+    }
+}

Dotnet/Overlay/Cef/OffScreenBrowserLegacy.cs

@@ -0,0 +1,206 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using CefSharp;
+using CefSharp.Enums;
+using CefSharp.OffScreen;
+using CefSharp.Structs;
+using SharpDX.Direct3D11;
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+using Range = CefSharp.Structs.Range;
+
+namespace VRCX
+{
+    public class OffScreenBrowserLegacy : ChromiumWebBrowser, IRenderHandler
+    {
+        private readonly ReaderWriterLockSlim _paintBufferLock;
+        private GCHandle _paintBuffer;
+        private int _width;
+        private int _height;
+
+        public OffScreenBrowserLegacy(string address, int width, int height)
+            : base(
+                address,
+                new BrowserSettings()
+                {
+                    DefaultEncoding = "UTF-8"
+                }
+            )
+        {
+            _paintBufferLock = new ReaderWriterLockSlim();
+
+            Size = new System.Drawing.Size(width, height);
+            RenderHandler = this;
+
+            JavascriptBindings.ApplyVrJavascriptBindings(JavascriptObjectRepository);
+        }
+
+        public new void Dispose()
+        {
+            RenderHandler = null;
+            base.Dispose();
+
+            _paintBufferLock.EnterWriteLock();
+            try
+            {
+                if (_paintBuffer.IsAllocated == true)
+                {
+                    _paintBuffer.Free();
+                }
+            }
+            finally
+            {
+                _paintBufferLock.ExitWriteLock();
+            }
+
+            _paintBufferLock.Dispose();
+        }
+
+        public void RenderToTexture(Texture2D texture)
+        {
+            // Safeguard against uninitialized texture
+            if (texture == null)
+                return;
+
+            _paintBufferLock.EnterReadLock();
+            try
+            {
+                if (_width > 0 &&
+                    _height > 0)
+                {
+                    var context = texture.Device.ImmediateContext;
+                    var dataBox = context.MapSubresource(
+                        texture,
+                        0,
+                        MapMode.WriteDiscard,
+                        MapFlags.None
+                    );
+                    if (dataBox.IsEmpty == false)
+                    {
+                        var sourcePtr = _paintBuffer.AddrOfPinnedObject();
+                        var destinationPtr = dataBox.DataPointer;
+                        var pitch = _width * 4;
+                        var rowPitch = dataBox.RowPitch;
+                        if (pitch == rowPitch)
+                        {
+                            WinApi.RtlCopyMemory(
+                                destinationPtr,
+                                sourcePtr,
+                                (uint)(_width * _height * 4)
+                            );
+                        }
+                        else
+                        {
+                            for (var y = _height; y > 0; --y)
+                            {
+                                WinApi.RtlCopyMemory(
+                                    destinationPtr,
+                                    sourcePtr,
+                                    (uint)pitch
+                                );
+                                sourcePtr += pitch;
+                                destinationPtr += rowPitch;
+                            }
+                        }
+                    }
+                    context.UnmapSubresource(texture, 0);
+                }
+            }
+            finally
+            {
+                _paintBufferLock.ExitReadLock();
+            }
+        }
+
+        ScreenInfo? IRenderHandler.GetScreenInfo()
+        {
+            return null;
+        }
+
+        bool IRenderHandler.GetScreenPoint(int viewX, int viewY, out int screenX, out int screenY)
+        {
+            screenX = viewX;
+            screenY = viewY;
+            return false;
+        }
+
+        Rect IRenderHandler.GetViewRect()
+        {
+            return new Rect(0, 0, Size.Width, Size.Height);
+        }
+
+        void IRenderHandler.OnAcceleratedPaint(PaintElementType type, Rect dirtyRect, AcceleratedPaintInfo paintInfo)
+        {
+            // NOT USED
+        }
+
+        void IRenderHandler.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo)
+        {
+        }
+
+        void IRenderHandler.OnImeCompositionRangeChanged(Range selectedRange, Rect[] characterBounds)
+        {
+        }
+
+        void IRenderHandler.OnPaint(PaintElementType type, Rect dirtyRect, IntPtr buffer, int width, int height)
+        {
+            if (type == PaintElementType.View)
+            {
+                _paintBufferLock.EnterWriteLock();
+                try
+                {
+                    if (_width != width ||
+                        _height != height)
+                    {
+                        _width = width;
+                        _height = height;
+                        if (_paintBuffer.IsAllocated == true)
+                        {
+                            _paintBuffer.Free();
+                        }
+                        _paintBuffer = GCHandle.Alloc(
+                            new byte[_width * _height * 4],
+                            GCHandleType.Pinned
+                        );
+                    }
+
+                    WinApi.RtlCopyMemory(
+                        _paintBuffer.AddrOfPinnedObject(),
+                        buffer,
+                        (uint)(width * height * 4)
+                    );
+                }
+                finally
+                {
+                    _paintBufferLock.ExitWriteLock();
+                }
+            }
+        }
+
+        void IRenderHandler.OnPopupShow(bool show)
+        {
+        }
+
+        void IRenderHandler.OnPopupSize(Rect rect)
+        {
+        }
+
+        void IRenderHandler.OnVirtualKeyboardRequested(IBrowser browser, TextInputMode inputMode)
+        {
+        }
+
+        bool IRenderHandler.StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y)
+        {
+            return false;
+        }
+
+        void IRenderHandler.UpdateDragCursor(DragOperationsMask operation)
+        {
+        }
+    }
+}

Dotnet/Overlay/Cef/SystemMonitorCef.cs

@@ -0,0 +1,151 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using System;
+using System.Diagnostics;
+using System.Threading;
+using NLog;
+
+namespace VRCX
+{
+    public class SystemMonitorCef
+    {
+        public static readonly SystemMonitorCef Instance;
+        public float CpuUsage;
+        public double UpTime;
+        private bool _enabled;
+        private PerformanceCounter _performanceCounterCpuUsage;
+        private PerformanceCounter _performanceCounterUpTime;
+        private Thread _thread;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+
+        static SystemMonitorCef()
+        {
+            Instance = new SystemMonitorCef();
+        }
+
+        public void Start(bool enabled)
+        {
+            if (enabled == _enabled)
+                return;
+
+            _enabled = enabled;
+            if (enabled)
+                StartThread();
+            else
+                Exit();
+        }
+
+        internal void Exit()
+        {
+            CpuUsage = 0;
+            UpTime = 0;
+            try
+            {
+                if (_thread != null)
+                {
+                    _thread.Interrupt();
+                    _thread.Join();
+                    _thread = null;
+                }
+            }
+            catch (ThreadInterruptedException)
+            {
+            }
+
+            _performanceCounterCpuUsage?.Dispose();
+            _performanceCounterCpuUsage = null;
+            _performanceCounterUpTime?.Dispose();
+            _performanceCounterUpTime = null;
+        }
+
+        private void StartThread()
+        {
+            Exit();
+
+            try
+            {
+                _performanceCounterCpuUsage = new PerformanceCounter(
+                    "Processor Information",
+                    "% Processor Utility",
+                    "_Total",
+                    true
+                );
+                _performanceCounterCpuUsage?.NextValue();
+            }
+            catch (Exception ex)
+            {
+                logger.Warn($"Failed to create \"Processor Utility\" PerformanceCounter ${ex}");
+            }
+
+            // fallback
+            if (_performanceCounterCpuUsage == null)
+            {
+                try
+                {
+                    _performanceCounterCpuUsage = new PerformanceCounter(
+                        "Processor",
+                        "% Processor Time",
+                        "_Total",
+                        true
+                    );
+                    _performanceCounterCpuUsage?.NextValue();
+                }
+                catch (Exception ex)
+                {
+                    logger.Warn($"Failed to create \"Processor Time\" PerformanceCounter ${ex}");
+                }
+            }
+
+            try
+            {
+                _performanceCounterUpTime = new PerformanceCounter("System", "System Up Time");
+                _performanceCounterUpTime?.NextValue();
+            }
+            catch
+            {
+                logger.Warn("Failed to create \"System Up Time\" PerformanceCounter");
+            }
+
+            if (_performanceCounterCpuUsage == null &&
+                _performanceCounterUpTime == null)
+            {
+                logger.Error("Failed to create any PerformanceCounter");
+                return;
+            }
+            logger.Info("SystemMonitor started");
+
+            _thread = new Thread(ThreadProc)
+            {
+                IsBackground = true
+            };
+            _thread.Start();
+        }
+
+        private void ThreadProc()
+        {
+            try
+            {
+                while (_enabled)
+                {
+                    if (_performanceCounterCpuUsage != null)
+                        CpuUsage = _performanceCounterCpuUsage.NextValue();
+
+                    if (_performanceCounterUpTime != null)
+                        UpTime = TimeSpan.FromSeconds(_performanceCounterUpTime.NextValue()).TotalMilliseconds;
+
+                    Thread.Sleep(1000);
+                }
+            }
+            catch (Exception ex)
+            {
+                logger.Warn($"SystemMonitor thread exception: {ex}");
+            }
+
+            Exit();
+        }
+    }
+}

Dotnet/Overlay/Cef/VRCXVRCef.cs

@@ -0,0 +1,864 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using CefSharp;
+using NLog;
+using SharpDX;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using Valve.VR;
+using Device = SharpDX.Direct3D11.Device;
+using Device1 = SharpDX.Direct3D11.Device1;
+using Device2 = SharpDX.Direct3D11.Device2;
+using Device3 = SharpDX.Direct3D11.Device3;
+using Device4 = SharpDX.Direct3D11.Device4;
+
+namespace VRCX
+{
+    public class VRCXVRCef : VRCXVRInterface
+    {
+        public static VRCXVRInterface Instance;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+        private static readonly float[] _rotation = { 0f, 0f, 0f };
+        private static readonly float[] _translation = { 0f, 0f, 0f };
+        private static readonly float[] _translationLeft = { -7f / 100f, -5f / 100f, 6f / 100f };
+        private static readonly float[] _translationRight = { 7f / 100f, -5f / 100f, 6f / 100f };
+        private static readonly float[] _rotationLeft = { 90f * (float)(Math.PI / 180f), 90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) };
+        private static readonly float[] _rotationRight = { -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) };
+        private static OffScreenBrowser _wristOverlay;
+        private static OffScreenBrowser _hmdOverlay;
+        private readonly List<string[]> _deviceList;
+        private readonly ReaderWriterLockSlim _deviceListLock;
+        private bool _active;
+        private Device _device;
+        private bool _menuButton;
+        private int _overlayHand;
+        private Factory _factory;
+        private Texture2D _texture1;
+        private Texture2D _texture2;
+        private Thread _thread;
+        private DateTime _nextOverlayUpdate;
+
+        private ulong _hmdOverlayHandle;
+        private bool _hmdOverlayActive;
+        private bool _hmdOverlayWasActive;
+
+        private ulong _wristOverlayHandle;
+        private bool _wristOverlayActive;
+        private bool _wristOverlayWasActive;
+
+
+        static VRCXVRCef()
+        {
+            Instance = new VRCXVRCef();
+        }
+
+        public VRCXVRCef()
+        {
+            _deviceListLock = new ReaderWriterLockSlim();
+            _deviceList = new List<string[]>();
+            _thread = new Thread(ThreadLoop)
+            {
+                IsBackground = true
+            };
+        }
+
+        // NOTE
+        // 메모리 릭 때문에 미리 생성해놓고 계속 사용함
+        public override void Init()
+        {
+            _thread.Start();
+        }
+
+        public override void Exit()
+        {
+            var thread = _thread;
+            _thread = null;
+            thread?.Interrupt();
+            thread?.Join();
+        }
+
+        public override void Restart()
+        {
+            Exit();
+            Instance = new VRCXVRCef();
+            Instance.Init();
+            MainForm.Instance.Browser.ExecuteScriptAsync("console.log('VRCXVR Restarted');");
+        }
+
+        private void SetupTextures()
+        {
+            _factory ??= new Factory1();
+
+            _device?.Dispose();
+            _device = new Device(_factory.GetAdapter(OpenVR.System.GetD3D9AdapterIndex()),
+                DeviceCreationFlags.BgraSupport);
+            UpgradeDevice();
+
+            _texture1?.Dispose();
+            _texture1 = new Texture2D(
+                _device,
+                new Texture2DDescription
+                {
+                    Width = 512,
+                    Height = 512,
+                    MipLevels = 1,
+                    ArraySize = 1,
+                    Format = Format.B8G8R8A8_UNorm,
+                    SampleDescription = new SampleDescription(1, 0),
+                    BindFlags = BindFlags.ShaderResource
+                }
+            );
+            _wristOverlay?.UpdateRender(_device, _texture1);
+
+            _texture2?.Dispose();
+            _texture2 = new Texture2D(
+                _device,
+                new Texture2DDescription
+                {
+                    Width = 1024,
+                    Height = 1024,
+                    MipLevels = 1,
+                    ArraySize = 1,
+                    Format = Format.B8G8R8A8_UNorm,
+                    SampleDescription = new SampleDescription(1, 0),
+                    BindFlags = BindFlags.ShaderResource
+                }
+            );
+            _hmdOverlay?.UpdateRender(_device, _texture2);
+        }
+
+        private void UpgradeDevice()
+        {
+            Device5 device5 = _device.QueryInterfaceOrNull<Device5>();
+            if (device5 != null)
+            {
+                _device.Dispose();
+                _device = device5;
+                return;
+            }
+            Device4 device4 = _device.QueryInterfaceOrNull<Device4>();
+            if (device4 != null)
+            {
+                _device.Dispose();
+                _device = device4;
+                return;
+            }
+            Device3 device3 = _device.QueryInterfaceOrNull<Device3>();
+            if (device3 != null)
+            {
+                _device.Dispose();
+                _device = device3;
+                return;
+            }
+            Device2 device2 = _device.QueryInterfaceOrNull<Device2>();
+            if (device2 != null)
+            {
+                _device.Dispose();
+                _device = device2;
+                return;
+            }
+            Device1 device1 = _device.QueryInterfaceOrNull<Device1>();
+            if (device1 != null)
+            {
+                _device.Dispose();
+                _device = device1;
+            }
+        }
+
+        private void ThreadLoop()
+        {
+            var active = false;
+            var e = new VREvent_t();
+            var nextInit = DateTime.MinValue;
+            var nextDeviceUpdate = DateTime.MinValue;
+            _nextOverlayUpdate = DateTime.MinValue;
+            var overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid;
+            var overlayVisible1 = false;
+            var overlayVisible2 = false;
+            var dashboardHandle = 0UL;
+
+            _wristOverlay = new OffScreenBrowser(
+                Program.LaunchDebug ? "http://localhost:9000/vr.html?1": "file://vrcx/vr.html?1",
+                512,
+                512
+            );
+
+            _hmdOverlay = new OffScreenBrowser(
+                Program.LaunchDebug ? "http://localhost:9000/vr.html?2": "file://vrcx/vr.html?2",
+                1024,
+                1024
+            );
+
+            while (_thread != null)
+            {
+                try
+                {
+                    Thread.Sleep(32);
+                }
+                catch (ThreadInterruptedException)
+                {
+                }
+
+                if (_active)
+                {
+                    var system = OpenVR.System;
+                    if (system == null)
+                    {
+                        if (DateTime.UtcNow.CompareTo(nextInit) <= 0)
+                        {
+                            continue;
+                        }
+
+                        var _err = EVRInitError.None;
+                        system = OpenVR.Init(ref _err, EVRApplicationType.VRApplication_Background);
+                        nextInit = DateTime.UtcNow.AddSeconds(5);
+                        if (system == null)
+                        {
+                            continue;
+                        }
+
+                        active = true;
+                        SetupTextures();
+                    }
+
+                    while (system.PollNextEvent(ref e, (uint)Marshal.SizeOf(e)))
+                    {
+                        var type = (EVREventType)e.eventType;
+                        if (type == EVREventType.VREvent_Quit)
+                        {
+                            active = false;
+                            IsHmdAfk = false;
+                            OpenVR.Shutdown();
+                            nextInit = DateTime.UtcNow.AddSeconds(10);
+                            system = null;
+
+                            _wristOverlayHandle = 0;
+                            _hmdOverlayHandle = 0;
+                            break;
+                        }
+                    }
+
+                    if (system != null)
+                    {
+                        if (DateTime.UtcNow.CompareTo(nextDeviceUpdate) >= 0)
+                        {
+                            overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid;
+                            UpdateDevices(system, ref overlayIndex);
+                            if (overlayIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
+                            {
+                                _nextOverlayUpdate = DateTime.UtcNow.AddSeconds(10);
+                            }
+
+                            nextDeviceUpdate = DateTime.UtcNow.AddSeconds(0.1);
+                        }
+
+                        var overlay = OpenVR.Overlay;
+                        if (overlay != null)
+                        {
+                            var dashboardVisible = overlay.IsDashboardVisible();
+                            var err = ProcessDashboard(overlay, ref dashboardHandle, dashboardVisible);
+                            if (err != EVROverlayError.None &&
+                                dashboardHandle != 0)
+                            {
+                                overlay.DestroyOverlay(dashboardHandle);
+                                dashboardHandle = 0;
+                                logger.Error(err);
+                            }
+
+                            if (_wristOverlayActive)
+                            {
+                                err = ProcessOverlay1(overlay, ref _wristOverlayHandle, ref overlayVisible1,
+                                    dashboardVisible, overlayIndex);
+                                if (err != EVROverlayError.None &&
+                                    _wristOverlayHandle != 0)
+                                {
+                                    overlay.DestroyOverlay(_wristOverlayHandle);
+                                    _wristOverlayHandle = 0;
+                                    logger.Error(err);
+                                }
+                            }
+
+                            if (_hmdOverlayActive)
+                            {
+                                err = ProcessOverlay2(overlay, ref _hmdOverlayHandle, ref overlayVisible2,
+                                    dashboardVisible);
+                                if (err != EVROverlayError.None &&
+                                    _hmdOverlayHandle != 0)
+                                {
+                                    overlay.DestroyOverlay(_hmdOverlayHandle);
+                                    _hmdOverlayHandle = 0;
+                                    logger.Error(err);
+                                }
+                            }
+                        }
+                    }
+                }
+                else if (active)
+                {
+                    active = false;
+                    IsHmdAfk = false;
+                    OpenVR.Shutdown();
+                    _deviceListLock.EnterWriteLock();
+                    try
+                    {
+                        _deviceList.Clear();
+                    }
+                    finally
+                    {
+                        _deviceListLock.ExitWriteLock();
+                    }
+                }
+            }
+
+            _hmdOverlay?.Dispose();
+            _wristOverlay?.Dispose();
+            _texture2?.Dispose();
+            _texture1?.Dispose();
+            _device?.Dispose();
+        }
+
+        public override void SetActive(bool active, bool hmdOverlay, bool wristOverlay, bool menuButton, int overlayHand)
+        {
+            _active = active;
+            _hmdOverlayActive = hmdOverlay;
+            _wristOverlayActive = wristOverlay;
+            _menuButton = menuButton;
+            _overlayHand = overlayHand;
+
+            if (_hmdOverlayActive != _hmdOverlayWasActive && _hmdOverlayHandle != 0)
+            {
+                OpenVR.Overlay.DestroyOverlay(_hmdOverlayHandle);
+                _hmdOverlayHandle = 0;
+            }
+
+            _hmdOverlayWasActive = _hmdOverlayActive;
+
+            if (_wristOverlayActive != _wristOverlayWasActive && _wristOverlayHandle != 0)
+            {
+                OpenVR.Overlay.DestroyOverlay(_wristOverlayHandle);
+                _wristOverlayHandle = 0;
+            }
+
+            _wristOverlayWasActive = _wristOverlayActive;
+        }
+
+        public override void Refresh()
+        {
+            _wristOverlay.Reload();
+            _hmdOverlay.Reload();
+        }
+
+        public override string[][] GetDevices()
+        {
+            _deviceListLock.EnterReadLock();
+            try
+            {
+                return _deviceList.ToArray();
+            }
+            finally
+            {
+                _deviceListLock.ExitReadLock();
+            }
+        }
+
+        private void UpdateDevices(CVRSystem system, ref uint overlayIndex)
+        {
+            _deviceListLock.EnterWriteLock();
+            try
+            {
+                _deviceList.Clear();
+            }
+            finally
+            {
+                _deviceListLock.ExitWriteLock();
+            }
+
+            var sb = new StringBuilder(256);
+            var state = new VRControllerState_t();
+            var poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
+            system.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, poses);
+            for (var i = 0u; i < OpenVR.k_unMaxTrackedDeviceCount; ++i)
+            {
+                var devClass = system.GetTrackedDeviceClass(i);
+                switch (devClass)
+                {
+                    case ETrackedDeviceClass.HMD:
+                        var success = system.GetControllerState(i, ref state, (uint)Marshal.SizeOf(state));
+                        if (!success)
+                            break; // this fails while SteamVR overlay is open
+
+                        var prox = state.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_ProximitySensor));
+                        var isHmdAfk = prox == 0;
+                        if (isHmdAfk != IsHmdAfk)
+                        {
+                            IsHmdAfk = isHmdAfk;
+                            Program.AppApiInstance.CheckGameRunning();
+                        }
+
+                        var headsetErr = ETrackedPropertyError.TrackedProp_Success;
+                        var headsetBatteryPercentage = system.GetFloatTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref headsetErr);
+                        if (headsetErr != ETrackedPropertyError.TrackedProp_Success)
+                        {
+                            // Headset has no battery, skip displaying it
+                            break;
+                        }
+
+                        var headset = new[]
+                        {
+                            "headset",
+                            system.IsTrackedDeviceConnected(i)
+                                ? "connected"
+                                : "disconnected",
+                            // Currently neither VD or SteamLink report charging state
+                            "discharging",
+                            (headsetBatteryPercentage * 100).ToString(),
+                            poses[i].eTrackingResult.ToString()
+                        };
+                        _deviceListLock.EnterWriteLock();
+                        try
+                        {
+                            _deviceList.Add(headset);
+                        }
+                        finally
+                        {
+                            _deviceListLock.ExitWriteLock();
+                        }
+
+                        break;
+                    case ETrackedDeviceClass.Controller:
+                    case ETrackedDeviceClass.GenericTracker:
+                    case ETrackedDeviceClass.TrackingReference:
+                        {
+                            var err = ETrackedPropertyError.TrackedProp_Success;
+                            var batteryPercentage = system.GetFloatTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref err);
+                            if (err != ETrackedPropertyError.TrackedProp_Success)
+                            {
+                                batteryPercentage = 1f;
+                            }
+
+                            err = ETrackedPropertyError.TrackedProp_Success;
+                            var isCharging = system.GetBoolTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceIsCharging_Bool, ref err);
+                            if (err != ETrackedPropertyError.TrackedProp_Success)
+                            {
+                                isCharging = false;
+                            }
+
+                            sb.Clear();
+                            system.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_TrackingSystemName_String, sb, (uint)sb.Capacity, ref err);
+                            var isOculus = sb.ToString().IndexOf("oculus", StringComparison.OrdinalIgnoreCase) >= 0;
+                            // Oculus : B/Y, Bit 1, Mask 2
+                            // Oculus : A/X, Bit 7, Mask 128
+                            // Vive : Menu, Bit 1, Mask 2,
+                            // Vive : Grip, Bit 2, Mask 4
+                            var role = system.GetControllerRoleForTrackedDeviceIndex(i);
+                            if (role == ETrackedControllerRole.LeftHand || role == ETrackedControllerRole.RightHand)
+                            {
+                                if (_overlayHand == 0 ||
+                                    (_overlayHand == 1 && role == ETrackedControllerRole.LeftHand) ||
+                                    (_overlayHand == 2 && role == ETrackedControllerRole.RightHand))
+                                {
+                                    if (system.GetControllerState(i, ref state, (uint)Marshal.SizeOf(state)) &&
+                                        (state.ulButtonPressed & (_menuButton ? 2u : isOculus ? 128u : 4u)) != 0)
+                                    {
+                                        _nextOverlayUpdate = DateTime.MinValue;
+                                        if (role == ETrackedControllerRole.LeftHand)
+                                        {
+                                            Array.Copy(_translationLeft, _translation, 3);
+                                            Array.Copy(_rotationLeft, _rotation, 3);
+                                        }
+                                        else
+                                        {
+                                            Array.Copy(_translationRight, _translation, 3);
+                                            Array.Copy(_rotationRight, _rotation, 3);
+                                        }
+
+                                        overlayIndex = i;
+                                    }
+                                }
+                            }
+
+                            var type = string.Empty;
+                            if (devClass == ETrackedDeviceClass.Controller)
+                            {
+                                if (role == ETrackedControllerRole.LeftHand)
+                                {
+                                    type = "leftController";
+                                }
+                                else if (role == ETrackedControllerRole.RightHand)
+                                {
+                                    type = "rightController";
+                                }
+                                else
+                                {
+                                    type = "controller";
+                                }
+                            }
+                            else if (devClass == ETrackedDeviceClass.GenericTracker)
+                            {
+                                type = "tracker";
+                            }
+                            else if (devClass == ETrackedDeviceClass.TrackingReference)
+                            {
+                                type = "base";
+                            }
+
+                            var item = new[]
+                            {
+                            type,
+                            system.IsTrackedDeviceConnected(i)
+                                ? "connected"
+                                : "disconnected",
+                            isCharging
+                                ? "charging"
+                                : "discharging",
+                            (batteryPercentage * 100).ToString(),
+                            poses[i].eTrackingResult.ToString()
+                        };
+                            _deviceListLock.EnterWriteLock();
+                            try
+                            {
+                                _deviceList.Add(item);
+                            }
+                            finally
+                            {
+                                _deviceListLock.ExitWriteLock();
+                            }
+
+                            break;
+                        }
+                }
+            }
+        }
+
+        internal EVROverlayError ProcessDashboard(CVROverlay overlay, ref ulong dashboardHandle, bool dashboardVisible)
+        {
+            var err = EVROverlayError.None;
+
+            if (dashboardHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX", ref dashboardHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    ulong thumbnailHandle = 0;
+                    err = overlay.CreateDashboardOverlay("VRCX", "VRCX", ref dashboardHandle, ref thumbnailHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    var iconPath = Path.Join(Program.BaseDirectory, "VRCX.png");
+                    err = overlay.SetOverlayFromFile(thumbnailHandle, iconPath);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(dashboardHandle, 1.5f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(dashboardHandle, VROverlayInputMethod.Mouse);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            var e = new VREvent_t();
+
+            while (overlay.PollNextOverlayEvent(dashboardHandle, ref e, (uint)Marshal.SizeOf(e)))
+            {
+                var type = (EVREventType)e.eventType;
+                if (type == EVREventType.VREvent_MouseMove)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseMoveEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), false, CefEventFlags.None);
+                }
+                else if (type == EVREventType.VREvent_MouseButtonDown)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, false, 1, CefEventFlags.LeftMouseButton);
+                }
+                else if (type == EVREventType.VREvent_MouseButtonUp)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, true, 1, CefEventFlags.None);
+                }
+            }
+
+            if (dashboardVisible)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture1.NativePointer
+                };
+                err = overlay.SetOverlayTexture(dashboardHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+            }
+
+            return err;
+        }
+
+        internal EVROverlayError ProcessOverlay1(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible, uint overlayIndex)
+        {
+            var err = EVROverlayError.None;
+
+            if (overlayHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX1", ref overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = false;
+                    err = overlay.CreateOverlay("VRCX1", "VRCX1", ref overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayAlpha(overlayHandle, 0.9f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            if (overlayIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
+            {
+                // http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices
+                // Scaling-Rotation-Translation
+                var m = Matrix.Scaling(0.25f);
+                m *= Matrix.RotationX(_rotation[0]);
+                m *= Matrix.RotationY(_rotation[1]);
+                m *= Matrix.RotationZ(_rotation[2]);
+                m *= Matrix.Translation(_translation[0], _translation[1], _translation[2]);
+                var hm34 = new HmdMatrix34_t
+                {
+                    m0 = m.M11,
+                    m1 = m.M21,
+                    m2 = m.M31,
+                    m3 = m.M41,
+                    m4 = m.M12,
+                    m5 = m.M22,
+                    m6 = m.M32,
+                    m7 = m.M42,
+                    m8 = m.M13,
+                    m9 = m.M23,
+                    m10 = m.M33,
+                    m11 = m.M43
+                };
+                err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, overlayIndex, ref hm34);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+            }
+
+            if (!dashboardVisible &&
+                DateTime.UtcNow.CompareTo(_nextOverlayUpdate) <= 0)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture1.NativePointer
+                };
+                err = overlay.SetOverlayTexture(overlayHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                if (!overlayVisible)
+                {
+                    err = overlay.ShowOverlay(overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = true;
+                }
+            }
+            else if (overlayVisible)
+            {
+                err = overlay.HideOverlay(overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                overlayVisible = false;
+            }
+
+            return err;
+        }
+
+        internal EVROverlayError ProcessOverlay2(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible)
+        {
+            var err = EVROverlayError.None;
+
+            if (overlayHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX2", ref overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = false;
+                    err = overlay.CreateOverlay("VRCX2", "VRCX2", ref overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayAlpha(overlayHandle, 0.9f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    var m = Matrix.Scaling(1f);
+                    m *= Matrix.Translation(0, -0.3f, -1.5f);
+                    var hm34 = new HmdMatrix34_t
+                    {
+                        m0 = m.M11,
+                        m1 = m.M21,
+                        m2 = m.M31,
+                        m3 = m.M41,
+                        m4 = m.M12,
+                        m5 = m.M22,
+                        m6 = m.M32,
+                        m7 = m.M42,
+                        m8 = m.M13,
+                        m9 = m.M23,
+                        m10 = m.M33,
+                        m11 = m.M43
+                    };
+                    err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, OpenVR.k_unTrackedDeviceIndex_Hmd, ref hm34);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            if (!dashboardVisible)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture2.NativePointer
+                };
+                err = overlay.SetOverlayTexture(overlayHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                if (!overlayVisible)
+                {
+                    err = overlay.ShowOverlay(overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = true;
+                }
+            }
+            else if (overlayVisible)
+            {
+                err = overlay.HideOverlay(overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                overlayVisible = false;
+            }
+
+            return err;
+        }
+
+        public override ConcurrentQueue<KeyValuePair<string, string>> GetExecuteVrFeedFunctionQueue()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void ExecuteVrFeedFunction(string function, string json)
+        {
+            if (_wristOverlay == null) return;
+            // if (_wristOverlay.IsLoading)
+            //     Restart();
+            _wristOverlay.ExecuteScriptAsync($"$app.{function}", json);
+        }
+
+        public override ConcurrentQueue<KeyValuePair<string, string>> GetExecuteVrOverlayFunctionQueue()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void ExecuteVrOverlayFunction(string function, string json)
+        {
+            if (_hmdOverlay == null) return;
+            // if (_hmdOverlay.IsLoading)
+            //     Restart();
+            _hmdOverlay.ExecuteScriptAsync($"$app.{function}", json);
+        }
+    }
+}

Dotnet/Overlay/Cef/VRCXVRLegacy.cs

@@ -0,0 +1,792 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using CefSharp;
+using NLog;
+using SharpDX;
+using SharpDX.Direct3D11;
+using SharpDX.DXGI;
+using Valve.VR;
+using Device = SharpDX.Direct3D11.Device;
+
+namespace VRCX
+{
+    public class VRCXVRLegacy : VRCXVRInterface
+    {
+        public static VRCXVRInterface Instance;
+        private static readonly Logger logger = LogManager.GetCurrentClassLogger();
+        private static readonly float[] _rotation = { 0f, 0f, 0f };
+        private static readonly float[] _translation = { 0f, 0f, 0f };
+        private static readonly float[] _translationLeft = { -7f / 100f, -5f / 100f, 6f / 100f };
+        private static readonly float[] _translationRight = { 7f / 100f, -5f / 100f, 6f / 100f };
+        private static readonly float[] _rotationLeft = { 90f * (float)(Math.PI / 180f), 90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) };
+        private static readonly float[] _rotationRight = { -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) };
+        private static OffScreenBrowserLegacy _wristOverlay;
+        private static OffScreenBrowserLegacy _hmdOverlay;
+        private readonly List<string[]> _deviceList;
+        private readonly ReaderWriterLockSlim _deviceListLock;
+        private bool _active;
+        private Device _device;
+        private bool _hmdOverlayActive;
+        private bool _menuButton;
+        private int _overlayHand;
+        private Texture2D _texture1;
+        private Texture2D _texture2;
+        private Thread _thread;
+        private bool _wristOverlayActive;
+        private DateTime _nextOverlayUpdate;
+
+        static VRCXVRLegacy()
+        {
+            Instance = new VRCXVRLegacy();
+        }
+
+        public VRCXVRLegacy()
+        {
+            _deviceListLock = new ReaderWriterLockSlim();
+            _deviceList = new List<string[]>();
+            _thread = new Thread(ThreadLoop)
+            {
+                IsBackground = true
+            };
+        }
+
+        // NOTE
+        // 메모리 릭 때문에 미리 생성해놓고 계속 사용함
+        public override void Init()
+        {
+            _thread.Start();
+        }
+
+        public override void Exit()
+        {
+            var thread = _thread;
+            _thread = null;
+            thread?.Interrupt();
+            thread?.Join();
+        }
+
+        public override void Restart()
+        {
+            Exit();
+            Instance = new VRCXVRLegacy();
+            Instance.Init();
+            MainForm.Instance.Browser.ExecuteScriptAsync("console.log('VRCXVR Restarted');");
+        }
+
+        private void SetupTextures()
+        {
+            Factory f = new Factory1();
+            _device = new Device(f.GetAdapter(OpenVR.System.GetD3D9AdapterIndex()),
+                DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.BgraSupport);
+
+            _texture1?.Dispose();
+            _texture1 = new Texture2D(
+                _device,
+                new Texture2DDescription
+                {
+                    Width = 512,
+                    Height = 512,
+                    MipLevels = 1,
+                    ArraySize = 1,
+                    Format = Format.B8G8R8A8_UNorm,
+                    SampleDescription = new SampleDescription(1, 0),
+                    Usage = ResourceUsage.Dynamic,
+                    BindFlags = BindFlags.ShaderResource,
+                    CpuAccessFlags = CpuAccessFlags.Write
+                }
+            );
+
+            _texture2?.Dispose();
+            _texture2 = new Texture2D(
+                _device,
+                new Texture2DDescription
+                {
+                    Width = 1024,
+                    Height = 1024,
+                    MipLevels = 1,
+                    ArraySize = 1,
+                    Format = Format.B8G8R8A8_UNorm,
+                    SampleDescription = new SampleDescription(1, 0),
+                    Usage = ResourceUsage.Dynamic,
+                    BindFlags = BindFlags.ShaderResource,
+                    CpuAccessFlags = CpuAccessFlags.Write
+                }
+            );
+        }
+
+        private void ThreadLoop()
+        {
+            var active = false;
+            var e = new VREvent_t();
+            var nextInit = DateTime.MinValue;
+            var nextDeviceUpdate = DateTime.MinValue;
+            _nextOverlayUpdate = DateTime.MinValue;
+            var overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid;
+            var overlayVisible1 = false;
+            var overlayVisible2 = false;
+            var dashboardHandle = 0UL;
+            var overlayHandle1 = 0UL;
+            var overlayHandle2 = 0UL;
+
+            _wristOverlay = new OffScreenBrowserLegacy(
+                "file://vrcx/vr.html?1",
+                512,
+                512
+            );
+
+            _hmdOverlay = new OffScreenBrowserLegacy(
+                "file://vrcx/vr.html?2",
+                1024,
+                1024
+            );
+
+            while (_thread != null)
+            {
+                if (_wristOverlayActive)
+                    _wristOverlay.RenderToTexture(_texture1);
+                if (_hmdOverlayActive)
+                    _hmdOverlay.RenderToTexture(_texture2);
+                try
+                {
+                    Thread.Sleep(32);
+                }
+                catch (ThreadInterruptedException)
+                {
+                }
+
+                if (_active)
+                {
+                    var system = OpenVR.System;
+                    if (system == null)
+                    {
+                        if (DateTime.UtcNow.CompareTo(nextInit) <= 0)
+                        {
+                            continue;
+                        }
+
+                        var _err = EVRInitError.None;
+                        system = OpenVR.Init(ref _err, EVRApplicationType.VRApplication_Background);
+                        nextInit = DateTime.UtcNow.AddSeconds(5);
+                        if (system == null)
+                        {
+                            continue;
+                        }
+
+                        active = true;
+                        SetupTextures();
+                    }
+
+                    while (system.PollNextEvent(ref e, (uint)Marshal.SizeOf(e)))
+                    {
+                        var type = (EVREventType)e.eventType;
+                        if (type == EVREventType.VREvent_Quit)
+                        {
+                            active = false;
+                            IsHmdAfk = false;
+                            OpenVR.Shutdown();
+                            nextInit = DateTime.UtcNow.AddSeconds(10);
+                            system = null;
+                            break;
+                        }
+                    }
+
+                    if (system != null)
+                    {
+                        if (DateTime.UtcNow.CompareTo(nextDeviceUpdate) >= 0)
+                        {
+                            overlayIndex = OpenVR.k_unTrackedDeviceIndexInvalid;
+                            UpdateDevices(system, ref overlayIndex);
+                            if (overlayIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
+                            {
+                                _nextOverlayUpdate = DateTime.UtcNow.AddSeconds(10);
+                            }
+
+                            nextDeviceUpdate = DateTime.UtcNow.AddSeconds(0.1);
+                        }
+
+                        var overlay = OpenVR.Overlay;
+                        if (overlay != null)
+                        {
+                            var dashboardVisible = overlay.IsDashboardVisible();
+                            var err = ProcessDashboard(overlay, ref dashboardHandle, dashboardVisible);
+                            if (err != EVROverlayError.None &&
+                                dashboardHandle != 0)
+                            {
+                                overlay.DestroyOverlay(dashboardHandle);
+                                dashboardHandle = 0;
+                                logger.Error(err);
+                            }
+
+                            err = ProcessOverlay1(overlay, ref overlayHandle1, ref overlayVisible1, dashboardVisible, overlayIndex);
+                            if (err != EVROverlayError.None &&
+                                overlayHandle1 != 0)
+                            {
+                                overlay.DestroyOverlay(overlayHandle1);
+                                overlayHandle1 = 0;
+                                logger.Error(err);
+                            }
+
+                            err = ProcessOverlay2(overlay, ref overlayHandle2, ref overlayVisible2, dashboardVisible);
+                            if (err != EVROverlayError.None &&
+                                overlayHandle2 != 0)
+                            {
+                                overlay.DestroyOverlay(overlayHandle2);
+                                overlayHandle2 = 0;
+                                logger.Error(err);
+                            }
+                        }
+                    }
+                }
+                else if (active)
+                {
+                    active = false;
+                    IsHmdAfk = false;
+                    OpenVR.Shutdown();
+                    _deviceListLock.EnterWriteLock();
+                    try
+                    {
+                        _deviceList.Clear();
+                    }
+                    finally
+                    {
+                        _deviceListLock.ExitWriteLock();
+                    }
+                }
+            }
+
+            _hmdOverlay?.Dispose();
+            _wristOverlay?.Dispose();
+            _texture2?.Dispose();
+            _texture1?.Dispose();
+            _device?.Dispose();
+        }
+
+        public override void SetActive(bool active, bool hmdOverlay, bool wristOverlay, bool menuButton, int overlayHand)
+        {
+            _active = active;
+            _hmdOverlayActive = hmdOverlay;
+            _wristOverlayActive = wristOverlay;
+            _menuButton = menuButton;
+            _overlayHand = overlayHand;
+        }
+
+        public override void Refresh()
+        {
+            _wristOverlay.Reload();
+            _hmdOverlay.Reload();
+        }
+
+        public override string[][] GetDevices()
+        {
+            _deviceListLock.EnterReadLock();
+            try
+            {
+                return _deviceList.ToArray();
+            }
+            finally
+            {
+                _deviceListLock.ExitReadLock();
+            }
+        }
+
+        private void UpdateDevices(CVRSystem system, ref uint overlayIndex)
+        {
+            _deviceListLock.EnterWriteLock();
+            try
+            {
+                _deviceList.Clear();
+            }
+            finally
+            {
+                _deviceListLock.ExitWriteLock();
+            }
+
+            var sb = new StringBuilder(256);
+            var state = new VRControllerState_t();
+            var poses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount];
+            system.GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin.TrackingUniverseStanding, 0, poses);
+            for (var i = 0u; i < OpenVR.k_unMaxTrackedDeviceCount; ++i)
+            {
+                var devClass = system.GetTrackedDeviceClass(i);
+                switch (devClass)
+                {
+                    case ETrackedDeviceClass.HMD:
+                        var success = system.GetControllerState(i, ref state, (uint)Marshal.SizeOf(state));
+                        if (!success)
+                            break; // this fails while SteamVR overlay is open
+
+                        var prox = state.ulButtonPressed & (1UL << ((int)EVRButtonId.k_EButton_ProximitySensor));
+                        var isHmdAfk = prox == 0;
+                        if (isHmdAfk != IsHmdAfk)
+                        {
+                            IsHmdAfk = isHmdAfk;
+                            Program.AppApiInstance.CheckGameRunning();
+                        }
+
+                        var headsetErr = ETrackedPropertyError.TrackedProp_Success;
+                        var headsetBatteryPercentage = system.GetFloatTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref headsetErr);
+                        if (headsetErr != ETrackedPropertyError.TrackedProp_Success)
+                        {
+                            // Headset has no battery, skip displaying it
+                            break;
+                        }
+
+                        var headset = new[]
+                        {
+                            "headset",
+                            system.IsTrackedDeviceConnected(i)
+                                ? "connected"
+                                : "disconnected",
+                            // Currently neither VD or SteamLink report charging state
+                            "discharging",
+                            (headsetBatteryPercentage * 100).ToString(),
+                            poses[i].eTrackingResult.ToString()
+                        };
+                        _deviceListLock.EnterWriteLock();
+                        try
+                        {
+                            _deviceList.Add(headset);
+                        }
+                        finally
+                        {
+                            _deviceListLock.ExitWriteLock();
+                        }
+
+                        break;
+                    case ETrackedDeviceClass.Controller:
+                    case ETrackedDeviceClass.GenericTracker:
+                    case ETrackedDeviceClass.TrackingReference:
+                        {
+                            var err = ETrackedPropertyError.TrackedProp_Success;
+                            var batteryPercentage = system.GetFloatTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref err);
+                            if (err != ETrackedPropertyError.TrackedProp_Success)
+                            {
+                                batteryPercentage = 1f;
+                            }
+
+                            err = ETrackedPropertyError.TrackedProp_Success;
+                            var isCharging = system.GetBoolTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceIsCharging_Bool, ref err);
+                            if (err != ETrackedPropertyError.TrackedProp_Success)
+                            {
+                                isCharging = false;
+                            }
+
+                            sb.Clear();
+                            system.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_TrackingSystemName_String, sb, (uint)sb.Capacity, ref err);
+                            var isOculus = sb.ToString().IndexOf("oculus", StringComparison.OrdinalIgnoreCase) >= 0;
+                            // Oculus : B/Y, Bit 1, Mask 2
+                            // Oculus : A/X, Bit 7, Mask 128
+                            // Vive : Menu, Bit 1, Mask 2,
+                            // Vive : Grip, Bit 2, Mask 4
+                            var role = system.GetControllerRoleForTrackedDeviceIndex(i);
+                            if (role == ETrackedControllerRole.LeftHand || role == ETrackedControllerRole.RightHand)
+                            {
+                                if (_overlayHand == 0 ||
+                                    (_overlayHand == 1 && role == ETrackedControllerRole.LeftHand) ||
+                                    (_overlayHand == 2 && role == ETrackedControllerRole.RightHand))
+                                {
+                                    if (system.GetControllerState(i, ref state, (uint)Marshal.SizeOf(state)) &&
+                                        (state.ulButtonPressed & (_menuButton ? 2u : isOculus ? 128u : 4u)) != 0)
+                                    {
+                                        _nextOverlayUpdate = DateTime.MinValue;
+                                        if (role == ETrackedControllerRole.LeftHand)
+                                        {
+                                            Array.Copy(_translationLeft, _translation, 3);
+                                            Array.Copy(_rotationLeft, _rotation, 3);
+                                        }
+                                        else
+                                        {
+                                            Array.Copy(_translationRight, _translation, 3);
+                                            Array.Copy(_rotationRight, _rotation, 3);
+                                        }
+
+                                        overlayIndex = i;
+                                    }
+                                }
+                            }
+
+                            var type = string.Empty;
+                            if (devClass == ETrackedDeviceClass.Controller)
+                            {
+                                if (role == ETrackedControllerRole.LeftHand)
+                                {
+                                    type = "leftController";
+                                }
+                                else if (role == ETrackedControllerRole.RightHand)
+                                {
+                                    type = "rightController";
+                                }
+                                else
+                                {
+                                    type = "controller";
+                                }
+                            }
+                            else if (devClass == ETrackedDeviceClass.GenericTracker)
+                            {
+                                type = "tracker";
+                            }
+                            else if (devClass == ETrackedDeviceClass.TrackingReference)
+                            {
+                                type = "base";
+                            }
+
+                            var item = new[]
+                            {
+                            type,
+                            system.IsTrackedDeviceConnected(i)
+                                ? "connected"
+                                : "disconnected",
+                            isCharging
+                                ? "charging"
+                                : "discharging",
+                            (batteryPercentage * 100).ToString(),
+                            poses[i].eTrackingResult.ToString()
+                        };
+                            _deviceListLock.EnterWriteLock();
+                            try
+                            {
+                                _deviceList.Add(item);
+                            }
+                            finally
+                            {
+                                _deviceListLock.ExitWriteLock();
+                            }
+
+                            break;
+                        }
+                }
+            }
+        }
+
+        internal EVROverlayError ProcessDashboard(CVROverlay overlay, ref ulong dashboardHandle, bool dashboardVisible)
+        {
+            var err = EVROverlayError.None;
+
+            if (dashboardHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX", ref dashboardHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    ulong thumbnailHandle = 0;
+                    err = overlay.CreateDashboardOverlay("VRCX", "VRCX", ref dashboardHandle, ref thumbnailHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    var iconPath = Path.Join(Program.BaseDirectory, "VRCX.png");
+                    err = overlay.SetOverlayFromFile(thumbnailHandle, iconPath);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(dashboardHandle, 1.5f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(dashboardHandle, VROverlayInputMethod.Mouse);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            var e = new VREvent_t();
+
+            while (overlay.PollNextOverlayEvent(dashboardHandle, ref e, (uint)Marshal.SizeOf(e)))
+            {
+                var type = (EVREventType)e.eventType;
+                if (type == EVREventType.VREvent_MouseMove)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseMoveEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), false, CefEventFlags.None);
+                }
+                else if (type == EVREventType.VREvent_MouseButtonDown)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, false, 1, CefEventFlags.LeftMouseButton);
+                }
+                else if (type == EVREventType.VREvent_MouseButtonUp)
+                {
+                    var m = e.data.mouse;
+                    var s = _wristOverlay.Size;
+                    _wristOverlay.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, true, 1, CefEventFlags.None);
+                }
+            }
+
+            if (dashboardVisible)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture1.NativePointer
+                };
+                err = overlay.SetOverlayTexture(dashboardHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+            }
+
+            return err;
+        }
+
+        internal EVROverlayError ProcessOverlay1(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible, uint overlayIndex)
+        {
+            var err = EVROverlayError.None;
+
+            if (overlayHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX1", ref overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = false;
+                    err = overlay.CreateOverlay("VRCX1", "VRCX1", ref overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayAlpha(overlayHandle, 0.9f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            if (overlayIndex != OpenVR.k_unTrackedDeviceIndexInvalid)
+            {
+                // http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices
+                // Scaling-Rotation-Translation
+                var m = Matrix.Scaling(0.25f);
+                m *= Matrix.RotationX(_rotation[0]);
+                m *= Matrix.RotationY(_rotation[1]);
+                m *= Matrix.RotationZ(_rotation[2]);
+                m *= Matrix.Translation(_translation[0], _translation[1], _translation[2]);
+                var hm34 = new HmdMatrix34_t
+                {
+                    m0 = m.M11,
+                    m1 = m.M21,
+                    m2 = m.M31,
+                    m3 = m.M41,
+                    m4 = m.M12,
+                    m5 = m.M22,
+                    m6 = m.M32,
+                    m7 = m.M42,
+                    m8 = m.M13,
+                    m9 = m.M23,
+                    m10 = m.M33,
+                    m11 = m.M43
+                };
+                err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, overlayIndex, ref hm34);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+            }
+
+            if (!dashboardVisible &&
+                DateTime.UtcNow.CompareTo(_nextOverlayUpdate) <= 0)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture1.NativePointer
+                };
+                err = overlay.SetOverlayTexture(overlayHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                if (!overlayVisible)
+                {
+                    err = overlay.ShowOverlay(overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = true;
+                }
+            }
+            else if (overlayVisible)
+            {
+                err = overlay.HideOverlay(overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                overlayVisible = false;
+            }
+
+            return err;
+        }
+
+        internal EVROverlayError ProcessOverlay2(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible)
+        {
+            var err = EVROverlayError.None;
+
+            if (overlayHandle == 0)
+            {
+                err = overlay.FindOverlay("VRCX2", ref overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    if (err != EVROverlayError.UnknownOverlay)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = false;
+                    err = overlay.CreateOverlay("VRCX2", "VRCX2", ref overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayAlpha(overlayHandle, 0.9f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    var m = Matrix.Scaling(1f);
+                    m *= Matrix.Translation(0, -0.3f, -1.5f);
+                    var hm34 = new HmdMatrix34_t
+                    {
+                        m0 = m.M11,
+                        m1 = m.M21,
+                        m2 = m.M31,
+                        m3 = m.M41,
+                        m4 = m.M12,
+                        m5 = m.M22,
+                        m6 = m.M32,
+                        m7 = m.M42,
+                        m8 = m.M13,
+                        m9 = m.M23,
+                        m10 = m.M33,
+                        m11 = m.M43
+                    };
+                    err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, OpenVR.k_unTrackedDeviceIndex_Hmd, ref hm34);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+                }
+            }
+
+            if (!dashboardVisible)
+            {
+                var texture = new Texture_t
+                {
+                    handle = _texture2.NativePointer
+                };
+                err = overlay.SetOverlayTexture(overlayHandle, ref texture);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                if (!overlayVisible)
+                {
+                    err = overlay.ShowOverlay(overlayHandle);
+                    if (err != EVROverlayError.None)
+                    {
+                        return err;
+                    }
+
+                    overlayVisible = true;
+                }
+            }
+            else if (overlayVisible)
+            {
+                err = overlay.HideOverlay(overlayHandle);
+                if (err != EVROverlayError.None)
+                {
+                    return err;
+                }
+
+                overlayVisible = false;
+            }
+
+            return err;
+        }
+        
+        public override ConcurrentQueue<KeyValuePair<string, string>> GetExecuteVrFeedFunctionQueue()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void ExecuteVrFeedFunction(string function, string json)
+        {
+            if (_wristOverlay == null) return;
+            if (_wristOverlay.IsLoading)
+                Restart();
+            _wristOverlay.ExecuteScriptAsync($"$app.{function}", json);
+        }
+        
+        public override ConcurrentQueue<KeyValuePair<string, string>> GetExecuteVrOverlayFunctionQueue()
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void ExecuteVrOverlayFunction(string function, string json)
+        {
+            if (_hmdOverlay == null) return;
+            if (_hmdOverlay.IsLoading)
+                Restart();
+            _hmdOverlay.ExecuteScriptAsync($"$app.{function}", json);
+        }
+    }
+}

Dotnet/Overlay/Cef/VRForm.Designer.cs

@@ -0,0 +1,110 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+// All rights reserved.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+namespace VRCX
+{
+    partial class VRForm
+    {
+        /// <summary>
+        /// 필수 디자이너 변수입니다.
+        /// </summary>
+        private System.ComponentModel.IContainer components = null;
+
+        /// <summary>
+        /// 사용 중인 모든 리소스를 정리합니다.
+        /// </summary>
+        /// <param name="disposing">관리되는 리소스를 삭제해야 하면 true이고, 그렇지 않으면 false입니다.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && (components != null))
+            {
+                components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Windows Form 디자이너에서 생성한 코드
+
+        /// <summary>
+        /// 디자이너 지원에 필요한 메서드입니다. 
+        /// 이 메서드의 내용을 코드 편집기로 수정하지 마세요.
+        /// </summary>
+        private void InitializeComponent()
+        {
+            this.components = new System.ComponentModel.Container();
+            this.timer = new System.Windows.Forms.Timer(this.components);
+            this.panel1 = new System.Windows.Forms.Panel();
+            this.panel2 = new System.Windows.Forms.Panel();
+            this.button_refresh = new System.Windows.Forms.Button();
+            this.button_devtools = new System.Windows.Forms.Button();
+            this.SuspendLayout();
+            // 
+            // panel1
+            // 
+            this.panel1.Location = new System.Drawing.Point(0, 0);
+            this.panel1.Margin = new System.Windows.Forms.Padding(4, 4, 4, 4);
+            this.panel1.Name = "panel1";
+            this.panel1.Size = new System.Drawing.Size(731, 768);
+            this.panel1.TabIndex = 0;
+            // 
+            // panel2
+            // 
+            this.panel2.Location = new System.Drawing.Point(740, 0);
+            this.panel2.Margin = new System.Windows.Forms.Padding(4, 4, 4, 4);
+            this.panel2.Name = "panel2";
+            this.panel2.Size = new System.Drawing.Size(731, 768);
+            this.panel2.TabIndex = 1;
+            // 
+            // button_refresh
+            // 
+            this.button_refresh.Location = new System.Drawing.Point(17, 777);
+            this.button_refresh.Margin = new System.Windows.Forms.Padding(4, 4, 4, 4);
+            this.button_refresh.Name = "button_refresh";
+            this.button_refresh.Size = new System.Drawing.Size(107, 34);
+            this.button_refresh.TabIndex = 27;
+            this.button_refresh.Text = "Refresh";
+            this.button_refresh.UseVisualStyleBackColor = true;
+            this.button_refresh.Click += new System.EventHandler(this.button_refresh_Click);
+            // 
+            // button_devtools
+            // 
+            this.button_devtools.Location = new System.Drawing.Point(133, 777);
+            this.button_devtools.Margin = new System.Windows.Forms.Padding(4, 4, 4, 4);
+            this.button_devtools.Name = "button_devtools";
+            this.button_devtools.Size = new System.Drawing.Size(107, 34);
+            this.button_devtools.TabIndex = 27;
+            this.button_devtools.Text = "DevTools";
+            this.button_devtools.UseVisualStyleBackColor = true;
+            this.button_devtools.Click += new System.EventHandler(this.button_devtools_Click);
+            // 
+            // VRForm
+            // 
+            this.AutoScaleDimensions = new System.Drawing.SizeF(144F, 144F);
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
+            this.ClientSize = new System.Drawing.Size(1483, 830);
+            this.Controls.Add(this.button_devtools);
+            this.Controls.Add(this.button_refresh);
+            this.Controls.Add(this.panel2);
+            this.Controls.Add(this.panel1);
+            this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
+            this.Margin = new System.Windows.Forms.Padding(4, 4, 4, 4);
+            this.MaximizeBox = false;
+            this.Name = "VRForm";
+            this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen;
+            this.Text = "VR";
+            this.ResumeLayout(false);
+
+        }
+
+        #endregion
+
+        private System.Windows.Forms.Timer timer;
+        private System.Windows.Forms.Panel panel1;
+        private System.Windows.Forms.Panel panel2;
+        private System.Windows.Forms.Button button_refresh;
+        private System.Windows.Forms.Button button_devtools;
+    }
+}

Dotnet/Overlay/Cef/VRForm.cs

@@ -0,0 +1,69 @@
+// Copyright(c) 2019-2025 pypy, Natsumi and individual contributors.
+//
+// This work is licensed under the terms of the MIT license.
+// For a copy, see <https://opensource.org/licenses/MIT>.
+
+using System.IO;
+using System.Windows.Forms;
+using CefSharp;
+using CefSharp.WinForms;
+
+namespace VRCX
+{
+    public partial class VRForm : WinformBase
+    {
+        public static VRForm Instance;
+        private ChromiumWebBrowser _browser1;
+        private ChromiumWebBrowser _browser2;
+
+        public VRForm()
+        {
+            Instance = this;
+            InitializeComponent();
+
+            _browser1 = new ChromiumWebBrowser(
+                Path.Join(Program.BaseDirectory, "html/vr.html?1")
+            )
+            {
+                DragHandler = new CefNoopDragHandler(),
+                RequestHandler = new CustomRequestHandler(),
+                BrowserSettings =
+                {
+                    DefaultEncoding = "UTF-8",
+                },
+                Dock = DockStyle.Fill
+            };
+
+            _browser2 = new ChromiumWebBrowser(
+                Path.Join(Program.BaseDirectory, "html/vr.html?2")
+            )
+            {
+                DragHandler = new CefNoopDragHandler(),
+                BrowserSettings =
+                {
+                    DefaultEncoding = "UTF-8",
+                },
+                Dock = DockStyle.Fill
+            };
+
+            JavascriptBindings.ApplyVrJavascriptBindings(_browser1.JavascriptObjectRepository);
+            JavascriptBindings.ApplyVrJavascriptBindings(_browser2.JavascriptObjectRepository);
+
+            panel1.Controls.Add(_browser1);
+            panel2.Controls.Add(_browser2);
+        }
+
+        private void button_refresh_Click(object sender, System.EventArgs e)
+        {
+            _browser1.ExecuteScriptAsync("location.reload()");
+            _browser2.ExecuteScriptAsync("location.reload()");
+            Program.VRCXVRInstance.Refresh();
+        }
+
+        private void button_devtools_Click(object sender, System.EventArgs e)
+        {
+            _browser1.ShowDevTools();
+            _browser2.ShowDevTools();
+        }
+    }
+}

Dotnet/Overlay/Cef/VRForm.resx

@@ -0,0 +1,123 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="timer.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+</root>