Apply RoofOverlay per-grid not per-map + fix lighting quality (#35207)

* Apply RoofOverlay per-grid not per-map

* Fix light render scales

diff --git a/Content.Client/Light/AfterLightTargetOverlay.cs b/Content.Client/Light/AfterLightTargetOverlay.cs
index 5cfe1e993b038483728f2ecfa994f4a38800c614..06c508a54ee52b7d6369b18b0989c1ac5d75a888 100644 (file)
--- a/Content.Client/Light/AfterLightTargetOverlay.cs
+++ b/Content.Client/Light/AfterLightTargetOverlay.cs
@@ -33,7 +33,8 @@ public sealed class AfterLightTargetOverlay : Overlay
         var bounds = args.WorldBounds;
 
         // at 1-1 render scale it's mostly fine but at 4x4 it's way too fkn big
-        var newScale = viewport.RenderScale / 2f;
+        var lightScale = viewport.LightRenderTarget.Size / (Vector2) viewport.Size;
+        var newScale = viewport.RenderScale / (Vector2.One / lightScale);
 
         var localMatrix =
             viewport.LightRenderTarget.GetWorldToLocalMatrix(viewport.Eye, newScale);

diff --git a/Content.Client/Light/LightBlurOverlay.cs b/Content.Client/Light/LightBlurOverlay.cs
index ae0684f9ffccb55e0d3269087824ef22c29ae042..684f5a94523358377018c53044d9dd98f8db39e4 100644 (file)
--- a/Content.Client/Light/LightBlurOverlay.cs
+++ b/Content.Client/Light/LightBlurOverlay.cs
@@ -39,6 +39,6 @@ public sealed class LightBlurOverlay : Overlay
 
         var target = beforeOverlay.EnlargedLightTarget;
         // Yeah that's all this does keep walkin.
-        _clyde.BlurRenderTarget(args.Viewport, target, _blurTarget, args.Viewport.Eye, 14f * 2f);
+        //_clyde.BlurRenderTarget(args.Viewport, target, _blurTarget, args.Viewport.Eye, 14f * 2f);
     }
 }

diff --git a/Content.Client/Light/RoofOverlay.cs b/Content.Client/Light/RoofOverlay.cs
index 981edf793c8e3a495abdf8a7aca8743f8466d67c..5543103cdc64de2233b014584c4eb8cfc4f69a51 100644 (file)
--- a/Content.Client/Light/RoofOverlay.cs
+++ b/Content.Client/Light/RoofOverlay.cs
@@ -3,13 +3,16 @@ 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.Physics;
 
 namespace Content.Client.Light;
 
 public sealed class RoofOverlay : Overlay
 {
     private readonly IEntityManager _entManager;
+    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IOverlayManager _overlay = default!;
 
     private readonly EntityLookupSystem _lookup;
@@ -17,6 +20,7 @@ public sealed class RoofOverlay : Overlay
     private readonly SharedTransformSystem _xformSystem;
 
     private readonly HashSet<Entity<OccluderComponent>> _occluders = new();
+    private List<Entity<MapGridComponent>> _grids = new();
 
     public override OverlaySpace Space => OverlaySpace.BeforeLighting;
 
@@ -39,14 +43,6 @@ public sealed class RoofOverlay : Overlay
         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;
 
@@ -55,46 +51,72 @@ public sealed class RoofOverlay : Overlay
         var bounds = lightoverlay.EnlargedBounds;
         var target = lightoverlay.EnlargedLightTarget;
 
+        _grids.Clear();
+        _mapManager.FindGridsIntersecting(args.MapId, bounds, ref _grids);
+
+        for (var i = _grids.Count - 1; i >= 0; i--)
+        {
+            var grid = _grids[i];
+
+            if (_entManager.HasComponent<RoofComponent>(grid.Owner))
+                continue;
+
+            _grids.RemoveAt(i);
+        }
+
+        if (_grids.Count == 0)
+            return;
+
+        var lightScale = viewport.LightRenderTarget.Size / (Vector2) viewport.Size;
+        var scale = viewport.RenderScale / (Vector2.One / lightScale);
+
         worldHandle.RenderInRenderTarget(target,
             () =>
             {
-                var invMatrix = target.GetWorldToLocalMatrix(eye, viewport.RenderScale / 2f);
+                foreach (var grid in _grids)
+                {
+                    if (!_entManager.TryGetComponent(grid.Owner, out RoofComponent? roof))
+                        continue;
 
-                var gridMatrix = _xformSystem.GetWorldMatrix(mapEnt);
-                var matty = Matrix3x2.Multiply(gridMatrix, invMatrix);
+                    var invMatrix = target.GetWorldToLocalMatrix(eye, scale);
 
-                worldHandle.SetTransform(matty);
+                    var gridMatrix = _xformSystem.GetWorldMatrix(grid.Owner);
+                    var matty = Matrix3x2.Multiply(gridMatrix, invMatrix);
 
-                var tileEnumerator = _mapSystem.GetTilesEnumerator(mapEnt, grid, bounds);
+                    worldHandle.SetTransform(matty);
 
-                // Due to stencilling we essentially draw on unrooved tiles
-                while (tileEnumerator.MoveNext(out var tileRef))
-                {
-                    if ((tileRef.Tile.Flags & (byte) 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;
+                    var tileEnumerator = _mapSystem.GetTilesEnumerator(grid.Owner, grid, bounds);
 
-                        foreach (var occluder in _occluders)
+                    // Due to stencilling we essentially draw on unrooved tiles
+                    while (tileEnumerator.MoveNext(out var tileRef))
+                    {
+                        if ((tileRef.Tile.Flags & (byte) TileFlag.Roof) == 0x0)
                         {
-                            if (!occluder.Comp.Enabled)
+                            // 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(grid.Owner, tileRef.GridIndices, _occluders);
+                            var found = false;
+
+                            foreach (var occluder in _occluders)
+                            {
+                                if (!occluder.Comp.Enabled)
+                                    continue;
+
+                                found = true;
+                                break;
+                            }
+
+                            if (!found)
                                 continue;
-
-                            found = true;
-                            break;
                         }
 
-                        if (!found)
-                            continue;
+                        var local = _lookup.GetLocalBounds(tileRef, grid.Comp.TileSize);
+                        worldHandle.DrawRect(local, roof.Color);
                     }
-
-                    var local = _lookup.GetLocalBounds(tileRef, grid.TileSize);
-                    worldHandle.DrawRect(local, roofComp.Color);
                 }
-
             }, null);
+
+        worldHandle.SetTransform(Matrix3x2.Identity);
     }
 }

diff --git a/Content.Client/Light/TileEmissionOverlay.cs b/Content.Client/Light/TileEmissionOverlay.cs
index bccc6fc21e6753687648472f4164bf24221c5b14..2f4a1390ff6368437234806661cb0a6f81294506 100644 (file)
--- a/Content.Client/Light/TileEmissionOverlay.cs
+++ b/Content.Client/Light/TileEmissionOverlay.cs
@@ -49,13 +49,19 @@ public sealed class TileEmissionOverlay : Overlay
         var bounds = lightoverlay.EnlargedBounds;
         var target = lightoverlay.EnlargedLightTarget;
         var viewport = args.Viewport;
+        _grids.Clear();
+        _mapManager.FindGridsIntersecting(mapId, bounds, ref _grids, approx: true);
+
+        if (_grids.Count == 0)
+            return;
+
+        var lightScale = viewport.LightRenderTarget.Size / (Vector2) viewport.Size;
+        var scale = viewport.RenderScale / (Vector2.One / lightScale);
 
         args.WorldHandle.RenderInRenderTarget(target,
         () =>
         {
-            var invMatrix = target.GetWorldToLocalMatrix(viewport.Eye, viewport.RenderScale / 2f);
-            _grids.Clear();
-            _mapManager.FindGridsIntersecting(mapId, bounds, ref _grids, approx: true);
+            var invMatrix = target.GetWorldToLocalMatrix(viewport.Eye, scale);
 
             foreach (var grid in _grids)
             {