ImageInstanceLayer.cs

using System.Drawing;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.SkiaSharp;
using Gondwana.Timers;
using SkiaSharp;
 
namespace Gondwana.Drawing.Direct.ImageLayer;

public sealed class ImageInstanceLayer : DirectDrawingMovableBase
{
    private readonly Random _rng = new();
    private readonly SKPaint _paint = new()
    {
        IsAntialias = true,
        BlendMode = SKBlendMode.SrcOver
    };
 
    private long _instanceLastTick;

    public List<ImageInstance> Instances { get; } = new();

    public Func<Rectangle, Random, IEnumerable<ImageInstance>>? Initializer { get; set; }

    public Func<ImageInstance, Rectangle, bool>? ShouldRecycle { get; set; }

    public Func<ImageInstance, Rectangle, Random, ImageInstance>? RecycleInstance { get; set; }

    public Action<ImageInstance, float>? UpdateInstance { get; set; }

    public ImageInstanceLayer(RenderSurfaceHostBase renderSurfaceHost,
                              View view,
                              Rectangle screenBounds,
                              string? nickname = null)
        : base(renderSurfaceHost,
               DirectDrawingMode.View,
               sceneLayer: null,
               view: view,
               screenBounds: screenBounds,
               worldBounds: null,
               name: nickname)
    {
    }

    public ImageInstanceLayer(RenderSurfaceHostBase renderSurfaceHost,
                              SceneLayer sceneLayer,
                              Rectangle worldBounds,
                              string? nickname = null)
        : base(renderSurfaceHost,
               DirectDrawingMode.SceneLayer,
               sceneLayer: sceneLayer,
               view: null,
               screenBounds: null,
               worldBounds: worldBounds,
               name: nickname)
    {
    }

    public ImageInstanceLayer(RenderSurfaceHostBase renderSurfaceHost,
                              View view,
                              Rectangle screenBounds,
                              Func<Rectangle, Random, IEnumerable<ImageInstance>>? initializer,
                              Func<ImageInstance, Rectangle, bool>? shouldRecycle = null,
                              Func<ImageInstance, Rectangle, Random, ImageInstance>? recycleInstance = null,
                              Action<ImageInstance, float>? updateInstance = null,
                              string? nickname = null)
        : this(renderSurfaceHost, view, screenBounds, nickname)
    {
        Initializer = initializer;
        ShouldRecycle = shouldRecycle;
        RecycleInstance = recycleInstance;
        UpdateInstance = updateInstance;
 
        InitializeInstances();
    }

    public ImageInstanceLayer(RenderSurfaceHostBase renderSurfaceHost,
                              SceneLayer sceneLayer,
                              Rectangle worldBounds,
                              Func<Rectangle, Random, IEnumerable<ImageInstance>>? initializer,
                              Func<ImageInstance, Rectangle, bool>? shouldRecycle = null,
                              Func<ImageInstance, Rectangle, Random, ImageInstance>? recycleInstance = null,
                              Action<ImageInstance, float>? updateInstance = null,
                              string? nickname = null)
        : this(renderSurfaceHost, sceneLayer, worldBounds, nickname)
    {
        Initializer = initializer;
        ShouldRecycle = shouldRecycle;
        RecycleInstance = recycleInstance;
        UpdateInstance = updateInstance;
 
        InitializeInstances();
    }

    public void InitializeInstances()
    {
        Instances.Clear();
 
        var bounds = Mode == DirectDrawingMode.SceneLayer
            ? WorldBounds
            : ScreenBounds;
 
        if (Initializer is not null)
            Instances.AddRange(Initializer(bounds, _rng));
 
        ForceRefresh();
    }

    public override void Update(long tick)
    {
        if (tick <= _lastTick)
            return;
 
        float dt = 0f;
 
        if (_instanceLastTick > 0)
            dt = HighResTimer.GetDuration(_instanceLastTick, tick);
 
        _instanceLastTick = tick;
 
        if (dt <= 0f)
        {
            base.Update(tick);
            return;
        }
 
        var bounds = Mode == DirectDrawingMode.SceneLayer
            ? WorldBounds
            : ScreenBounds;
 
        for (int i = 0; i < Instances.Count; i++)
        {
            var instance = Instances[i];
            var oldRefreshBounds = GetRefreshBounds(instance);
 
            instance.Bounds = new RectangleF(
                instance.Bounds.X + (instance.VelocityX * dt),
                instance.Bounds.Y + (instance.VelocityY * dt),
                instance.Bounds.Width,
                instance.Bounds.Height);
 
            instance.Rotation += instance.AngularVelocity * dt;
 
            UpdateInstance?.Invoke(instance, dt);
 
            if (ShouldRecycle is not null &&
                RecycleInstance is not null &&
                ShouldRecycle(instance, bounds))
            {
                var recycled = RecycleInstance(instance, bounds, _rng);
                Instances[i] = recycled;
 
                AddRefreshRect(oldRefreshBounds);
                AddRefreshRect(GetRefreshBounds(recycled));
            }
            else
            {
                AddRefreshRect(oldRefreshBounds);
                AddRefreshRect(GetRefreshBounds(instance));
            }
        }
 
        base.Update(tick);
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        var canvas = backbuffer.Canvas;
 
        Rectangle srcBounds = Mode == DirectDrawingMode.SceneLayer
            ? WorldBounds
            : ScreenBounds;
 
        float sx = srcBounds.Width > 0
            ? destRectScreen.Width / srcBounds.Width
            : 1f;
 
        float sy = srcBounds.Height > 0
            ? destRectScreen.Height / srcBounds.Height
            : 1f;
 
        canvas.Save();
        canvas.ClipRect(destRectScreen.ToSKRect());
 
        foreach (var instance in Instances)
        {
            _paint.Color = instance.Tint;
 
            var dst = new SKRect(
                destRectScreen.Left + ((instance.Bounds.Left - srcBounds.Left) * sx),
                destRectScreen.Top + ((instance.Bounds.Top - srcBounds.Top) * sy),
                destRectScreen.Left + ((instance.Bounds.Right - srcBounds.Left) * sx),
                destRectScreen.Top + ((instance.Bounds.Bottom - srcBounds.Top) * sy));
 
            if (instance.Rotation != 0f)
            {
                float cx = (dst.Left + dst.Right) * 0.5f;
                float cy = (dst.Top + dst.Bottom) * 0.5f;
 
                canvas.Save();
                canvas.RotateDegrees(instance.Rotation, cx, cy);
                canvas.DrawBitmap(instance.Bitmap, dst, _paint);
                canvas.Restore();
            }
            else
            {
                canvas.DrawBitmap(instance.Bitmap, dst, _paint);
            }
        }
 
        canvas.Restore();
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
            _paint.Dispose();
 
        base.Dispose(disposing);
    }

    private void AddRefreshRect(RectangleF rect)
    {
        const float pad = 4f;
 
        var expanded = Rectangle.Ceiling(RectangleF.Inflate(rect, pad, pad));
 
        if (Mode == DirectDrawingMode.SceneLayer)
        {
            SceneLayer!.RefreshQueue.AddWorldRect(expanded);
            return;
        }
 
        foreach (var sceneLayer in RenderSurfaceHost.Scene.SceneLayers)
            sceneLayer.RefreshQueue.AddViewScreenRect(View!, sceneLayer, expanded);
    }

    private static RectangleF GetRefreshBounds(ImageInstance instance)
    {
        if (instance.Rotation == 0f && instance.AngularVelocity == 0f)
            return instance.Bounds;
 
        float cx = instance.Bounds.Left + (instance.Bounds.Width * 0.5f);
        float cy = instance.Bounds.Top + (instance.Bounds.Height * 0.5f);
 
        float halfWidth = instance.Bounds.Width * 0.5f;
        float halfHeight = instance.Bounds.Height * 0.5f;
        float halfDiagonal = MathF.Sqrt((halfWidth * halfWidth) + (halfHeight * halfHeight));
 
        return new RectangleF(
            cx - halfDiagonal,
            cy - halfDiagonal,
            halfDiagonal * 2f,
            halfDiagonal * 2f);
    }
}