ParticleSurface.cs

using System.Buffers;
using System.Drawing;
using System.Runtime.CompilerServices;
using Gondwana.Rendering;
using Gondwana.Rendering.Backbuffers;
using Gondwana.Rendering.Views;
using Gondwana.Scenes;
using Gondwana.Timers;
using SkiaSharp;
 
namespace Gondwana.Drawing.Direct.Particles;

public sealed partial class ParticleSurface : DirectDrawingMovableBase
{
    private readonly Particle[] _particles;
    private readonly Random _rng = new();
    private readonly SKPaint _paint = new() { IsAntialias = true };
    private int _alive;
    private long _particlesLastTick = 0;
 
    // If you want textured particles, supply a tilesheet frame and draw bitmap quads instead of circles.
    private readonly SKBitmap? _particleSprite;

    public readonly List<ParticleEmitter> Emitters = new();

    public int ActiveParticleCount => _alive;

    public float GlobalEmitScale { get; set; } = 1f;

    public SKColor GlobalColorTint { get; set; } = SKColors.White;

    public float GravityX { get; set; } = 0f;   // px/s^2

    public float GravityY { get; set; } = 400f; // px/s^2

    public float CullingMarginX { get; set; } = 32f;

    public float CullingMarginY { get; set; } = 32f;
 
    private ParticleSurface(RenderSurfaceHostBase renderSurfaceHost,
                           DirectDrawingMode mode,
                           SceneLayer? sceneLayer,
                           View? view,
                           Rectangle? screenBounds,
                           Rectangle? worldBounds,
                           string? nickname = null,
                           int maxParticles = 2000,
                           SKBitmap? particleSprite = null)
        : base(renderSurfaceHost, mode, sceneLayer, view, screenBounds, worldBounds, nickname)
    {
        _particles = ArrayPool<Particle>.Shared.Rent(maxParticles);
        _particleSprite = particleSprite;
    }

    public ParticleSurface(RenderSurfaceHostBase renderSurfaceHost,
                           SceneLayer sceneLayer,
                           Rectangle? worldBounds,
                           string? nickname = null,
                           int maxParticles = 2000,
                           SKBitmap? particleSprite = null)
        : this(renderSurfaceHost,
               DirectDrawingMode.SceneLayer,
               sceneLayer,
               null,
               null,
               worldBounds,
               nickname,
               maxParticles,
               particleSprite)
    { }

    public ParticleSurface(RenderSurfaceHostBase renderSurfaceHost,
                            View view,
                            Rectangle? screenBounds,
                            string? nickname = null,
                            int maxParticles = 2000,
                            SKBitmap? particleSprite = null)
        : this(renderSurfaceHost,
              DirectDrawingMode.View,
              null,
              view,
              screenBounds,
              null,
              nickname,
              maxParticles,
              particleSprite)
    { }

    public void Burst(ParticleEmitter emitter, int count) => EmitFrom(emitter, count);

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            ArrayPool<Particle>.Shared.Return(_particles, clearArray: true);
            _paint.Dispose();
            _alive = 0;
            _particlesLastTick = 0;
        }
        base.Dispose(disposing);
    }

    public override void Update(long tick)
    {
        if (tick <= _lastTick)
            return;
 
        // Compute dt from ticks (seconds)
        float dt = 0f;
 
        // no previous tick assume first frame, so skip dt-based updates
        if (_particlesLastTick > 0)
            dt = HighResTimer.GetDuration(_particlesLastTick, tick);
 
        _particlesLastTick = tick;
 
        // (A) per-emitter motion
        for (int i = 0; i < Emitters.Count; i++)
            Emitters[i].OnUpdate?.Invoke(Emitters[i], dt);
 
        // (B) emission
        for (int i = 0; i < Emitters.Count; i++)
        {
            var em = Emitters[i];
            float rate = MathF.Max(0f, em.EmitRate * GlobalEmitScale);
            em._accumulator += rate * dt;
 
            int toEmit = (int)em._accumulator;
            if (toEmit > 0) { em._accumulator -= toEmit; EmitFrom(em, toEmit); }
        }
 
        // (C) integrate & compact
        int write = 0;
        for (int i = 0; i < _alive; i++)
        {
            ref var p = ref _particles[i];
 
            // integrate acceleration (including gravity)
            p.VX += p.AX * dt;
            p.VY += p.AY * dt;
 
            // clamp max velocity
            if (p.MaxVelocity > 0f)
            {
                // thank you, Pythagoras
                float vx = p.VX, vy = p.VY;
                float velocity2 = (vx * vx) + (vy * vy);
                float max2 = p.MaxVelocity * p.MaxVelocity;
 
                if (velocity2 > max2)
                {
                    float inv = p.MaxVelocity / MathF.Sqrt(velocity2);
                    p.VX = vx * inv;
                    p.VY = vy * inv;
                }
            }
 
            // integrate velocity
            p.X += p.VX * dt;
            p.Y += p.VY * dt;
 
            // to every season...
            p.Rotation += p.AngularVel * dt;
            p.Life -= dt;
 
            // cull if out of bounds (with margin)
            Rectangle cullBounds = (Mode == DirectDrawingMode.SceneLayer)
                ? WorldBounds
                : ScreenBounds;
 
            bool isInView = p.X >= cullBounds.Left - CullingMarginX
                         && p.X <= cullBounds.Right + CullingMarginX
                         && p.Y >= cullBounds.Top - CullingMarginY
                         && p.Y <= cullBounds.Bottom + CullingMarginY;
 
            if (p.Life > 0 && isInView)
                _particles[write++] = p;
        }
        _alive = write;
 
        ForceRefresh();
 
        base.Update(tick);
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        var canvas = backbuffer.Canvas;
 
        // Source bounds in the particle coordinate space
        Rectangle srcBounds = (Mode == DirectDrawingMode.SceneLayer)
            ? WorldBounds
            : ScreenBounds;
 
        // Guard against divide-by-zero (shouldn't happen, but cheap insurance)
        float sx = (srcBounds.Width > 0) ? (destRectScreen.Width / srcBounds.Width) : 1f;
        float sy = (srcBounds.Height > 0) ? (destRectScreen.Height / srcBounds.Height) : 1f;
 
        // Usually uniform; if not, pick one (or average) for size scaling
        float sSize = (sx + sy) * 0.5f;
 
        for (int i = 0; i < _alive; i++)
        {
            ref var p = ref _particles[i];
 
            // blend mode
            _paint.BlendMode = p.BlendMode;
 
            // life-based fade
            float t = 1f - (p.Life / p.MaxLife);
            byte a = (byte)(255 * (1f - t));
 
            // choose tint: emitter override if set, otherwise current global
            var tint = p.Tint ?? GlobalColorTint;
 
            // apply global tint
            _paint.Color = ApplyTint(p.Color, a, tint);
 
            // Map particle position from srcBounds space -> destRectScreen space
            float x = destRectScreen.Left + (p.X - srcBounds.Left) * sx;
            float y = destRectScreen.Top + (p.Y - srcBounds.Top) * sy;
 
            if (p.ParticleSprite is null)
            {
                float size = (p.Size * sSize) * (1f + 0.5f * t);
                canvas.DrawCircle(x, y, size, _paint);
            }
            else
            {
                float s = p.Size * sSize;
                var dst = new SKRect(x - s * 0.5f, y - s * 0.5f,
                                     x + s * 0.5f, y + s * 0.5f);
 
                canvas.Save();
                canvas.RotateDegrees(p.Rotation, x, y);
                canvas.DrawBitmap(p.ParticleSprite, dst, _paint);
                canvas.Restore();
            }
        }
    }
 
    private void EmitFrom(ParticleEmitter em, int count)
    {
        for (int i = 0; i < count && _alive < _particles.Length; i++)
        {
            ref var p = ref _particles[_alive++];
 
            // Position
            if (em.JitterX == 0f && em.JitterY == 0f)
            {
                p.X = em.Position.X;
                p.Y = em.Position.Y;
            }
            else
            {
                (float dx, float dy) = SampleSpawnOffset(em);
                p.X = em.Position.X + dx;
                p.Y = em.Position.Y + dy;
            }
 
            // Velocity
            p.VX = NextRange(em.VelocityRangeX.Min, em.VelocityRangeX.Max);
            p.VY = NextRange(em.VelocityRangeY.Min, em.VelocityRangeY.Max);
 
            // Acceleration (emitter override or surface default)
            p.AX = em.GravityX ?? this.GravityX;
            p.AY = em.GravityY ?? this.GravityY;
 
            // Life/Size
            p.MaxLife = p.Life = NextRange(em.LifeRange.Min, em.LifeRange.Max);
            p.Size = NextRange(em.SizeRange.Min, em.SizeRange.Max);
 
            // Color & spin
            p.Color = em.Color;
            p.Rotation = NextRange(0f, 360f);
            p.AngularVel = NextRange(-180f, 180f);
 
            // choose sprite once; no emitter lookups in hot loop
            p.ParticleSprite = em.ParticleSprite ?? this._particleSprite;
 
            // tint override
            p.Tint = em.Tint;                          // null means "use global at render"
 
            // max speed clamp
            p.MaxVelocity = em.MaxVelocity ?? 0f;      // 0 = no clamp
 
            // blend mode
            p.BlendMode = em.BlendMode;
 
            // User hook for last-mile per-particle tweaks
            em.OnSpawn?.Invoke(ref p);
        }
    }
 
    private float NextRange(float min, float max) => (float)(_rng.NextDouble() * (max - min) + min);
 
    private (float dx, float dy) SampleSpawnOffset(ParticleEmitter em)
    {
        float jx = MathF.Abs(em.JitterX);
        float jy = MathF.Abs(em.JitterY);
 
        // Handle "line" cases cleanly (one axis zero)
        if (jx == 0f)
            return (0f, NextRange(-jy, jy));
 
        if (jy == 0f)
            return (NextRange(-jx, jx), 0f);
 
        switch (em.SpawnDistribution)
        {
            default:
            case ParticleSpawnDistribution.Rectangle:
                return (NextRange(-jx, jx), NextRange(-jy, jy));
 
            case ParticleSpawnDistribution.Ellipse:
                {
                    // Uniform over area of ellipse
                    float a = NextRange(0f, MathF.Tau);
                    float r = MathF.Sqrt(NextRange(0f, 1f)); // sqrt => uniform area
                    return (MathF.Cos(a) * r * jx, MathF.Sin(a) * r * jy);
                }
 
            case ParticleSpawnDistribution.Ring:
                {
                    // Uniform over area of annulus (ellipse-scaled)
                    float inner = Math.Clamp(em.RingInnerRadius01, 0f, 1f);
                    float a = NextRange(0f, MathF.Tau);
 
                    // area-uniform annulus: r = sqrt(inner^2 + u*(1-inner^2))
                    float u = NextRange(0f, 1f);
                    float r = MathF.Sqrt(inner * inner + u * (1f - inner * inner));
 
                    return (MathF.Cos(a) * r * jx, MathF.Sin(a) * r * jy);
                }
 
            case ParticleSpawnDistribution.Gaussian:
                {
                    // Center-weighted, then clamped to ellipse boundary
                    float sd = Math.Clamp(em.GaussianStdDev01, 1e-4f, 10f);
 
                    float dx = NextGaussian() * (jx * sd);
                    float dy = NextGaussian() * (jy * sd);
 
                    // Clamp to ellipse: (dx/jx)^2 + (dy/jy)^2 <= 1
                    float nx = dx / jx;
                    float ny = dy / jy;
                    float q = nx * nx + ny * ny;
 
                    if (q > 1f)
                    {
                        float s = 1f / MathF.Sqrt(q);
                        dx *= s;
                        dy *= s;
                    }
 
                    return (dx, dy);
                }
        }
    }
 
    private float NextGaussian()
    {
        // Box–Muller transform (standard normal)
        // Guard u1 from 0 to avoid log(0)
        double u1 = 1.0 - _rng.NextDouble();
        double u2 = 1.0 - _rng.NextDouble();
        double mag = Math.Sqrt(-2.0 * Math.Log(u1));
        double z0 = mag * Math.Cos(Math.Tau * u2);
        return (float)z0;
    }
 
    // Fast, branch-free tint (multiplies RGB by tint).
    // Alpha combines the particle's base alpha, life fade, and tint alpha.
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private SKColor ApplyTint(SKColor c, byte lifeAlpha, SKColor tint)
    {
        int r = (c.Red * tint.Red) / 255;
        int g = (c.Green * tint.Green) / 255;
        int b = (c.Blue * tint.Blue) / 255;
        int a = (c.Alpha * lifeAlpha * tint.Alpha) / (255 * 255);
 
        return new SKColor((byte)r, (byte)g, (byte)b, (byte)a);
    }
}