RenderSurfaceHostBase.cs

using Gondwana.Effects;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.Timers;
using SkiaSharp;
 
namespace Gondwana.Rendering;

public abstract class RenderSurfaceHostBase : IDisposable
{
    public Diagnostics.TelemetrySource? Telemetry { get; internal set; }
    internal RenderFrameMailbox FrameMailbox { get; } = new();
    internal bool UsesRenderFrameSnapshots => !OperatingSystem.IsBrowser() && Backbuffer is GpuBackbuffer;
    internal virtual void ProduceRenderFrameSnapshot(long tick) { }

    protected RenderSurfaceHostBase()
    {
        Effects = new EffectsManager(this);
        RenderSurfaceHostRegistry.Register(this);
    }

    ~RenderSurfaceHostBase() => Dispose(false);

    public abstract BackbufferBase Backbuffer { get; }

    public float PresentationScale => RenderSurfaceAdapter?.PresentationScale ?? 0f;
 
    internal virtual void RequestRenderScale(float scale) { }
    internal virtual void InvalidatePresentation() { }

    public abstract Scene Scene { get; }

    public abstract RenderSurfaceAdapterBase? RenderSurfaceAdapter { get; }

    public abstract ViewManager ViewManager { get; }

    public EffectsManager Effects { get; }

    public event Action<GpuRenderSynchronizationDiagnostics>? GpuRenderSynchronizationDiagnosticsCalculated;

    public SKImage? GlRenderAndSnapshot()
    {
        if (!Backbuffer.IsGlThreadRendered)
            return null;
 
        if (UsesRenderFrameSnapshots)
            return ReplayRenderFrameSnapshot();
 
        bool collectSynchronizationDiagnostics =
            GpuRenderSynchronizationDiagnosticsCalculated is not null;
        long waitStarted = collectSynchronizationDiagnostics
            ? HighResTimer.GetCurrentTick()
            : 0;
        long lockAcquired = 0;
        long lockReleased = 0;
        SKImage? image;
 
        RenderStateSynchronization.EnterGpuRender();
        try
        {
            if (collectSynchronizationDiagnostics)
                lockAcquired = HighResTimer.GetCurrentTick();
 
            var tick = HighResTimer.GetCurrentTick();
 
            RenderToBackbuffer(tick);
            Backbuffer.EndFrame();
 
            image = Backbuffer.Snapshot();
 
            Backbuffer.BeginFrame();
 
            if (collectSynchronizationDiagnostics)
                lockReleased = HighResTimer.GetCurrentTick();
        }
        finally
        {
            RenderStateSynchronization.ExitGpuRender();
        }
 
        if (collectSynchronizationDiagnostics)
        {
            GpuRenderSynchronizationDiagnosticsCalculated?.Invoke(
                new GpuRenderSynchronizationDiagnostics(
                    HighResTimer.GetDuration(waitStarted, lockAcquired) * 1000d,
                    HighResTimer.GetDuration(lockAcquired, lockReleased) * 1000d));
        }
 
        return image;
    }
 
    private SKImage? ReplayRenderFrameSnapshot()
    {
        var diagnostics = GpuRenderSynchronizationDiagnosticsCalculated;
        long telemetryGeneration = Telemetry?.BeginSample() ?? 0;
        bool collectDiagnostics = diagnostics is not null || telemetryGeneration != 0;
        var slot = FrameMailbox.TryAcquire();
        if (slot is null) return Backbuffer.Snapshot();
 
        long acquired = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
        var counters = !collectDiagnostics ? default : FrameMailbox.Counters;
        long replayEnd = acquired;
        bool replayCompleted = false;
        long pictureReplayTicks = 0;
        long backbufferFlushTicks = 0;
        long snapshotTicks = 0;
        int commands = !collectDiagnostics ? 0 : slot.Frame!.CommandCount;
        double age = !collectDiagnostics ? 0 :
            HighResTimer.GetDuration(slot.Frame!.ProducedTick, acquired) * 1000d;
 
        try
        {
            var frame = slot.Frame!;
 
            // A logical resize invalidates geometry, but context/MSAA recreation does
            // not: recordings contain CPU resources and are uploaded by the current GL context.
            if (frame.Width != Backbuffer.Width || frame.Height != Backbuffer.Height)
            {
                long snapshotStart = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
                var resizedSnapshot = Backbuffer.Snapshot();
                if (collectDiagnostics)
                    snapshotTicks = HighResTimer.GetCurrentTick() - snapshotStart;
                return resizedSnapshot;
            }
 
            Backbuffer.BeginFrame();
 
            long pictureStart = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
            frame.Replay(Backbuffer.Canvas);
            long pictureEnd = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
 
            Backbuffer.EndFrame();
            long flushEnd = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
            replayCompleted = true;
 
            if (collectDiagnostics)
            {
                pictureReplayTicks = pictureEnd - pictureStart;
                backbufferFlushTicks = flushEnd - pictureEnd;
                replayEnd = flushEnd;
            }
 
            long snapshotStartTick = !collectDiagnostics ? 0 : HighResTimer.GetCurrentTick();
            var snapshot = Backbuffer.Snapshot();
            if (collectDiagnostics)
                snapshotTicks = HighResTimer.GetCurrentTick() - snapshotStartTick;
 
            return snapshot;
        }
        finally
        {
            try { Backbuffer.BeginFrame(); }
            finally { FrameMailbox.Release(slot); }
 
            if (collectDiagnostics)
            {
                double replayMs = HighResTimer.GetDuration(acquired, replayEnd) * 1000d;
                double pictureMs = HighResTimer.GetDuration(0, pictureReplayTicks) * 1000d;
                double flushMs = HighResTimer.GetDuration(0, backbufferFlushTicks) * 1000d;
                double snapshotMs = HighResTimer.GetDuration(0, snapshotTicks) * 1000d;
                if (telemetryGeneration != 0)
                {
                    if (replayCompleted)
                    {
                        Telemetry!.Record(telemetryGeneration, "replay.cpu.ms", replayMs);
                        Telemetry.Record(telemetryGeneration, "picture.cpu.ms", pictureMs);
                        Telemetry.Record(telemetryGeneration, "backbuffer.flush.cpu.ms", flushMs);
                    }
 
                    Telemetry!.Record(telemetryGeneration, "snapshot.cpu.ms", snapshotMs);
                    Telemetry.Record(telemetryGeneration, "snapshot.age.ms", age);
                    Telemetry.Record(telemetryGeneration, "mailbox.published.lifetime", counters.Published);
                    Telemetry.Record(telemetryGeneration, "mailbox.dropped.lifetime", counters.Dropped);
                    Telemetry.Record(telemetryGeneration, "mailbox.slots", counters.InUse);
                    Telemetry.Record(telemetryGeneration, "snapshot.commands.approximate", commands);
                }
                diagnostics?.Invoke(new(0, 0)
                {
                    ReplayMilliseconds = replayMs,
                    PictureReplayMilliseconds = pictureMs,
                    BackbufferFlushMilliseconds = flushMs,
                    SnapshotMilliseconds = snapshotMs,
                    SnapshotAgeMilliseconds = age,
                    PublishedSnapshots = counters.Published,
                    DroppedSnapshots = counters.Dropped,
                    SnapshotSlotsInUse = counters.InUse,
                    SnapshotCommandCount = commands
                });
            }
        }
    }

    public bool GlRenderToCanvas(SKCanvas destinationCanvas)
    {
        ArgumentNullException.ThrowIfNull(destinationCanvas);
 
        if (!Backbuffer.IsGlThreadRendered)
            return false;
 
        if (UsesRenderFrameSnapshots)
        {
            using var image = ReplayRenderFrameSnapshot();
            DrawCurrentSurface(destinationCanvas);
            return true;
        }
 
        RenderStateSynchronization.EnterGpuRender();
        try
        {
            var tick = HighResTimer.GetCurrentTick();
 
            RenderToBackbuffer(tick);
            Backbuffer.EndFrame();
 
            try
            {
                DrawCurrentSurface(destinationCanvas);
                return true;
            }
            finally
            {
                Backbuffer.BeginFrame();
            }
        }
        finally
        {
            RenderStateSynchronization.ExitGpuRender();
        }
    }

    public bool GlDrawCurrentFrameToCanvas(SKCanvas destinationCanvas)
    {
        ArgumentNullException.ThrowIfNull(destinationCanvas);
 
        if (!Backbuffer.IsGlThreadRendered)
            return false;
 
        DrawCurrentSurface(destinationCanvas);
        return true;
    }
 
    private void DrawCurrentSurface(SKCanvas canvas)
    {
        var presentation = RenderSurfaceAdapter?.Presentation ?? default;
        canvas.Clear(Backbuffer.ClearColor);
        if (presentation.Scale <= 0) return;
        canvas.Save();
        try
        {
            canvas.Translate(presentation.DestinationRect.Left, presentation.DestinationRect.Top);
            canvas.Scale(presentation.Scale);
            bool needsLinearSampling = Engine.Instance.Configuration.RenderScalingFilter == RenderScalingFilter.Linear &&
                (presentation.Scale != 1f ||
                 presentation.DestinationRect.Left != MathF.Floor(presentation.DestinationRect.Left) ||
                 presentation.DestinationRect.Top != MathF.Floor(presentation.DestinationRect.Top));
            if (needsLinearSampling)
            {
                // Skia's DrawSurface does not expose sampling and ignores SKPaint.FilterQuality.
                // A scoped snapshot is a GPU texture view, not a readback or an intermediate copy.
                using var image = Backbuffer.Snapshot();
                canvas.DrawImage(image, 0, 0, RenderSurfaceAdapterBase.PresentationSampling);
            }
            else
            {
                canvas.DrawSurface(Backbuffer.Canvas.Surface, 0, 0);
            }
        }
        finally { canvas.Restore(); }
    }

    public SKImage? GlSnapshotCurrentFrame()
    {
        if (!Backbuffer.IsGlThreadRendered)
            return null;
 
        return Backbuffer.Snapshot();
    }

    internal abstract void RenderToBackbuffer(long tick);

    internal abstract void PresentBackbufferToAdapter();

    public void Dispose()
    {
        lock (RenderStateSynchronization.SyncRoot)
            Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        Telemetry?.Dispose();
        if (disposing)
        {
            FrameMailbox.Dispose();
            Effects.Dispose();
        }
 
        RenderSurfaceHostRegistry.Unregister(this);
    }
}