DirectRadialLight.cs

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

public sealed class DirectRadialLight : DirectDrawingBase
{
    private PointF _centerWorldPx;
    private float _radiusWorldPx;
    private Color _lightColor;
    private float _intensity = 1f;
    private float _hotspotRadiusRatio = 0.06f;
    private float _midpointRadiusRatio = 0.55f;
    private float _midpointIntensityRatio = 0.35f;
    private bool _isAntialias = true;
    private SKBlendMode _blendMode = SKBlendMode.Screen;
 
    private bool _flickerEnabled;
    private float _flickerAmount = 0.08f;
    private int _flickerRefreshHz = 12;
    private float _flickerPhaseSec;
    private float _flickerMultiplier = 1f;
    private long _lastFlickerRefreshTick;

    public event Action<DirectRadialLight>? Changed;

    public DirectRadialLight(
        Color lightColor,
        RenderSurfaceHostBase renderSurfaceHost,
        SceneLayer sceneLayer,
        PointF centerWorldPx,
        float radiusWorldPx,
        string? nickname = null)
        : base(
            renderSurfaceHost,
            DirectDrawingMode.SceneLayer,
            sceneLayer,
            view: null,
            screenBounds: null,
            worldBounds: BoundsFromCenter(centerWorldPx, radiusWorldPx),
            nickname)
    {
        _lightColor = lightColor;
        _centerWorldPx = centerWorldPx;
        _radiusWorldPx = Math.Max(1f, radiusWorldPx);
    }

    public PointF CenterWorldPx
    {
        get => _centerWorldPx;
        set
        {
            if (ApproximatelyEqual(_centerWorldPx, value))
                return;
 
            _centerWorldPx = value;
            UpdateWorldBounds();
        }
    }

    public float RadiusWorldPx
    {
        get => _radiusWorldPx;
        set
        {
            var clamped = Math.Max(1f, value);
            if (Math.Abs(_radiusWorldPx - clamped) < 0.001f)
                return;
 
            _radiusWorldPx = clamped;
            UpdateWorldBounds();
        }
    }

    public Color LightColor
    {
        get => _lightColor;
        set
        {
            if (_lightColor.ToArgb() == value.ToArgb())
                return;
 
            _lightColor = value;
            ForceRefresh();
            OnChanged();
        }
    }

    public float Intensity
    {
        get => _intensity;
        set
        {
            var clamped = Clamp01(value);
            if (Math.Abs(_intensity - clamped) < 0.001f)
                return;
 
            _intensity = clamped;
            ForceRefresh();
            OnChanged();
        }
    }

    public float EffectiveIntensity => Clamp01(_intensity * _flickerMultiplier);

    public SKBlendMode BlendMode
    {
        get => _blendMode;
        set
        {
            if (_blendMode == value)
                return;
 
            _blendMode = value;
            ForceRefresh();
        }
    }

    public float HotspotRadiusRatio
    {
        get => _hotspotRadiusRatio;
        set
        {
            var clamped = Clamp01(value);
            if (Math.Abs(_hotspotRadiusRatio - clamped) < 0.001f)
                return;
 
            _hotspotRadiusRatio = clamped;
            ForceRefresh();
        }
    }

    public float MidpointRadiusRatio
    {
        get => _midpointRadiusRatio;
        set
        {
            var clamped = Clamp01(value);
            if (Math.Abs(_midpointRadiusRatio - clamped) < 0.001f)
                return;
 
            _midpointRadiusRatio = clamped;
            ForceRefresh();
        }
    }

    public float MidpointIntensityRatio
    {
        get => _midpointIntensityRatio;
        set
        {
            var clamped = Clamp01(value);
            if (Math.Abs(_midpointIntensityRatio - clamped) < 0.001f)
                return;
 
            _midpointIntensityRatio = clamped;
            ForceRefresh();
        }
    }

    public bool IsAntialias
    {
        get => _isAntialias;
        set
        {
            if (_isAntialias == value)
                return;
 
            _isAntialias = value;
            ForceRefresh();
        }
    }

    public bool FlickerEnabled
    {
        get => _flickerEnabled;
        set
        {
            if (_flickerEnabled == value)
                return;
 
            _flickerEnabled = value;
            _flickerMultiplier = 1f;
            _lastFlickerRefreshTick = 0;
            ForceRefresh();
            OnChanged();
        }
    }

    public float FlickerAmount
    {
        get => _flickerAmount;
        set
        {
            var clamped = Math.Clamp(value, 0f, 1f);
            if (Math.Abs(_flickerAmount - clamped) < 0.001f)
                return;
 
            _flickerAmount = clamped;
            ForceRefresh();
            OnChanged();
        }
    }

    public int FlickerRefreshHz
    {
        get => _flickerRefreshHz;
        set => _flickerRefreshHz = Math.Max(1, value);
    }

    public DirectRadialLight MoveTo(PointF centerWorldPx)
    {
        CenterWorldPx = centerWorldPx;
        return this;
    }

    public DirectRadialLight SetRadius(float radiusWorldPx)
    {
        RadiusWorldPx = radiusWorldPx;
        return this;
    }

    public DirectRadialLight SetIntensity(float intensity)
    {
        Intensity = intensity;
        return this;
    }

    public override void Update(long tick)
    {
        UpdateFlicker(tick);
        base.Update(tick);
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        if (destRectScreen.Width <= 0f || destRectScreen.Height <= 0f)
            return;
 
        var canvas = backbuffer.Canvas;
        var worldBounds = WorldBounds;
 
        if (worldBounds.Width <= 0 || worldBounds.Height <= 0)
            return;
 
        var rect = new SKRect(destRectScreen.Left, destRectScreen.Top, destRectScreen.Right, destRectScreen.Bottom);
        float scaleX = destRectScreen.Width / worldBounds.Width;
        float scaleY = destRectScreen.Height / worldBounds.Height;
 
        // Use the actual world-space center/radius rather than the integer-rounded
        // WorldBounds midpoint. The bounds are intentionally pixel-aligned for dirty
        // rectangles, but the shader geometry should preserve sub-pixel light movement
        // so a moving torch does not pop by ~0.5px as its bounds floor/ceil change.
        var center = new SKPoint(
            destRectScreen.Left + (_centerWorldPx.X - worldBounds.Left) * scaleX,
            destRectScreen.Top + (_centerWorldPx.Y - worldBounds.Top) * scaleY);
 
        var radius = Math.Max(Math.Abs(_radiusWorldPx * scaleX), Math.Abs(_radiusWorldPx * scaleY));
 
        if (radius <= 0f)
            return;
 
        var hotspot = Math.Clamp(_hotspotRadiusRatio, 0f, 0.95f);
        var midpoint = Math.Clamp(_midpointRadiusRatio, hotspot + 0.001f, 0.999f);
        var effectiveIntensity = EffectiveIntensity;
 
        var inner = ToSkColor(_lightColor, effectiveIntensity);
        var middle = ToSkColor(_lightColor, effectiveIntensity * _midpointIntensityRatio);
        var outer = ToSkColor(_lightColor, 0f);
 
        using var shader = SKShader.CreateRadialGradient(
            center,
            radius,
            new[] { inner, inner, middle, outer },
            new[] { 0f, hotspot, midpoint, 1f },
            SKShaderTileMode.Clamp);
 
        using var paint = new SKPaint
        {
            Shader = shader,
            Style = SKPaintStyle.Fill,
            BlendMode = _blendMode,
            IsAntialias = _isAntialias
        };
 
        canvas.DrawRect(rect, paint);
    }
 
    private void UpdateFlicker(long tick)
    {
        if (!_flickerEnabled)
            return;
 
        if (_lastFlickerRefreshTick == 0)
        {
            _lastFlickerRefreshTick = tick;
            return;
        }
 
        if (tick <= _lastFlickerRefreshTick)
            return;
 
        var dt = HighResTimer.GetDuration(_lastFlickerRefreshTick, tick);
        var refreshIntervalSec = 1f / _flickerRefreshHz;
 
        if (dt < refreshIntervalSec)
            return;
 
        _flickerPhaseSec += dt;
 
        var primary = 0.5f + 0.5f * MathF.Sin(_flickerPhaseSec * MathF.Tau * _flickerRefreshHz);
        var secondary = 0.5f + 0.5f * MathF.Sin(_flickerPhaseSec * MathF.Tau * (_flickerRefreshHz * 0.37f + 0.73f));
        var mixed = primary * 0.65f + secondary * 0.35f;
 
        _flickerMultiplier = 1f - _flickerAmount + mixed * _flickerAmount * 2f;
        _lastFlickerRefreshTick = tick;
 
        ForceRefresh();
        OnChanged();
    }
 
    private void UpdateWorldBounds()
    {
        WorldBounds = BoundsFromCenter(_centerWorldPx, _radiusWorldPx);
        OnChanged();
    }
 
    private void OnChanged()
    {
        Changed?.Invoke(this);
    }
 
    private static Rectangle BoundsFromCenter(PointF centerWorldPx, float radiusWorldPx)
    {
        var radius = Math.Max(1f, radiusWorldPx);
        var left = (int)MathF.Floor(centerWorldPx.X - radius);
        var top = (int)MathF.Floor(centerWorldPx.Y - radius);
        var right = (int)MathF.Ceiling(centerWorldPx.X + radius);
        var bottom = (int)MathF.Ceiling(centerWorldPx.Y + radius);
 
        return Rectangle.FromLTRB(left, top, right, bottom);
    }
 
    private static SKColor ToSkColor(Color color, float intensity)
    {
        var alpha = (byte)Math.Clamp(color.A * Clamp01(intensity), 0f, 255f);
        return new SKColor(color.R, color.G, color.B, alpha);
    }
 
    private static float Clamp01(float value) => Math.Clamp(value, 0f, 1f);
 
    private static bool ApproximatelyEqual(PointF left, PointF right)
    {
        return Math.Abs(left.X - right.X) < 0.001f &&
               Math.Abs(left.Y - right.Y) < 0.001f;
    }
}