BitmapBackbuffer.cs

using System.Drawing;
using Gondwana.Drawing;
using Gondwana.SkiaSharp;
using SkiaSharp;
 
namespace Gondwana.Rendering.Backbuffers;

public sealed class BitmapBackbuffer : BackbufferBase
{
    private readonly object _gate = new();       // guards _buffer/_surface/_disposed
    private SKBitmap? _buffer;
    private SKSurface? _surface;
    private bool _disposed;
 
    private sealed record Resolution(int Width, int Height);
    private Resolution? _requestedResolution;

    public BitmapBackbuffer(int width, int height) : base(width, height)
    {
        CreateSurface(width, height);
    }

    public static BitmapBackbuffer Create(int width, int height) => new BitmapBackbuffer(width, height);

    protected internal override void RequestResize(int width, int height)
    {
        Interlocked.Exchange(ref _requestedResolution, new(width, height));
    }

    public override SKCanvas Canvas
    {
        get { lock (_gate) return _surface!.Canvas; }
    }
 
    private readonly SKPaint _bitmapPaint = new SKPaint
    {
        FilterQuality = SKFilterQuality.None,
        BlendMode = SKBlendMode.SrcOver
    };

    public SKFilterQuality FilterQuality
    {
        get => _bitmapPaint.FilterQuality;
        set => _bitmapPaint.FilterQuality = value;
    }

    protected internal override void BeginFrame()
    {
        // if a resize was requested, do it now (render thread only)...
        if (Interlocked.Exchange(ref _requestedResolution, null) is { } request)
        {
            var w = request.Width;
            var h = request.Height;
 
            if (w > 0 && h > 0 && (w != Width || h != Height))
            {
                lock (_gate)
                {
                    if (_disposed) return;
                    DisposeSurface_NoLock();
                    CreateSurface(w, h);
                    UpdateSize(w, h); // tell base about new logical size
                }
            }
        }
 
        // Prepare for drawing.
        lock (_gate)
        {
            if (_disposed) return;
            var c = _surface!.Canvas;
            c.RestoreToCount(1);
            c.Save();
            c.ResetMatrix();
            c.ClipRect(new SKRect(0, 0, Width, Height));
        }
    }

    protected internal override void EndFrame()
    {
        lock (_gate)
        {
            if (_disposed || _surface is null) return;
            _surface.Flush();
        }
    }

    protected internal override void DrawTileFrame(Tile tile, RectangleF destRectScreen)
    {
        var bmp = tile.CurrentFrame.SkBitmap;
 
        if (bmp is null)
            return;
 
        Canvas.DrawBitmap(bmp, destRectScreen.ToSKRect(), _bitmapPaint);
    }

    protected internal override SKImage Snapshot()
    {
        lock (_gate)
        {
            if (_disposed || _surface is null)
                throw new ObjectDisposedException(nameof(BitmapBackbuffer));
 
            return _surface.Snapshot(); // immutable; safe to use on UI thread
        }
    }
 
    private void CreateSurface(int width, int height)
    {
        var info = new SKImageInfo(width, height, SKColorType.Bgra8888, SKAlphaType.Premul);
        _buffer = new SKBitmap(info);
        _surface = SKSurface.Create(info, _buffer.GetPixels(), _buffer.Info.RowBytes);
    }
 
    private void DisposeSurface_NoLock()
    {
        _surface?.Dispose(); _surface = null;
        _buffer?.Dispose(); _buffer = null;
    }

    public override void Dispose()
    {
        lock (_gate)
        {
            if (_disposed) return;
 
            _disposed = true;
            base.Dispose();
            DisposeSurface_NoLock();
        }
    }
}