DirectSceneLayerDarknessOverlay.cs

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

public sealed class DirectSceneLayerDarknessOverlay : DirectDrawingBase
{
    private readonly List<RevealSource> _revealSources = [];
    private readonly List<TrackedLightReveal> _trackedLightReveals = [];
    private readonly List<TrackedLightLayerReveal> _trackedLightLayers = [];
 
    private readonly SKPaint _darknessPaint = new()
    {
        IsAntialias = true,
        BlendMode = SKBlendMode.SrcOver,
        Style = SKPaintStyle.Fill
    };
 
    private Color _darknessColor = Color.Black;
    private byte _darknessOpacity = 190;
    private float _innerClearRadiusRatio = 0.20f;
    private float _midpointRadiusRatio = 0.62f;
    private float _midpointStrength = 0.45f;

    public DirectSceneLayerDarknessOverlay(RenderSurfaceHostBase renderSurfaceHost,
                                           SceneLayer sceneLayer,
                                           Rectangle worldBounds,
                                           string? nickname = null)
        : base(renderSurfaceHost,
               DirectDrawingMode.SceneLayer,
               sceneLayer,
               view: null,
               screenBounds: null,
               worldBounds: worldBounds,
               nickname: nickname)
    {
        ZOrder = 20_000;
        RebuildDarknessPaint();
    }

    public IReadOnlyList<RevealSource> RevealSources => _revealSources;

    public Rectangle DarknessWorldBounds
    {
        get => WorldBounds;
        set => WorldBounds = value;
    }

    public Color DarknessColor
    {
        get => _darknessColor;
        set
        {
            if (_darknessColor == value)
                return;
 
            _darknessColor = value;
            RebuildDarknessPaint();
            ForceRefresh();
        }
    }

    public byte DarknessOpacity
    {
        get => _darknessOpacity;
        set
        {
            if (_darknessOpacity == value)
                return;
 
            _darknessOpacity = value;
            RebuildDarknessPaint();
            ForceRefresh();
        }
    }

    public float InnerClearRadiusRatio
    {
        get => _innerClearRadiusRatio;
        set
        {
            float clamped = Math.Clamp(value, 0f, 1f);
            if (Math.Abs(_innerClearRadiusRatio - clamped) < 0.0001f)
                return;
 
            _innerClearRadiusRatio = clamped;
            if (_midpointRadiusRatio < _innerClearRadiusRatio)
                _midpointRadiusRatio = _innerClearRadiusRatio;
 
            ForceRefresh();
        }
    }

    public float MidpointRadiusRatio
    {
        get => _midpointRadiusRatio;
        set
        {
            float clamped = Math.Clamp(value, 0f, 1f);
            clamped = Math.Max(clamped, _innerClearRadiusRatio);
 
            if (Math.Abs(_midpointRadiusRatio - clamped) < 0.0001f)
                return;
 
            _midpointRadiusRatio = clamped;
            ForceRefresh();
        }
    }

    public float MidpointStrength
    {
        get => _midpointStrength;
        set
        {
            float clamped = Math.Clamp(value, 0f, 1f);
            if (Math.Abs(_midpointStrength - clamped) < 0.0001f)
                return;
 
            _midpointStrength = clamped;
            ForceRefresh();
        }
    }

    public RevealSource AddRevealSource(PointF centerWorldPx, float radiusWorldPx, string? nickname = null)
    {
        var source = new RevealSource(this, centerWorldPx, radiusWorldPx, nickname);
        _revealSources.Add(source);
        ForceRefresh();
        return source;
    }

    public RevealSource TrackLight(DirectRadialLight light,
                                   float radiusScale = 1f,
                                   float intensityScale = 1f,
                                   bool trackIntensity = true,
                                   string? nickname = null)
    {
        if (light is null)
            throw new ArgumentNullException(nameof(light));
 
        EnsureSameSceneLayer(light);
 
        if (_trackedLightReveals.Any(t => ReferenceEquals(t.Light, light)))
            return _trackedLightReveals.First(t => ReferenceEquals(t.Light, light)).Source;
 
        var source = new RevealSource(this, light.CenterWorldPx, light.RadiusWorldPx * Math.Max(0f, radiusScale), nickname ?? light.Nickname);
        _revealSources.Add(source);
 
        var tracked = new TrackedLightReveal(light, source, Math.Max(0f, radiusScale), Math.Max(0f, intensityScale), trackIntensity);
        _trackedLightReveals.Add(tracked);
 
        light.Changed += OnTrackedLightChanged;
        light.Disposing += OnTrackedLightDisposing;
 
        SyncTrackedLight(tracked);
        ForceRefresh();
        return source;
    }

    public void TrackLightLayer(DirectLightLayer lightLayer,
                                float radiusScale = 1f,
                                float intensityScale = 1f,
                                bool trackIntensity = true)
    {
        if (lightLayer is null)
            throw new ArgumentNullException(nameof(lightLayer));
 
        if (!ReferenceEquals(lightLayer.SceneLayer, SceneLayer))
            throw new ArgumentException("SceneLayer-bound darkness can only track a DirectLightLayer attached to the same SceneLayer.", nameof(lightLayer));
 
        if (_trackedLightLayers.Any(t => ReferenceEquals(t.LightLayer, lightLayer)))
            return;
 
        var trackedLayer = new TrackedLightLayerReveal(
            lightLayer,
            Math.Max(0f, radiusScale),
            Math.Max(0f, intensityScale),
            trackIntensity);
 
        _trackedLightLayers.Add(trackedLayer);
 
        foreach (var light in lightLayer.Lights)
            TrackLight(light, trackedLayer.RadiusScale, trackedLayer.IntensityScale, trackedLayer.TrackIntensity);
 
        lightLayer.LightAdded += OnTrackedLayerLightAdded;
        lightLayer.LightRemoving += OnTrackedLayerLightRemoving;
    }

    public bool UntrackLight(DirectRadialLight light)
    {
        var tracked = _trackedLightReveals.FirstOrDefault(t => ReferenceEquals(t.Light, light));
        if (tracked is null)
            return false;
 
        UntrackLight(tracked, removeRevealSource: true);
        return true;
    }

    public bool RemoveRevealSource(RevealSource source)
    {
        if (source is null)
            return false;
 
        var tracked = _trackedLightReveals.FirstOrDefault(t => ReferenceEquals(t.Source, source));
        if (tracked is not null)
            UntrackLight(tracked, removeRevealSource: false);
 
        bool removed = _revealSources.Remove(source);
        if (removed)
            ForceRefresh();
 
        return removed;
    }

    public void ClearRevealSources()
    {
        if (_revealSources.Count == 0 && _trackedLightReveals.Count == 0 && _trackedLightLayers.Count == 0)
            return;
 
        foreach (var trackedLayer in _trackedLightLayers.ToArray())
        {
            trackedLayer.LightLayer.LightAdded -= OnTrackedLayerLightAdded;
            trackedLayer.LightLayer.LightRemoving -= OnTrackedLayerLightRemoving;
        }
 
        _trackedLightLayers.Clear();
 
        foreach (var tracked in _trackedLightReveals.ToArray())
            UntrackLight(tracked, removeRevealSource: false);
 
        _revealSources.Clear();
        ForceRefresh();
    }

    public DirectSceneLayerDarknessOverlay SetDarknessWorldBounds(Rectangle worldBounds)
    {
        DarknessWorldBounds = worldBounds;
        return this;
    }

    public DirectSceneLayerDarknessOverlay SetDarknessColor(Color color)
    {
        DarknessColor = color;
        return this;
    }

    public DirectSceneLayerDarknessOverlay SetDarknessOpacity(byte opacity)
    {
        DarknessOpacity = opacity;
        return this;
    }

    public DirectSceneLayerDarknessOverlay SetInnerClearRadiusRatio(float ratio)
    {
        InnerClearRadiusRatio = ratio;
        return this;
    }

    public DirectSceneLayerDarknessOverlay SetMidpointRadiusRatio(float ratio)
    {
        MidpointRadiusRatio = ratio;
        return this;
    }

    public DirectSceneLayerDarknessOverlay SetMidpointStrength(float strength)
    {
        MidpointStrength = strength;
        return this;
    }

    protected override void OnDraw(BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        if (destRectScreen.Width <= 0f || destRectScreen.Height <= 0f || WorldBounds.Width <= 0 || WorldBounds.Height <= 0)
            return;
 
        var canvas = backbuffer.Canvas;
        var destRect = destRectScreen.ToSKRect();
 
        // Work in an isolated layer so DstOut reveal holes affect only this overlay,
        // not the already-rendered scene content beneath it.
        canvas.SaveLayer(destRect, null);
 
        canvas.DrawRect(destRect, _darknessPaint);
 
        for (int i = 0; i < _revealSources.Count; i++)
        {
            var source = _revealSources[i];
            if (!source.Enabled || source.RadiusWorldPx <= 0.01f || source.Intensity <= 0.001f)
                continue;
 
            var centerScreen = WorldPointToDrawRect(source.CenterWorldPx, destRectScreen);
            float radiusScreen = WorldRadiusToDrawRadius(source.RadiusWorldPx, destRectScreen);
 
            if (radiusScreen <= 0.01f)
                continue;
 
            using var revealShader = BuildRevealShader(centerScreen, radiusScreen, source.Intensity);
            using var revealPaint = new SKPaint
            {
                IsAntialias = true,
                BlendMode = SKBlendMode.DstOut,
                Shader = revealShader,
                Style = SKPaintStyle.Fill
            };
 
            canvas.DrawRect(destRect, revealPaint);
        }
 
        canvas.Restore();
    }
 
    internal void RefreshFromSourceChange()
    {
        ForceRefresh();
    }
 
    private void OnTrackedLightChanged(DirectRadialLight light)
    {
        foreach (var tracked in _trackedLightReveals.Where(t => ReferenceEquals(t.Light, light)).ToArray())
            SyncTrackedLight(tracked);
    }
 
    private void OnTrackedLightDisposing(object? sender, IDirectDrawable drawing)
    {
        if (drawing is DirectRadialLight light)
            UntrackLight(light);
    }
 
    private void OnTrackedLayerLightAdded(DirectRadialLight light)
    {
        if (!ReferenceEquals(light.SceneLayer, SceneLayer))
            return;
 
        foreach (var trackedLayer in _trackedLightLayers.Where(t => t.LightLayer.Lights.Contains(light)).ToArray())
            TrackLight(light, trackedLayer.RadiusScale, trackedLayer.IntensityScale, trackedLayer.TrackIntensity);
    }
 
    private void OnTrackedLayerLightRemoving(DirectRadialLight light)
    {
        UntrackLight(light);
    }
 
    private void SyncTrackedLight(TrackedLightReveal tracked)
    {
        var light = tracked.Light;
        float intensity = tracked.TrackIntensity
            ? light.EffectiveIntensity * tracked.IntensityScale
            : tracked.IntensityScale;
 
        tracked.Source.SyncFromTrackedLight(
            light.CenterWorldPx,
            light.RadiusWorldPx * tracked.RadiusScale,
            intensity);
    }
 
    private void UntrackLight(TrackedLightReveal tracked, bool removeRevealSource)
    {
        tracked.Light.Changed -= OnTrackedLightChanged;
        tracked.Light.Disposing -= OnTrackedLightDisposing;
        _trackedLightReveals.Remove(tracked);
 
        if (removeRevealSource)
            _revealSources.Remove(tracked.Source);
 
        ForceRefresh();
    }
 
    private void EnsureSameSceneLayer(DirectRadialLight light)
    {
        if (!ReferenceEquals(light.SceneLayer, SceneLayer))
            throw new ArgumentException("SceneLayer-bound darkness can only track lights attached to the same SceneLayer.", nameof(light));
    }
 
    private PointF WorldPointToDrawRect(PointF worldPx, RectangleF destRectScreen)
    {
        float scaleX = destRectScreen.Width / WorldBounds.Width;
        float scaleY = destRectScreen.Height / WorldBounds.Height;
 
        return new PointF(
            destRectScreen.Left + (worldPx.X - WorldBounds.Left) * scaleX,
            destRectScreen.Top + (worldPx.Y - WorldBounds.Top) * scaleY);
    }
 
    private float WorldRadiusToDrawRadius(float radiusWorldPx, RectangleF destRectScreen)
    {
        float scaleX = destRectScreen.Width / WorldBounds.Width;
        float scaleY = destRectScreen.Height / WorldBounds.Height;
 
        return Math.Max(Math.Abs(radiusWorldPx * scaleX), Math.Abs(radiusWorldPx * scaleY));
    }
 
    private void RebuildDarknessPaint()
    {
        _darknessPaint.Color = Color.FromArgb(_darknessOpacity, _darknessColor).ToSKColor();
    }
 
    private SKShader BuildRevealShader(PointF centerScreenPx, float radiusScreenPx, float intensity)
    {
        byte centerAlpha = (byte)Math.Clamp((int)Math.Round(255f * Math.Clamp(intensity, 0f, 1f)), 0, 255);
        byte midAlpha = (byte)Math.Clamp((int)Math.Round(255f * Math.Clamp(intensity, 0f, 1f) * _midpointStrength), 0, 255);
 
        return SKShader.CreateRadialGradient(
            new SKPoint(centerScreenPx.X, centerScreenPx.Y),
            radiusScreenPx,
            colors:
            [
                new SKColor(255, 255, 255, centerAlpha),
                new SKColor(255, 255, 255, centerAlpha),
                new SKColor(255, 255, 255, midAlpha),
                new SKColor(255, 255, 255, 0)
            ],
            colorPos:
            [
                0f,
                _innerClearRadiusRatio,
                _midpointRadiusRatio,
                1f
            ],
            mode: SKShaderTileMode.Clamp);
    }

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            ClearRevealSources();
            _darknessPaint.Dispose();
        }
 
        base.Dispose(disposing);
    }
 
    private sealed class TrackedLightReveal(
        DirectRadialLight light,
        RevealSource source,
        float radiusScale,
        float intensityScale,
        bool trackIntensity)
    {
        public DirectRadialLight Light { get; } = light;
        public RevealSource Source { get; } = source;
        public float RadiusScale { get; } = radiusScale;
        public float IntensityScale { get; } = intensityScale;
        public bool TrackIntensity { get; } = trackIntensity;
    }
 
    private sealed class TrackedLightLayerReveal(
        DirectLightLayer lightLayer,
        float radiusScale,
        float intensityScale,
        bool trackIntensity)
    {
        public DirectLightLayer LightLayer { get; } = lightLayer;
        public float RadiusScale { get; } = radiusScale;
        public float IntensityScale { get; } = intensityScale;
        public bool TrackIntensity { get; } = trackIntensity;
    }

    public sealed class RevealSource
    {
        private readonly DirectSceneLayerDarknessOverlay _owner;
        private PointF _centerWorldPx;
        private float _radiusWorldPx;
        private float _intensity = 1f;
        private bool _enabled = true;
 
        internal RevealSource(DirectSceneLayerDarknessOverlay owner, PointF centerWorldPx, float radiusWorldPx, string? nickname)
        {
            _owner = owner;
            _centerWorldPx = centerWorldPx;
            _radiusWorldPx = Math.Max(0f, radiusWorldPx);
            Nickname = nickname;
        }

        public string? Nickname { get; }

        public bool Enabled
        {
            get => _enabled;
            set
            {
                if (_enabled == value)
                    return;
 
                _enabled = value;
                _owner.RefreshFromSourceChange();
            }
        }

        public PointF CenterWorldPx
        {
            get => _centerWorldPx;
            set
            {
                if (_centerWorldPx == value)
                    return;
 
                _centerWorldPx = value;
                _owner.RefreshFromSourceChange();
            }
        }

        public float RadiusWorldPx
        {
            get => _radiusWorldPx;
            set
            {
                float clamped = Math.Max(0f, value);
                if (Math.Abs(_radiusWorldPx - clamped) < 0.0001f)
                    return;
 
                _radiusWorldPx = clamped;
                _owner.RefreshFromSourceChange();
            }
        }

        public float Intensity
        {
            get => _intensity;
            set
            {
                float clamped = Math.Clamp(value, 0f, 1f);
                if (Math.Abs(_intensity - clamped) < 0.0001f)
                    return;
 
                _intensity = clamped;
                _owner.RefreshFromSourceChange();
            }
        }

        public void MoveTo(PointF centerWorldPx)
        {
            CenterWorldPx = centerWorldPx;
        }

        public void SetRadius(float radiusWorldPx)
        {
            RadiusWorldPx = radiusWorldPx;
        }
 
        internal void SyncFromTrackedLight(PointF centerWorldPx, float radiusWorldPx, float intensity)
        {
            bool changed =
                _centerWorldPx != centerWorldPx ||
                Math.Abs(_radiusWorldPx - radiusWorldPx) >= 0.0001f ||
                Math.Abs(_intensity - intensity) >= 0.0001f;
 
            if (!changed)
                return;
 
            _centerWorldPx = centerWorldPx;
            _radiusWorldPx = Math.Max(0f, radiusWorldPx);
            _intensity = Math.Clamp(intensity, 0f, 1f);
            _owner.RefreshFromSourceChange();
        }
    }
}