BlazorBitmapRenderSurfaceComponent.razor.cs

using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Microsoft.AspNetCore.Components;
using Microsoft.JSInterop;
 
namespace Gondwana.Blazor.Rendering;

public sealed partial class BlazorBitmapRenderSurfaceComponent : BlazorRenderSurfaceComponentBase
{
    private ElementReference _canvasRef;
    private IJSObjectReference? _module;
    private DotNetObjectReference<BlazorBitmapRenderSurfaceComponent>? _dotNetRef;
    private bool _moduleLoaded;

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

    public RenderSurfaceHost<BitmapBackbuffer> Host { get; private set; } = null!;
 
    internal override ValueTask<CanvasOffset> GetCanvasOffsetAsync()
        => _module is null ? ValueTask.FromResult(default(CanvasOffset))
           : _module.InvokeAsync<CanvasOffset>("getCanvasOffset", _canvasRef);
 
    internal override RenderSurfaceAdapterBase? InputSurfaceAdapter => Adapter;

    protected override void OnInitialized()
    {
        Adapter = new BlazorBitmapRenderSurfaceAdapter(this);
        Host = new RenderSurfaceHost<BitmapBackbuffer>(Adapter);
    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (!firstRender) return;
 
        _module = await JS.InvokeAsync<IJSObjectReference>(
            "import", "./_content/Gondwana.Blazor/gondwana-blazor.js");
        _moduleLoaded = true;
        _dotNetRef = DotNetObjectReference.Create(this);
 
        await _module.InvokeVoidAsync("observeCanvasSize", _canvasRef, _dotNetRef);
 
        // Get the actual canvas size and update the adapter
        await UpdateCanvasSizeAsync();
 
        // Request focus so keyboard events are received without requiring a click.
        try
        {
            await _canvasRef.FocusAsync();
        }
        catch
        {
            // Focus request is best-effort; ignore failures (e.g. server-side pre-render).
        }
    }

    internal async Task UpdateCanvasSizeAsync()
    {
        if (!_moduleLoaded || _module is null) return;
 
        try
        {
            var size = await _module.InvokeAsync<CanvasSize>("getCanvasSize", _canvasRef);
            if (size.Width > 0 && size.Height > 0)
            {
                Adapter.UpdateSize(size.Width, size.Height);
            }
        }
        catch
        {
            // Size query failed; adapter remains at default 1x1
        }
    }

    [JSInvokable]
    public void OnCanvasSizeChanged(int width, int height)
    {
        if (width > 0 && height > 0)
        {
            Adapter.UpdateSize(width, height);
            PresentRetainedFrame();
        }
    }

    internal void EnqueueFrame(byte[] rgbaPixels, int width, int height, int x, int y, int canvasWidth, int canvasHeight)
    {
        if (!_moduleLoaded || _module is null) return;
 
        if (_module is IJSInProcessObjectReference inProcessModule)
        {
            try
            {
                inProcessModule.InvokeVoid("putImageData", _canvasRef, canvasWidth, canvasHeight, width, height, x, y, rgbaPixels, Adapter.Width, Adapter.Height,
                    Adapter.Presentation.DestinationRect.Left, Adapter.Presentation.DestinationRect.Top,
                    Adapter.Presentation.DestinationRect.Width, Adapter.Presentation.DestinationRect.Height,
                    Engine.Instance.Configuration.RenderScalingFilter == RenderScalingFilter.NearestNeighbor);
                return;
            }
            catch
            {
                // Fall back to the async path if sync interop is unavailable or fails.
            }
        }
 
        _ = InvokeAsync(async () =>
        {
            if (!_moduleLoaded || _module is null) return;
            await _module.InvokeVoidAsync("putImageData", _canvasRef, canvasWidth, canvasHeight, width, height, x, y, rgbaPixels, Adapter.Width, Adapter.Height,
                    Adapter.Presentation.DestinationRect.Left, Adapter.Presentation.DestinationRect.Top,
                    Adapter.Presentation.DestinationRect.Width, Adapter.Presentation.DestinationRect.Height,
                    Engine.Instance.Configuration.RenderScalingFilter == RenderScalingFilter.NearestNeighbor);
        });
    }
 
    private void PresentRetainedFrame()
    {
        if (_module is null) return;
        var rect = Adapter.Presentation.DestinationRect;
        _ = _module.InvokeVoidAsync("presentBitmap", _canvasRef, Adapter.Width, Adapter.Height,
            rect.Left, rect.Top, rect.Width, rect.Height,
            Engine.Instance.Configuration.RenderScalingFilter == RenderScalingFilter.NearestNeighbor);
    }

    public override void Dispose()
    {
        if (_moduleLoaded && _module is not null)
        {
            try
            {
                if (_module is IJSInProcessObjectReference inProcessModule)
                {
                    inProcessModule.InvokeVoid("unobserveCanvasSize", _canvasRef);
                }
                else
                {
                    _ = _module.InvokeVoidAsync("unobserveCanvasSize", _canvasRef);
                }
            }
            catch
            {
                // Observer cleanup is best-effort during disposal.
            }
        }
 
        _dotNetRef?.Dispose();
        _dotNetRef = null;
        _ = _module?.DisposeAsync();
        _module = null;
        _moduleLoaded = false;
 
        Adapter?.Dispose();
        Host?.Dispose();
    }
 
    private sealed class CanvasSize
    {
        public int Width { get; set; }

        public int Height { get; set; }
    }
}