GpuBackbuffer.cs

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

public class GpuBackbuffer : BackbufferBase
{
    // Surface state.  All access MUST occur on the GL thread after Initialize() is called.
    private SKBitmap? _cpuBitmap;   // temporary CPU surface used before GRContext is ready
    private SKSurface? _surface;
    private bool _disposed;
    private GRContext? _context;
    private sealed record Resolution(int Width, int Height);
    private Resolution? _requestedResolution;
 
    private int _targetFps = 60;
    private readonly object _msaaSyncRoot = new();
    private int _msaaSampleCount = 1;
    private long _msaaConfigurationRevision;
    private long _appliedMsaaConfigurationRevision = -1;
    private int _actualMsaaSampleCount = 1;
    private int _maxSupportedMsaaSampleCount = 1;
 
    // Frame counter used to compute the actual rendered FPS.
    // Incremented on the GL thread by RecordFrame(); consumed atomically by the engine's CPS sampler.
    private long _frameCount;

    public int TargetFps
    {
        get => _targetFps;
        set => _targetFps = value < 0 ? 0 : value;
    }

    public bool VSync { get; set; } = true;

    public int MsaaSampleCount
    {
        get
        {
            lock (_msaaSyncRoot)
                return _msaaSampleCount;
        }
        set
        {
            int normalized = value < 1 ? 1 : value;
 
            lock (_msaaSyncRoot)
            {
                if (_msaaSampleCount == normalized)
                    return;
 
                _msaaSampleCount = normalized;
                _msaaConfigurationRevision++;
            }
        }
    }

    public int ActualMsaaSampleCount => Volatile.Read(ref _actualMsaaSampleCount);

    public int MaxSupportedMsaaSampleCount => Volatile.Read(ref _maxSupportedMsaaSampleCount);

    internal bool IsMsaaSurfaceRecreationPending =>
        Volatile.Read(ref _appliedMsaaConfigurationRevision) !=
        Volatile.Read(ref _msaaConfigurationRevision);

    public GpuBackbuffer(int width, int height)
        : base(width, height)
    {
        // Apply the current engine configuration defaults for the settings this backbuffer
        // explicitly copies at construction time: TargetFps, VSync, and MsaaSampleCount.
        var config = Engine.Instance.Configuration;
        TargetFps = config.TargetFPS;
        VSync = config.VSync;
        MsaaSampleCount = config.MsaaSampleCount;
 
        CreateCpuSurface(width, height);
    }

    public override bool IsGlThreadRendered => true;

    public void Initialize(GRContext grContext, int width, int height)
    {
        if (width <= 0 || height <= 0)
            return;
        if (_disposed) return;
 
        (int requestedSampleCount, long configurationRevision) = GetMsaaConfigurationSnapshot();
        int maxSupportedSampleCount = grContext.GetMaxSurfaceSampleCount(SKColorType.Rgba8888);
        Volatile.Write(ref _maxSupportedMsaaSampleCount, maxSupportedSampleCount);
 
        DisposeSurface();
        int actualSampleCount = CreateGpuSurface(grContext, width, height, requestedSampleCount);
        _context = grContext;
        // SizeChanged updates live viewports. Only this handoff needs the simulation
        // gate; GPU creation and ordinary command replay never hold it.
        lock (RenderStateSynchronization.SyncRoot)
            UpdateSize(width, height);
 
        MarkMsaaConfigurationApplied(configurationRevision, actualSampleCount);
 
        // Set canvas into a known state for the first frame on the new surface.
        BeginFrame();
        Canvas.Clear(ClearColor);
    }

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

    public bool EnsureInitialized(GRContext context)
    {
        ArgumentNullException.ThrowIfNull(context);
        if (_disposed) return false;
        var request = Interlocked.Exchange(ref _requestedResolution, null);
        int width = request?.Width ?? Width;
        int height = request?.Height ?? Height;
        if (ReferenceEquals(_context, context) &&
            width == Width &&
            height == Height &&
            !IsMsaaSurfaceRecreationPending)
        {
            return false;
        }
 
        Initialize(context, width, height);
        return true;
    }

    public override SKCanvas Canvas => _surface?.Canvas
        ?? throw new InvalidOperationException($"{nameof(GpuBackbuffer)} surface is not initialized.");

    protected internal override void BeginFrame()
    {
        if (_disposed || _surface is null) 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()
    {
        if (_disposed || _surface is null) return;
        _surface.Flush();
    }

    protected internal override void DrawTileFrame(Tile tile, RectangleF destRectScreen)
    {
        var image = tile.CurrentFrame.SkImage;
        if (image is null || _surface is null) return;
 
        var canvas = _surface.Canvas;
 
        canvas.DrawImage(image, destRectScreen.ToSKRect());
    }

    protected internal override SKImage Snapshot()
    {
        if (_disposed || _surface is null)
            throw new ObjectDisposedException(nameof(GpuBackbuffer));
 
        return _surface.Snapshot();
    }
 
    // ── Actual FPS tracking ──────────────────────────────────────────────────

    public void RecordFrame() => Interlocked.Increment(ref _frameCount);

    internal long ConsumeFrameCount() => Interlocked.Exchange(ref _frameCount, 0);
 
    // ── Surface creation helpers ─────────────────────────────────────────────
 
    internal (int SampleCount, long Revision) GetMsaaConfigurationSnapshot()
    {
        lock (_msaaSyncRoot)
            return (_msaaSampleCount, _msaaConfigurationRevision);
    }
 
    internal void MarkMsaaConfigurationApplied(long revision, int actualSampleCount)
    {
        Volatile.Write(ref _actualMsaaSampleCount, actualSampleCount);
        Volatile.Write(ref _appliedMsaaConfigurationRevision, revision);
    }
 
    private int CreateGpuSurface(
        GRContext grContext,
        int width,
        int height,
        int requestedSampleCount)
    {
        // Rgba8888 / Premul is the natural format for an OpenGL render target.
        var info = new SKImageInfo(width, height, SKColorType.Rgba8888, SKAlphaType.Premul);
        _surface = SKSurface.Create(grContext, budgeted: true, info, requestedSampleCount);
 
        if (_surface is not null)
            return requestedSampleCount;
 
        // SKSurface.Create returns null when the requested MSAA sample count is not supported
        // by the hardware or driver. Fall back to no MSAA (sample count 1) so the surface
        // is always valid after Initialize() completes.
        if (requestedSampleCount > 1)
            _surface = SKSurface.Create(grContext, budgeted: true, info, sampleCount: 1);
 
        if (_surface is null)
            throw new InvalidOperationException(
                $"Failed to create a {nameof(GpuBackbuffer)} GPU surface ({width}x{height}). " +
                "The GRContext may be invalid or the pixel format is not renderable.");
 
        return 1;
    }
 
    private void CreateCpuSurface(int width, int height)
    {
        // Bgra8888 matches the native Windows GDI pixel format; used only before
        // GRContext becomes available so rendering is always valid from frame one.
        var info = new SKImageInfo(width, height, SKColorType.Bgra8888, SKAlphaType.Premul);
        _cpuBitmap = new SKBitmap(info);
        _surface = SKSurface.Create(info, _cpuBitmap.GetPixels(), _cpuBitmap.Info.RowBytes);
    }
 
    private void DisposeSurface()
    {
        _surface?.Dispose();
        _surface = null;
        _cpuBitmap?.Dispose();
        _cpuBitmap = null;
    }
 
    // Called by a platform's GL deinitialization callback, while its old context
    // is still current. Logical state and Engine-owned recordings survive a
    // temporary context loss; EnsureInitialized will attach the next context.
    internal void ReleaseContext()
    {
        DisposeSurface();
        _context = null;
    }

    public override void Dispose()
    {
        if (_disposed) return;
        _disposed = true;
        base.Dispose();
        DisposeSurface();
        GC.SuppressFinalize(this);
    }
}