BlazorGpuRenderSurfaceComponent.razor.cs

using System.Runtime.Versioning;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Microsoft.JSInterop;
using SkiaSharp;
using SkiaSharp.Views.Blazor;
 
namespace Gondwana.Blazor.Rendering;

[SupportedOSPlatform("browser")]
public sealed partial class BlazorGpuRenderSurfaceComponent : BlazorRenderSurfaceComponentBase
{
    private readonly string _generatedCanvasId = $"gondwana-webgl-{Guid.NewGuid():N}";
    private BlazorSkiaGlView? _glView;
    private IJSObjectReference? _module;
    private GRContext? _grContext;
    private IReadOnlyDictionary<string, object>? _gpuCanvasAttributes;
    private string _canvasId = string.Empty;
    private bool _backbufferNeedsRender = true;
    private bool _disposed;

    public BlazorGpuRenderSurfaceAdapter Adapter { get; private set; } = null!;

    public RenderSurfaceHost<GpuBackbuffer> Host { get; private set; } = null!;

    private IReadOnlyDictionary<string, object>? GpuCanvasAttributes => _gpuCanvasAttributes;
 
    internal override ValueTask<CanvasOffset> GetCanvasOffsetAsync()
        => _module is null ? ValueTask.FromResult(default(CanvasOffset))
           : _module.InvokeAsync<CanvasOffset>("getCanvasOffset", _canvasId);
 
    internal override RenderSurfaceAdapterBase? InputSurfaceAdapter => Adapter;

    protected override void OnInitialized()
    {
        Adapter = new BlazorGpuRenderSurfaceAdapter();
        Host = new RenderSurfaceHost<GpuBackbuffer>(Adapter);
        Adapter.AttachToEngine();
    }

    protected override void OnParametersSet()
    {
        base.OnParametersSet();
 
        var attributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        if (CanvasAttributes is not null)
        {
            foreach (var attribute in CanvasAttributes)
                attributes[attribute.Key] = attribute.Value;
        }
 
        if (attributes.TryGetValue("id", out var id) && id is not null)
            _canvasId = id.ToString() ?? _generatedCanvasId;
        else
            attributes["id"] = _canvasId = _generatedCanvasId;
 
        attributes[nameof(SKGLView.OnPaintSurface)] =
            (Action<SKPaintGLSurfaceEventArgs>)HandlePaintSurface;
 
        _gpuCanvasAttributes = attributes;
    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (!firstRender)
            return;
 
        _module = await JS.InvokeAsync<IJSObjectReference>(
            "import",
            "./_content/Gondwana.Blazor/gondwana-blazor.js");
 
        try
        {
            await _module.InvokeVoidAsync("focusElementById", _canvasId);
            await _module.InvokeVoidAsync("suppressBrowserInputDefaultsById", _canvasId);
        }
        catch
        {
            // Focus is best-effort; browser policy may reject programmatic focus.
        }
    }
 
    private void HandlePaintSurface(SKPaintGLSurfaceEventArgs e)
    {
        long telemetryGeneration = Host?.Telemetry?.BeginSample() ?? 0;
        if (_disposed)
            return;
 
        var width = e.Info.Width;
        var height = e.Info.Height;
        Adapter.BeginPaint(width, height);
 
        if (width <= 0 || height <= 0 || e.Surface.Context is not GRContext grContext)
        {
            e.Surface.Canvas.Clear(SKColors.Black);
            return;
        }
 
        var backbuffer = (GpuBackbuffer)Host.Backbuffer;
        _grContext = grContext;
        if (backbuffer.EnsureInitialized(grContext))
            _backbufferNeedsRender = true;
 
        var engine = Engine.Instance;
        if (!engine.IsRunning)
        {
            e.Surface.Canvas.Clear(backbuffer.ClearColor);
            return;
        }
 
        // SKGLView owns the browser rAF for the GPU path. Advance simulation first so a
        // foreground frame request, when due, can be rendered in this same paint callback.
        engine.Tick();
 
        bool engineFrameRequested = Adapter.ConsumeFrameRequest();
        bool renderScene = _backbufferNeedsRender || engineFrameRequested;
 
        bool presented = renderScene
            ? Host.GlRenderToCanvas(e.Surface.Canvas)
            : Host.GlDrawCurrentFrameToCanvas(e.Surface.Canvas);
 
        if (!presented)
        {
            e.Surface.Canvas.Clear(backbuffer.ClearColor);
            return;
        }
 
        if (renderScene)
            _backbufferNeedsRender = false;
 
        // Count successful WebGL paint/presentation callbacks. This intentionally measures the
        // browser GPU presentation cadence, which may differ from the engine's TargetFPS.
        backbuffer.RecordFrame();
        if (telemetryGeneration != 0) Host!.Telemetry!.Record(telemetryGeneration, "presentation.count", 1);
    }

    public override void Dispose()
    {
        if (_disposed)
            return;
 
        _disposed = true;
 
        Adapter?.Dispose();
        Host?.Dispose();
 
        _grContext = null;
        _glView = null;
 
        if (_module is not null)
        {
            _ = _module.DisposeAsync();
            _module = null;
        }
    }
}