BlazorGameHostBase.cs

using Gondwana.Blazor.Logging;
using Gondwana.Blazor.Rendering;
using Gondwana.Hosting;
using Gondwana.Rendering;
using Gondwana.Scenes;
using Microsoft.JSInterop;
 
namespace Gondwana.Blazor.Hosting;

public abstract class BlazorGameHostBase : GameHostBase
{
    private readonly IJSRuntime _jsRuntime;
    private DotNetObjectReference<BlazorGameHostBase>? _dotNetRef;
    private IJSObjectReference? _module;
    private BlazorLogicalResolutionBinding? _logicalResolution;

    public void ConfigureLogicalResolution(int logicalWidth, int logicalHeight)
    {
        EnsureNotDisposed();
        if (!Engine.IsInitialized)
            throw new InvalidOperationException("Logical resolution can only be configured after engine initialization.");
        if (_logicalResolution is not null)
            throw new InvalidOperationException("Logical resolution is already configured for this host.");
 
        _logicalResolution = new BlazorLogicalResolutionBinding(
            RenderSurfaceHost.RenderSurfaceAdapter,
            logicalWidth,
            logicalHeight,
            scale => Engine.Configuration.RenderScale = scale);
    }

    protected BlazorGameHostBase(IJSRuntime jsRuntime)
    {
        _jsRuntime = jsRuntime ?? throw new ArgumentNullException(nameof(jsRuntime));
    }

    protected abstract BlazorRenderSurfaceComponentBase RenderSurfaceComponent { get; }

    protected abstract RenderSurfaceHostBase RenderSurfaceHost { get; }

    protected virtual bool RenderSurfaceDrivesBrowserFrames => false;

    protected abstract void BindSceneCore(Scene scene);

    protected sealed override void ConfigurePlatform()
    {
        if (OperatingSystem.IsBrowser())
            BrowserConsoleLogging.AttachToEngineLogger();
 
        OnConfigurePlatform();
    }

    protected sealed override void ConfigureKeyboard()
    {
        Engine.InitializeBlazorKeyboardAdapter(RenderSurfaceComponent);
        OnKeyboardAdapterInitialized();
    }

    protected sealed override void ConfigureMouse()
    {
        Engine.InitializeBlazorMouseAdapter(RenderSurfaceComponent);
        OnMouseAdapterInitialized();
    }

    protected sealed override void ConfigureGamepads()
    {
        OnConfigureGamepads();
    }

    protected sealed override void ConfigureTouch()
    {
        Engine.InitializeBlazorTouchAdapter(RenderSurfaceComponent);
        OnTouchAdapterInitialized();
    }

    protected sealed override void BindScene()
    {
        var scene = Scene
            ?? throw new InvalidOperationException(
                $"{nameof(BindScene)} cannot be called before {nameof(Scene)} has been created.");
 
        BindSceneCore(scene);
    }

    protected sealed override SynchronizationContext? GetSynchronizationContext()
    {
        var syncContext = base.GetSynchronizationContext();
 
        if (syncContext is not null)
            return syncContext;
 
        if (!OperatingSystem.IsBrowser())
            return null;
 
        syncContext = new SynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(syncContext);
 
        return syncContext;
    }

    protected sealed override void StartEngineCore(SynchronizationContext syncContext)
    {
        if (OperatingSystem.IsBrowser())
        {
            Engine.StartTimerDriven(syncContext);
 
            if (!RenderSurfaceDrivesBrowserFrames)
                _ = StartBrowserRenderLoopAsync();
 
            return;
        }
 
        base.StartEngineCore(syncContext);
    }
 
    private async Task StartBrowserRenderLoopAsync()
    {
        var module = await _jsRuntime.InvokeAsync<IJSObjectReference>(
            "import",
            "./_content/Gondwana.Blazor/gondwana-blazor.js");
 
        _module = module;
        _dotNetRef = DotNetObjectReference.Create(this);
 
        await module.InvokeVoidAsync("startRenderLoop", _dotNetRef);
    }

    [JSInvokable]
    public void OnAnimationFrame()
    {
        if (Engine.IsRunning)
            Engine.Tick();
    }

    protected sealed override void StopEngineCore()
    {
        if (_module is not null)
            _ = _module.InvokeVoidAsync("stopRenderLoop");
 
        base.StopEngineCore();
    }

    protected sealed override void OnInputConfigured()
    {
        base.OnInputConfigured();
        InitializeWidgetInput(RenderSurfaceHost);
    }

    protected sealed override void OnDisposed()
    {
        _logicalResolution?.Dispose();
        _logicalResolution = null;
 
        _dotNetRef?.Dispose();
        _dotNetRef = null;
 
        if (_module is not null)
        {
            _ = _module.DisposeAsync();
            _module = null;
        }
 
        OnBlazorDisposed();
    }

    protected virtual void OnConfigurePlatform()
    {
    }

    protected virtual void OnKeyboardAdapterInitialized()
    {
    }

    protected virtual void OnMouseAdapterInitialized()
    {
    }

    protected virtual void OnConfigureGamepads()
    {
    }

    protected virtual void OnTouchAdapterInitialized()
    {
    }

    protected virtual void OnBlazorDisposed()
    {
    }
}