RenderSurfaceAdapterBase.cs

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

public abstract class RenderSurfaceAdapterBase
{
    private sealed class PresentationState(int bufferWidth, int bufferHeight, int adapterWidth, int adapterHeight)
    {
        internal readonly int BufferWidth = bufferWidth, BufferHeight = bufferHeight;
        internal readonly int AdapterWidth = adapterWidth, AdapterHeight = adapterHeight;
        internal readonly PresentationTransform Transform = PresentationTransform.Fit(bufferWidth, bufferHeight, adapterWidth, adapterHeight);
    }
 
    private readonly object _presentationSync = new();
    private PresentationState _presentation = new(1, 1, 0, 0);
    internal bool InitialSizeAvailable { get; private set; }

    public PresentationTransform Presentation => Volatile.Read(ref _presentation).Transform;

    public float PresentationScale => Presentation.Scale;
 
    internal void SetBackbufferSize(int width, int height)
    {
        lock (_presentationSync)
        {
            var state = _presentation;
            Volatile.Write(ref _presentation, new(width, height, state.AdapterWidth, state.AdapterHeight));
        }
    }

    public Point AdapterPxToScreenPx(PointF adapterPx)
    {
        Presentation.TryAdapterPxToScreenPx(adapterPx, out var screen);
        // Floor is essential: a fractional negative margin must not truncate to the edge pixel zero.
        return new Point((int)Math.Floor(screen.X), (int)Math.Floor(screen.Y));
    }

    public void DrawImage(SKCanvas canvas, SKImage image, SKColor clearColor)
    {
        var state = Volatile.Read(ref _presentation);
        // A queued CPU snapshot may precede an explicit resolution change. Fit that complete
        // image using the same authoritative calculation until its replacement arrives.
        var transform = image.Width == state.BufferWidth && image.Height == state.BufferHeight
            ? state.Transform : PresentationTransform.Fit(image.Width, image.Height, state.AdapterWidth, state.AdapterHeight);
        canvas.Clear(clearColor);
        if (transform.Scale <= 0) return;
        canvas.DrawImage(image, transform.DestinationRect, PresentationSampling);
    }
 
    internal static SKSamplingOptions PresentationSampling => new(
        Engine.Instance.Configuration.RenderScalingFilter == RenderScalingFilter.NearestNeighbor
            ? SKFilterMode.Nearest : SKFilterMode.Linear);

    public event Action<RenderSurfaceAdapterResizedEventArgs>? Resized;

    public int Width
    {
        get => Volatile.Read(ref _presentation).AdapterWidth;
        protected set => SetDestinationSize(value, Height);
    }

    public int Height
    {
        get => Volatile.Read(ref _presentation).AdapterHeight;
        protected set => SetDestinationSize(Width, value);
    }

    protected RenderSurfaceAdapterBase(int destWidth, int destHeight)
        : this(destWidth, destHeight, initialSizeAvailable: true) { }

    protected RenderSurfaceAdapterBase(int destWidth, int destHeight, bool initialSizeAvailable)
    {
        SetDestinationSize(destWidth, destHeight);
        InitialSizeAvailable = initialSizeAvailable;
    }

    protected void SetDestinationSize(int destWidth, int destHeight)
    {
        var sizeAvailable = destWidth > 0 && destHeight > 0;
        if (destWidth == Width && destHeight == Height && InitialSizeAvailable == sizeAvailable)
            return;
 
        var oldWidth = Width;
        var oldHeight = Height;
 
        InitialSizeAvailable = sizeAvailable;
        lock (_presentationSync)
        {
            var state = _presentation;
            Volatile.Write(ref _presentation, new(state.BufferWidth, state.BufferHeight, destWidth, destHeight));
        }
        Resized?.Invoke(new RenderSurfaceAdapterResizedEventArgs(this, oldWidth, oldHeight, Width, Height));
    }

    public abstract void Present(SKImage bufferImage, SKRectI bufferRect, SKRect destRect);
}