SwapChainPanel.cs

#if WINDOWS
using AndroidApp.Controls;
using Core.Helpers;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;
using Microsoft.UI.Xaml.Media;
using Silk.NET.Core.Contexts;
using Silk.NET.Core.Native;
using Silk.NET.Vulkan;
using Silk.NET.Vulkan.Extensions.KHR;
using SkiaSharp.Views.Windows;
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace AndroidApp.Platforms.Windows.Controls;

internal sealed unsafe class VkSurface : IVkSurface, IDisposable
{
    private readonly Vk _vk = Vk.GetApi();
    private readonly Allocator _alloter = new();
    private readonly nint _hwnd;

    public VkSurface(nint hwnd)
    {
        _hwnd = hwnd;
    }

    ~VkSurface()
    {
        Dispose();
    }

    public VkNonDispatchableHandle Create<T>(VkHandle instance, T* allocator) where T : unmanaged
    {
        if (!_vk.TryGetInstanceExtension(new Instance(instance.Handle), out KhrWin32Surface win32Surface))
        {
            throw new InvalidOperationException("KHR Win32 Surface extension is not supported.");
        }

        Win32SurfaceCreateInfoKHR createInfo = new()
        {
            SType = StructureType.Win32SurfaceCreateInfoKhr,
            Hinstance = 0, // TODO: supply real HINSTANCE if needed
            Hwnd = _hwnd
        };

        SurfaceKHR surface;
        if (win32Surface.CreateWin32Surface(new Instance(instance.Handle), &createInfo, (AllocationCallbacks*)allocator, &surface) != Result.Success)
        {
            throw new InvalidOperationException("Failed to create Win32 surface.");
        }

        return new VkNonDispatchableHandle(surface.Handle);
    }

    public byte** GetRequiredExtensions(out uint count)
    {
        count = 2;
        return _alloter.Alloc([KhrSurface.ExtensionName, KhrWin32Surface.ExtensionName]);
    }

    public void Dispose()
    {
        _alloter.Dispose();
        _vk.Dispose();
        GC.SuppressFinalize(this);
    }
}

internal sealed class Timer : IDisposable
{
    private readonly Stopwatch _stopwatch = new();
    private readonly float _frequency = 1.0f / Stopwatch.Frequency;

    public float DeltaTime { get; private set; }
    public float TotalTime { get; private set; }

    public void Start() => _stopwatch.Start();
    public void Stop() => _stopwatch.Stop();

    public void Update()
    {
        long elapsedTicks = _stopwatch.ElapsedTicks;
        DeltaTime = elapsedTicks * _frequency;
        TotalTime += DeltaTime;
        _stopwatch.Restart();
    }

    public void Dispose()
    {
        _stopwatch.Stop();
        _stopwatch.Reset();
    }
}

internal sealed class FrameCallback
{
    private readonly Timer _timer = new();
    private readonly ISwapChainPanel _swapChainPanel;

    public FrameCallback(ISwapChainPanel swapChainPanel)
    {
        _swapChainPanel = swapChainPanel;
        CompositionTarget.Rendering += OnRendering;
        _timer.Start();
    }

    private void OnRendering(object? sender, object e)
    {
        _timer.Update();
        _swapChainPanel.Update(_timer.DeltaTime, _timer.TotalTime);
        _timer.Update();
        _swapChainPanel.Render(_timer.DeltaTime, _timer.TotalTime);
    }

    public void Stop()
    {
        CompositionTarget.Rendering -= OnRendering;
        _timer.Stop();
        _timer.Dispose();
    }
}

internal static class Win32
{
    public static int WS_VISIBLE = 0x10000000;

    public static int WS_CAPTION = 0x00C00000;
    public static int WS_SYSMENU = 0x00080000;
    public static int WS_MINIMIZEBOX = 0x00020000;
    public static int WS_MAXIMIZEBOX = 0x00010000;
    public static int WS_THICKFRAME = 0x00040000;
    public static int WS_OVERLAPPED = 0x00000000;
    public static int WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;

    public static int WS_TOPMOST = 0x00000008;

    public static int WS_MAXIMIZE = 0x01000000;
    public static int WS_MINIMIZE = 0x20000000;

    [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
    public static extern nint CreateWindowExW
    (
        int exStyle,
        string className,
        string windowName,
        int style,
        int x,
        int y,
        int width,
        int height,
        nint parent,
        nint menu,
        nint instance,
        nint param
    );

    [DllImport("user32.dll", SetLastError = true)]
    public static extern bool SetWindowPos(
        nint hWnd,
        nint hWndInsertAfter,
        int X,
        int Y,
        int cx,
        int cy,
        uint uFlags);
}

internal sealed class SwapChainPanel : Microsoft.UI.Xaml.Controls.SwapChainPanel
{
    private ISwapChainPanel? _swapChainPanel;
    private FrameCallback? _frameCallback;
    private VkSurface? _vkSurface;
    private nint _hwnd;

    public SwapChainPanel(ISwapChainPanel swapChainPanel)
    {
        _swapChainPanel = swapChainPanel;

        _hwnd = CreateRenderWindow();

        if (_hwnd == 0)
            throw new Exception("Failed to create child HWND.");

        SetWindowPos(_hwnd);

        _vkSurface = new VkSurface(_hwnd);

        _swapChainPanel.CreateSwapChainPanel(_vkSurface);

        _frameCallback = new FrameCallback(_swapChainPanel);

        Loaded += OnLoaded;
        Unloaded += OnUnloaded;
        SizeChanged += OnSizeChanged;
    }

    private void OnLoaded(object sender, RoutedEventArgs e)
    {
        if (_swapChainPanel is null)
            return;

        var mauiWindow = Microsoft.Maui.Controls.Application.Current.Windows[0];
        var winuiWindow = (Microsoft.UI.Xaml.Window)mauiWindow.Handler.PlatformView;
        nint parentHwnd = WinRT.Interop.WindowNative.GetWindowHandle(winuiWindow);

        _hwnd = CreateRenderWindow();

        if (_hwnd == 0)
            throw new Exception("Failed to create child HWND.");

        SetWindowPos(_hwnd);

        _vkSurface = new VkSurface(_hwnd);

        _swapChainPanel.CreateSwapChainPanel(_vkSurface);

        _frameCallback = new FrameCallback(_swapChainPanel);
    }

    private nint CreateRenderWindow(string wndClass = "STATIC", string title = "RenderView")
    {
        nint hwnd = Win32.CreateWindowExW
        (
            0, //Win32.WS_TOPMOST,
            wndClass,
            title,
            Win32.WS_OVERLAPPEDWINDOW | Win32.WS_VISIBLE,
            0,
            0,
            1920,
            1080,
            IntPtr.Zero,
            0,
            0,
            0
        );

        return hwnd;
    }

    private void OnUnloaded(object sender, RoutedEventArgs e)
    {
        _frameCallback?.Stop();
        _frameCallback = null;

        if (_swapChainPanel is not null)
        {
            _swapChainPanel.DestroySwapChainPanel();
        }

        _vkSurface?.Dispose();
        _vkSurface = null;
    }

    private void SetWindowPos(nint hwnd)
    {
        Win32.SetWindowPos
        (
            hwnd,
            IntPtr.Zero,
            0,
            0,
            1920,
            1080,
            0
        );
    }

    private void OnSizeChanged(object sender, SizeChangedEventArgs e)
    {
        if (_hwnd != 0)
        {
            SetWindowPos(_hwnd);
        }

        _swapChainPanel?.Resize((uint)e.NewSize.Width, (uint)e.NewSize.Height);
    }

    public void AttachSwapChainPanel(ISwapChainPanel swapChainPanel)
    {
        _swapChainPanel = swapChainPanel;
    }
}
#endif