Add planet lighting

Content.Client/Light/EntitySystems/PlanetLightSystem.cs

@@ -0,0 +1,23 @@
+using Robust.Client.Graphics;
+
+namespace Content.Client.Light.EntitySystems;
+
+public sealed class PlanetLightSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    private RoofOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _overlay = new(EntityManager);
+        _overlayMan.AddOverlay(_overlay);
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+}

Content.Client/Light/EntitySystems/TileEmissionSystem.cs

@@ -0,0 +1,23 @@
+using Robust.Client.Graphics;
+
+namespace Content.Client.Light.EntitySystems;
+
+public sealed class TileEmissionSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    private TileEmissionOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _overlay = new(EntityManager);
+        _overlayMan.AddOverlay(_overlay);
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _overlayMan.RemoveOverlay(_overlay);
+    }
+}

Content.Client/Light/LightCycleSystem.cs

@@ -0,0 +1,32 @@
+using Content.Client.GameTicking.Managers;
+using Content.Shared;
+using Content.Shared.Light.Components;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Light;
+
+public sealed class LightCycleSystem : SharedLightCycleSystem
+{
+    [Dependency] private readonly ClientGameTicker _ticker = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+        var mapQuery = AllEntityQuery<LightCycleComponent, MapLightComponent>();
+        while (mapQuery.MoveNext(out var uid,  out var cycle, out var map))
+        {
+            if (!cycle.Running)
+                continue;
+
+            var time = (float) _timing.CurTime
+                .Add(cycle.Offset)
+                .Subtract(_ticker.RoundStartTimeSpan)
+                .TotalSeconds;
+
+            var color = GetColor((uid, cycle), cycle.OriginalColor, time);
+            map.AmbientLightColor = color;
+        }
+    }
+}

Content.Client/Light/RoofOverlay.cs

@@ -0,0 +1,121 @@
+using System.Numerics;
+using Content.Shared.Light.Components;
+using Content.Shared.Maps;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Light;
+
+public sealed class RoofOverlay : Overlay
+{
+    [Dependency] private readonly IClyde _clyde = default!;
+    [Dependency] private readonly IPrototypeManager _protoManager = default!;
+    private readonly IEntityManager _entManager;
+
+    private readonly EntityLookupSystem _lookup;
+    private readonly SharedMapSystem _mapSystem;
+    private readonly SharedTransformSystem _xformSystem;
+
+    private readonly HashSet<Entity<OccluderComponent>> _occluders = new();
+
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    private IRenderTexture? _target;
+
+    public RoofOverlay(IEntityManager entManager)
+    {
+        _entManager = entManager;
+        IoCManager.InjectDependencies(this);
+
+        _lookup = _entManager.System<EntityLookupSystem>();
+        _mapSystem = _entManager.System<SharedMapSystem>();
+        _xformSystem = _entManager.System<SharedTransformSystem>();
+
+        ZIndex = -1;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (args.Viewport.Eye == null)
+            return;
+
+        var mapEnt = _mapSystem.GetMap(args.MapId);
+
+        if (!_entManager.TryGetComponent(mapEnt, out RoofComponent? roofComp) ||
+            !_entManager.TryGetComponent(mapEnt, out MapGridComponent? grid))
+        {
+            return;
+        }
+
+        var viewport = args.Viewport;
+        var eye = args.Viewport.Eye;
+
+        var worldHandle = args.WorldHandle;
+        var bounds = args.WorldBounds;
+
+        if (_target?.Size != viewport.LightRenderTarget.Size)
+        {
+            _target = _clyde
+                .CreateRenderTarget(viewport.LightRenderTarget.Size,
+                    new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb), name: "roof-target");
+        }
+
+        worldHandle.RenderInRenderTarget(_target,
+            () =>
+            {
+                var invMatrix = _target.GetWorldToLocalMatrix(eye, viewport.RenderScale / 2f);
+
+                var gridMatrix = _xformSystem.GetWorldMatrix(mapEnt);
+                var matty = Matrix3x2.Multiply(gridMatrix, invMatrix);
+
+                worldHandle.SetTransform(matty);
+
+                var tileEnumerator = _mapSystem.GetTilesEnumerator(mapEnt, grid, bounds);
+
+                // Due to stencilling we essentially draw on unrooved tiles
+                while (tileEnumerator.MoveNext(out var tileRef))
+                {
+                    if ((tileRef.Tile.ContentFlag & (ushort) TileFlag.Roof) == 0x0)
+                    {
+                        // Check if the tile is occluded in which case hide it anyway.
+                        // This is to avoid lit walls bleeding over to unlit tiles.
+                        _occluders.Clear();
+                        _lookup.GetLocalEntitiesIntersecting(mapEnt, tileRef.GridIndices, _occluders);
+                        var found = false;
+
+                        foreach (var occluder in _occluders)
+                        {
+                            if (!occluder.Comp.Enabled)
+                                continue;
+
+                            found = true;
+                            break;
+                        }
+
+                        if (!found)
+                            continue;
+                    }
+
+                    var local = _lookup.GetLocalBounds(tileRef, grid.TileSize);
+                    worldHandle.DrawRect(local, roofComp.Color);
+                }
+
+            }, Color.Transparent);
+
+        args.WorldHandle.RenderInRenderTarget(viewport.LightRenderTarget,
+            () =>
+            {
+                var invMatrix =
+                    viewport.LightRenderTarget.GetWorldToLocalMatrix(viewport.Eye, viewport.RenderScale / 2f);
+                worldHandle.SetTransform(invMatrix);
+
+                var maskShader = _protoManager.Index<ShaderPrototype>("Mix").Instance();
+                worldHandle.UseShader(maskShader);
+
+                worldHandle.DrawTextureRect(_target.Texture, bounds);
+            }, null);
+    }
+}

Content.Client/Light/TileEmissionOverlay.cs

@@ -0,0 +1,110 @@
+using System.Numerics;
+using Content.Shared.Light.Components;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client.Light;
+
+public sealed class TileEmissionOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    [Dependency] private readonly IClyde _clyde = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IPrototypeManager _protoManager = default!;
+
+    private SharedMapSystem _mapSystem;
+    private SharedTransformSystem _xformSystem;
+
+    private readonly EntityLookupSystem _lookup;
+
+    private readonly EntityQuery<TransformComponent> _xformQuery;
+    private readonly HashSet<Entity<TileEmissionComponent>> _entities = new();
+
+    private List<Entity<MapGridComponent>> _grids = new();
+
+    private IRenderTexture? _target;
+
+    public TileEmissionOverlay(IEntityManager entManager)
+    {
+        IoCManager.InjectDependencies(this);
+
+        _lookup = entManager.System<EntityLookupSystem>();
+        _mapSystem = entManager.System<SharedMapSystem>();
+        _xformSystem = entManager.System<SharedTransformSystem>();
+
+        _xformQuery = entManager.GetEntityQuery<TransformComponent>();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (args.Viewport.Eye == null)
+            return;
+
+        var mapId = args.MapId;
+        var worldHandle = args.WorldHandle;
+        var bounds = args.WorldBounds;
+        var expandedBounds = bounds.Enlarged(1.5f);
+        var viewport = args.Viewport;
+
+        if (_target?.Size != viewport.LightRenderTarget.Size)
+        {
+            _target = _clyde
+                .CreateRenderTarget(viewport.LightRenderTarget.Size, new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb), name: "tile-emissions");
+        }
+
+        args.WorldHandle.RenderInRenderTarget(_target,
+        () =>
+        {
+            var invMatrix = _target.GetWorldToLocalMatrix(viewport.Eye, viewport.RenderScale / 2f);
+            _grids.Clear();
+            _mapManager.FindGridsIntersecting(mapId, expandedBounds, ref _grids, approx: true);
+
+            foreach (var grid in _grids)
+            {
+                var gridInvMatrix = _xformSystem.GetInvWorldMatrix(grid);
+                var localBounds = gridInvMatrix.TransformBox(expandedBounds);
+                _entities.Clear();
+                _lookup.GetLocalEntitiesIntersecting(grid.Owner, localBounds, _entities);
+
+                if (_entities.Count == 0)
+                    continue;
+
+                var gridMatrix = _xformSystem.GetWorldMatrix(grid.Owner);
+
+                foreach (var ent in _entities)
+                {
+                    var xform = _xformQuery.Comp(ent);
+
+                    var tile = _mapSystem.LocalToTile(grid.Owner, grid, xform.Coordinates);
+                    var matty = Matrix3x2.Multiply(gridMatrix, invMatrix);
+
+                    worldHandle.SetTransform(matty);
+
+                    // Yes I am fully aware this leads to overlap. If you really want to have alpha then you'll need
+                    // to turn the squares into polys.
+                    // Additionally no shadows so if you make it too big it's going to go through a 1x wall.
+                    var local = _lookup.GetLocalBounds(tile, grid.Comp.TileSize).Enlarged(ent.Comp.Range);
+                    worldHandle.DrawRect(local, ent.Comp.Color);
+                }
+            }
+        }, Color.Transparent);
+
+        args.WorldHandle.RenderInRenderTarget(viewport.LightRenderTarget,
+            () =>
+            {
+                var invMatrix =
+                    viewport.LightRenderTarget.GetWorldToLocalMatrix(viewport.Eye, viewport.RenderScale / 2f);
+                worldHandle.SetTransform(invMatrix);
+
+                var maskShader = _protoManager.Index<ShaderPrototype>("Mix").Instance();
+                worldHandle.UseShader(maskShader);
+
+                worldHandle.DrawTextureRect(_target.Texture, bounds);
+            }, null);
+    }
+}

Content.Server/Light/Components/SetRoofComponent.cs

@@ -0,0 +1,8 @@
+namespace Content.Server.Light.Components;
+
+[RegisterComponent]
+public sealed partial class SetRoofComponent : Component
+{
+    [DataField(required: true)]
+    public bool Value;
+}

Content.Server/Light/EntitySystems/LightCycleSystem.cs

@@ -0,0 +1,21 @@
+using Content.Shared;
+using Content.Shared.Light.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server.Light.EntitySystems;
+
+public sealed class LightCycleSystem : SharedLightCycleSystem
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+
+    protected override void OnCycleMapInit(Entity<LightCycleComponent> ent, ref MapInitEvent args)
+    {
+        base.OnCycleMapInit(ent, ref args);
+
+        if (ent.Comp.InitialOffset)
+        {
+            ent.Comp.Offset = _random.Next(ent.Comp.Duration);
+            Dirty(ent);
+        }
+    }
+}

Content.Server/Light/EntitySystems/RoofSystem.cs

@@ -0,0 +1,32 @@
+using Content.Server.Light.Components;
+using Content.Shared.Light.EntitySystems;
+using Robust.Shared.Map.Components;
+
+namespace Content.Server.Light.EntitySystems;
+
+public sealed class RoofSystem : SharedRoofSystem
+{
+    [Dependency] private readonly SharedMapSystem _maps = default!;
+
+    private EntityQuery<MapGridComponent> _gridQuery;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _gridQuery = GetEntityQuery<MapGridComponent>();
+        SubscribeLocalEvent<SetRoofComponent, ComponentStartup>(OnFlagStartup);
+    }
+
+    private void OnFlagStartup(Entity<SetRoofComponent> ent, ref ComponentStartup args)
+    {
+        var xform = Transform(ent.Owner);
+
+        if (_gridQuery.TryComp(xform.GridUid, out var grid))
+        {
+            var index = _maps.LocalToTile(xform.GridUid.Value, grid, xform.Coordinates);
+            SetRoof((xform.GridUid.Value, grid, null), index, ent.Comp.Value);
+        }
+
+        QueueDel(ent.Owner);
+    }
+}