BackbufferBase.cs

using System.Drawing;
using Gondwana.Drawing;
using Gondwana.Drawing.Sprites;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.SkiaSharp;
using SkiaSharp;
 
namespace Gondwana.Rendering.Backbuffers;

public abstract class BackbufferBase : IDisposable
{
    private int _width;
    private int _height;
 
    private BackbufferBase()
    { }

    protected BackbufferBase(int width, int height)
        : this()
    {
        _width = width;
        _height = height;
    }

    public abstract SKCanvas Canvas { get; }

    protected internal abstract SKImage Snapshot();

    protected internal abstract void BeginFrame();

    protected internal abstract void DrawTileFrame(Tile tile, RectangleF destRectScreen);

    protected internal abstract void EndFrame();

    public SKPaint FogPaint { get; set; } = new()
    {
        Color = new SKColor(0, 0, 0, 128),
        IsAntialias = true
    };

    public SKPaint GridLinePaint { get; set; } = new()
    {
        Color = SKColors.White,
        IsStroke = true,
        StrokeWidth = 1
    };

    public SKPaint CollisionBoxPaint { get; set; } = new()
    {
        Color = SKColors.Green,
        IsStroke = true,
        StrokeWidth = 1
    };

    public int Width => Volatile.Read(ref _width);

    public int Height => Volatile.Read(ref _height);

    protected internal virtual void RequestResize(int width, int height)
    { /* no-op by default */ }

    protected internal event Action<int, int>? SizeChanged;

    protected void UpdateSize(int width, int height)
    {
        Volatile.Write(ref _width, width);
        Volatile.Write(ref _height, height);
 
        SizeChanged?.Invoke(width, height);
    }

    protected internal Rectangle DirtyRectangle { get; private set; }
 
    private SKColor _clearColor = SKColors.Black;

    protected readonly SKPaint _fillPaint = new()
    {
        IsAntialias = false,
        BlendMode = SKBlendMode.Src,
        Style = SKPaintStyle.Fill,
        FilterQuality = SKFilterQuality.None,
    };

    public SKColor ClearColor
    {
        get => _clearColor;
        set
        {
            _clearColor = value;
            _fillPaint.Color = value;
        }
    }
 
    internal void ClearRect(Rectangle rectPx)
    {
        if (rectPx.IsEmpty)
            return;
 
        _fillPaint.Color = ClearColor;
 
        // Screen-pixel space
        Canvas.Save();
        Canvas.ResetMatrix();
 
        // Rect is expected to be in the current canvas coordinate space.
        Canvas.DrawRect(rectPx.ToSKRect(), _fillPaint);
 
        // GL surfaces always present the full backbuffer and do not maintain dirty regions.
        if (!IsGlThreadRendered)
            AddToBackbufferDirtyRectangle(rectPx);
 
        Canvas.Restore();
    }
 
    internal void DrawDrawables(View view, IEnumerable<IDrawable> drawables, Rectangle clipRect)
    {
        if (this is RecordingBackbuffer recording &&
            drawables is IReadOnlyList<IDrawable> ordered &&
            recording.TryDrawFixedGridDrawables(view, ordered, clipRect))
        {
            return;
        }
 
        Canvas.Save();
        Canvas.ClipRect(clipRect.ToSKRect());
 
        var tiles = new List<(Tile Tile, WrappedDrawable? Instance)>();
 
        foreach (var entry in drawables)
        {
            var instance = entry as WrappedDrawable;
            var drawable = instance?.Owner ?? entry;
            using var scope = instance?.Enter(view);
            if (!drawable.Visible)
                continue;
 
            var destRectScreen = drawable.GetDrawLocationScreen(view);
            if (drawable is Sprite sprite)
            {
                destRectScreen = sprite.ApplyJiggleToDestRect(destRectScreen);
            }
 
            bool batched = this is RecordingBackbuffer recorder &&
                instance is null &&
                drawable.GetType() == typeof(SceneLayerTile) &&
                drawable is SceneLayerTile layerTile &&
                recorder.TryQueueTile(layerTile, destRectScreen);
 
            if (!batched)
            {
                (this as RecordingBackbuffer)?.FlushTileBatch();
                drawable.Draw(this, destRectScreen);
            }
 
            // GPU/GL surfaces always present the complete backbuffer. Avoid calculating visual
            // bounds just to pass them to dirty-region tracking that the GPU path never consumes.
            if (!IsGlThreadRendered)
            {
                RectangleF visualBoundsScreen = drawable is Sprite drawnSprite
                    ? drawnSprite.GetVisualBoundsScreen(destRectScreen)
                    : destRectScreen;
 
                AddToBackbufferDirtyRectangle(visualBoundsScreen.ToPixelAlignedRect());
            }
 
            if (drawable is Tile tile)
                tiles.Add((tile, instance));
        }
 
        (this as RecordingBackbuffer)?.FlushTileBatch();
 
        PostDrawTiles(view, tiles);
 
        Canvas.Restore();
    }
 
    private void PostDrawTiles(View view, List<(Tile Tile, WrappedDrawable? Instance)> tiles)
    {
        foreach (var entry in tiles)
        {
            var tile = entry.Tile;
            using var scope = entry.Instance?.Enter(view);
            var layer = tile.SceneLayer;
            bool drawFog = tile.EnableFog;
            bool drawGrid = layer.ShowGridLines && tile.Visible && tile.IsPositionFixed;
            bool drawCollision = layer.ShowCollisionBoxes && tile.Visible && tile.CollisionsEnabled;
 
            if (!drawFog && !drawGrid && !drawCollision)
                continue;
 
            // Orthogonal grid outlines are rectangles. Avoid building two transient point arrays
            // and performing four point-wise world-to-screen transforms for every fixed tile.
            // Rectangle conversion uses the same view transform while preserving the grid cell
            // bounds (includeOverhang: false) used by the legacy polygon path.
            if (drawGrid
                && !drawFog
                && layer.CoordinateSystemType == Gondwana.Drawing.Coordinates.CoordinateSystemTypes.Orthogonal)
            {
                var worldRect = layer.CoordinateSystem.GetPixelRangeForTile(tile, includeOverhang: false);
                var screenRect = view.WorldRectToScreenRect(layer, worldRect);
                Canvas.DrawRect(screenRect.ToSKRect(), GridLinePaint);
 
                if (drawCollision)
                {
                    var colRectScreen = tile.GetCollisionAreaScreen(view).ToSKRect();
                    Canvas.DrawRect(colRectScreen, CollisionBoxPaint);
                }
 
                continue;
            }
 
            // Polygon geometry is only needed for fog or non-orthogonal grid outlines.
            if (drawFog || drawGrid)
            {
                var worldPts = tile.OutlinePointsWorld;
                var ptsScreen = new SKPoint[worldPts.Length];
 
                for (int i = 0; i < worldPts.Length; i++)
                {
                    var p = worldPts[i];
                    var sp = view.WorldPxToScreenPx(
                        layer,
                        new PointF(p.X, p.Y)
                    );
 
                    ptsScreen[i] = new SKPoint(sp.X, sp.Y);
                }
 
                if (drawFog)
                {
                    using var path = new SKPath();
                    path.AddPoly(ptsScreen, close: true);
                    Canvas.DrawPath(path, FogPaint);
                }
 
                if (drawGrid)
                {
                    var enclosed = new SKPoint[ptsScreen.Length + 1];
                    Array.Copy(ptsScreen, enclosed, ptsScreen.Length);
                    enclosed[^1] = ptsScreen[0];
                    Canvas.DrawPoints(SKPointMode.Polygon, enclosed, GridLinePaint);
                }
            }
 
            if (drawCollision)
            {
                var colRectScreen = tile.GetCollisionAreaScreen(view).ToSKRect();
                Canvas.DrawRect(colRectScreen, CollisionBoxPaint);
            }
        }
    }

    protected internal void AddToBackbufferDirtyRectangle(Rectangle area)
    {
        if (IsGlThreadRendered || area.IsEmpty)
            return;
 
        area.Inflate(area.Width, area.Height);
 
        DirtyRectangle = DirtyRectangle.IsEmpty
            ? area
            : Rectangle.Union(DirtyRectangle, area);
    }

    protected internal void ClearDirtyRectangle()
    {
        DirtyRectangle = Rectangle.Empty;
    }

    public virtual byte[] ToByteArray(SKEncodedImageFormat format = SKEncodedImageFormat.Png, int quality = 100)
    {
        using var image = Snapshot();
        using var data = image.Encode(format, quality);
        return data.ToArray();
    }

    public virtual bool IsGlThreadRendered => false;

    public virtual void Dispose()
    {
        _fillPaint.Dispose();
        FogPaint.Dispose();
        GridLinePaint.Dispose();
        CollisionBoxPaint.Dispose();
 
        GC.SuppressFinalize(this);
    }
}