Merge branch 'Rxup:master' into Disable-Tile-Rip

Content.Benchmarks/ComponentQueryBenchmark.cs

@@ -9,13 +9,14 @@
 using Content.Shared.Clothing.Components;
 using Content.Shared.Doors.Components;
 using Content.Shared.Item;
-using Robust.Server.GameObjects;
 using Robust.Shared;
 using Robust.Shared.Analyzers;
+using Robust.Shared.EntitySerialization;
+using Robust.Shared.EntitySerialization.Systems;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Random;
+using Robust.Shared.Utility;
 
 namespace Content.Benchmarks;
 
@@ -32,7 +33,6 @@ public class ComponentQueryBenchmark
 
     private TestPair _pair = default!;
     private IEntityManager _entMan = default!;
-    private MapId _mapId = new(10);
     private EntityQuery<ItemComponent> _itemQuery;
     private EntityQuery<ClothingComponent> _clothingQuery;
     private EntityQuery<MapComponent> _mapQuery;
@@ -54,10 +54,10 @@ public void Setup()
         _pair.Server.ResolveDependency<IRobustRandom>().SetSeed(42);
         _pair.Server.WaitPost(() =>
         {
-            var success = _entMan.System<MapLoaderSystem>().TryLoad(_mapId, Map, out _);
-            if (!success)
+            var map = new ResPath(Map);
+            var opts = DeserializationOptions.Default with {InitializeMaps = true};
+            if (!_entMan.System<MapLoaderSystem>().TryLoadMap(map, out _, out _, opts))
                 throw new Exception("Map load failed");
-            _pair.Server.MapMan.DoMapInitialize(_mapId);
         }).GetAwaiter().GetResult();
 
         _items = new EntityUid[_entMan.Count<ItemComponent>()];

Content.Benchmarks/MapLoadBenchmark.cs

@@ -6,12 +6,13 @@
 using Content.IntegrationTests;
 using Content.IntegrationTests.Pair;
 using Content.Server.Maps;
-using Robust.Server.GameObjects;
 using Robust.Shared;
 using Robust.Shared.Analyzers;
+using Robust.Shared.EntitySerialization.Systems;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
 
 namespace Content.Benchmarks;
 
@@ -20,7 +21,7 @@ public class MapLoadBenchmark
 {
     private TestPair _pair = default!;
     private MapLoaderSystem _mapLoader = default!;
-    private IMapManager _mapManager = default!;
+    private SharedMapSystem _mapSys = default!;
 
     [GlobalSetup]
     public void Setup()
@@ -36,7 +37,7 @@ public void Setup()
             .ToDictionary(x => x.ID, x => x.MapPath.ToString());
 
         _mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();
-        _mapManager = server.ResolveDependency<IMapManager>();
+        _mapSys = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<SharedMapSystem>();
     }
 
     [GlobalCleanup]
@@ -52,27 +53,27 @@ public async Task Cleanup()
     public string Map;
 
     public Dictionary<string, string> Paths;
+    private MapId _mapId;
 
     [Benchmark]
     public async Task LoadMap()
     {
-        var mapPath = Paths[Map];
+        var mapPath = new ResPath(Paths[Map]);
         var server = _pair.Server;
         await server.WaitPost(() =>
         {
-            var success = _mapLoader.TryLoad(new MapId(10), mapPath, out _);
+            var success = _mapLoader.TryLoadMap(mapPath, out var map, out _);
             if (!success)
                 throw new Exception("Map load failed");
+            _mapId = map.Value.Comp.MapId;
         });
     }
 
     [IterationCleanup]
     public void IterationCleanup()
     {
         var server = _pair.Server;
-        server.WaitPost(() =>
-        {
-            _mapManager.DeleteMap(new MapId(10));
-        }).Wait();
+        server.WaitPost(() => _mapSys.DeleteMap(_mapId))
+            .Wait();
     }
 }

Content.Benchmarks/PvsBenchmark.cs

@@ -7,13 +7,15 @@
 using Content.IntegrationTests.Pair;
 using Content.Server.Mind;
 using Content.Server.Warps;
-using Robust.Server.GameObjects;
 using Robust.Shared;
 using Robust.Shared.Analyzers;
+using Robust.Shared.EntitySerialization;
+using Robust.Shared.EntitySerialization.Systems;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Player;
 using Robust.Shared.Random;
+using Robust.Shared.Utility;
 
 namespace Content.Benchmarks;
 
@@ -34,7 +36,6 @@ public class PvsBenchmark
 
     private TestPair _pair = default!;
     private IEntityManager _entMan = default!;
-    private MapId _mapId = new(10);
     private ICommonSession[] _players = default!;
     private EntityCoordinates[] _spawns = default!;
     public int _cycleOffset = 0;
@@ -65,10 +66,10 @@ private async Task SetupAsync()
         _pair.Server.ResolveDependency<IRobustRandom>().SetSeed(42);
         await _pair.Server.WaitPost(() =>
         {
-            var success = _entMan.System<MapLoaderSystem>().TryLoad(_mapId, Map, out _);
-            if (!success)
+            var path = new ResPath(Map);
+            var opts = DeserializationOptions.Default with {InitializeMaps = true};
+            if (!_entMan.System<MapLoaderSystem>().TryLoadMap(path, out _, out _, opts))
                 throw new Exception("Map load failed");
-            _pair.Server.MapMan.DoMapInitialize(_mapId);
         });
 
         // Get list of ghost warp positions

Content.Client/Chemistry/EntitySystems/ChemistryGuideDataSystem.cs

@@ -141,6 +141,11 @@ public List<ReagentSourceData> GetReagentSources(string id)
     {
         return _reagentSources.GetValueOrDefault(id) ?? new List<ReagentSourceData>();
     }
+
+    // Is handled on server and updated on client via ReagentGuideRegistryChangedEvent
+    public override void ReloadAllReagentPrototypes()
+    {
+    }
 }
 
 /// <summary>

Content.Client/Construction/ConstructionGhostComponent.cs

@@ -7,6 +7,7 @@ namespace Content.Client.Construction
     [RegisterComponent]
     public sealed partial class ConstructionGhostComponent : Component
     {
+        public int GhostId { get; set; }
         [ViewVariables] public ConstructionPrototype? Prototype { get; set; }
     }
 }

Content.Client/Construction/ConstructionSystem.cs

@@ -55,6 +55,12 @@ public override void Initialize()
                 .Register<ConstructionSystem>();
 
             SubscribeLocalEvent<ConstructionGhostComponent, ExaminedEvent>(HandleConstructionGhostExamined);
+            SubscribeLocalEvent<ConstructionGhostComponent, ComponentShutdown>(HandleGhostComponentShutdown);
+        }
+
+        private void HandleGhostComponentShutdown(EntityUid uid, ConstructionGhostComponent component, ComponentShutdown args)
+        {
+            ClearGhost(component.GhostId);
         }
 
         private void OnConstructionGuideReceived(ResponseConstructionGuide ev)
@@ -205,8 +211,9 @@ public bool TrySpawnGhost(
             ghost = EntityManager.SpawnEntity("constructionghost", loc);
             var comp = EntityManager.GetComponent<ConstructionGhostComponent>(ghost.Value);
             comp.Prototype = prototype;
+            comp.GhostId = ghost.GetHashCode();
             EntityManager.GetComponent<TransformComponent>(ghost.Value).LocalRotation = dir.ToAngle();
-            _ghosts.Add(ghost.GetHashCode(), ghost.Value);
+            _ghosts.Add(comp.GhostId, ghost.Value);
             var sprite = EntityManager.GetComponent<SpriteComponent>(ghost.Value);
             sprite.Color = new Color(48, 255, 48, 128);
 

Content.Client/CriminalRecords/CriminalRecordsConsoleWindow.xaml

@@ -58,9 +58,7 @@
                            StyleClasses="LabelBig" />
                     <BoxContainer Orientation="Horizontal"
                                   Margin="0 0 0 5">
-                        <Label Text="{Loc 'crew-monitoring-user-interface-job'}:"
-                               FontColorOverride="DarkGray" />
-                        <Label Text=":"
+                        <Label Text="{Loc 'crew-monitoring-user-interface-job'}"
                                FontColorOverride="DarkGray" />
                         <TextureRect Name="PersonJobIcon"
                                      TextureScale="2 2"

Content.Client/Dice/DiceSystem.cs

@@ -5,17 +5,24 @@ namespace Content.Client.Dice;
 
 public sealed class DiceSystem : SharedDiceSystem
 {
-    protected override void UpdateVisuals(EntityUid uid, DiceComponent? die = null)
+    public override void Initialize()
     {
-        if (!Resolve(uid, ref die) || !TryComp(uid, out SpriteComponent? sprite))
+        base.Initialize();
+
+        SubscribeLocalEvent<DiceComponent, AfterAutoHandleStateEvent>(OnDiceAfterHandleState);
+    }
+
+    private void OnDiceAfterHandleState(Entity<DiceComponent> entity, ref AfterAutoHandleStateEvent args)
+    {
+        if (!TryComp<SpriteComponent>(entity, out var sprite))
             return;
 
-        // TODO maybe just move each diue to its own RSI?
+        // TODO maybe just move each die to its own RSI?
         var state = sprite.LayerGetState(0).Name;
         if (state == null)
             return;
 
         var prefix = state.Substring(0, state.IndexOf('_'));
-        sprite.LayerSetState(0, $"{prefix}_{die.CurrentValue}");
+        sprite.LayerSetState(0, $"{prefix}_{entity.Comp.CurrentValue}");
     }
 }

Content.Client/Light/AfterLightTargetOverlay.cs

@@ -0,0 +1,59 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+
+namespace Content.Client.Light;
+
+/// <summary>
+/// This exists just to copy <see cref="BeforeLightTargetOverlay"/> to the light render target
+/// </summary>
+public sealed class AfterLightTargetOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+
+    public const int ContentZIndex = LightBlurOverlay.ContentZIndex + 1;
+
+    public AfterLightTargetOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        ZIndex = ContentZIndex;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var viewport = args.Viewport;
+        var worldHandle = args.WorldHandle;
+
+        if (viewport.Eye == null)
+            return;
+
+        var lightOverlay = _overlay.GetOverlay<BeforeLightTargetOverlay>();
+        var bounds = args.WorldBounds;
+
+        // at 1-1 render scale it's mostly fine but at 4x4 it's way too fkn big
+        var lightScale = viewport.LightRenderTarget.Size / (Vector2) viewport.Size;
+        var newScale = viewport.RenderScale / (Vector2.One / lightScale);
+
+        var localMatrix =
+            viewport.LightRenderTarget.GetWorldToLocalMatrix(viewport.Eye, newScale);
+        var diff = (lightOverlay.EnlargedLightTarget.Size - viewport.LightRenderTarget.Size);
+        var halfDiff = diff / 2;
+
+        // Pixels -> Metres -> Half distance.
+        // If we're zoomed in need to enlarge the bounds further.
+        args.WorldHandle.RenderInRenderTarget(viewport.LightRenderTarget,
+            () =>
+            {
+                // We essentially need to draw the cropped version onto the lightrendertarget.
+                var subRegion = new UIBox2i(halfDiff.X,
+                    halfDiff.Y,
+                    viewport.LightRenderTarget.Size.X + halfDiff.X,
+                    viewport.LightRenderTarget.Size.Y + halfDiff.Y);
+
+                worldHandle.SetTransform(localMatrix);
+                worldHandle.DrawTextureRectRegion(lightOverlay.EnlargedLightTarget.Texture, bounds, subRegion: subRegion);
+            }, null);
+    }
+}

Content.Client/Light/BeforeLightTargetOverlay.cs

@@ -0,0 +1,51 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+
+namespace Content.Client.Light;
+
+/// <summary>
+/// Handles an enlarged lighting target so content can use large blur radii.
+/// </summary>
+public sealed class BeforeLightTargetOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.BeforeLighting;
+
+    [Dependency] private readonly IClyde _clyde = default!;
+
+    public IRenderTexture EnlargedLightTarget = default!;
+    public Box2Rotated EnlargedBounds;
+
+    /// <summary>
+    /// In metres
+    /// </summary>
+    private float _skirting = 2f;
+
+    public const int ContentZIndex = -10;
+
+    public BeforeLightTargetOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        ZIndex = ContentZIndex;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        // Code is weird but I don't think engine should be enlarging the lighting render target arbitrarily either, maybe via cvar?
+        // The problem is the blur has no knowledge of pixels outside the viewport so with a large enough blur radius you get sampling issues.
+        var size = args.Viewport.LightRenderTarget.Size + (int) (_skirting * EyeManager.PixelsPerMeter);
+        EnlargedBounds = args.WorldBounds.Enlarged(_skirting / 2f);
+
+        // This just exists to copy the lightrendertarget and write back to it.
+        if (EnlargedLightTarget?.Size != size)
+        {
+            EnlargedLightTarget = _clyde
+                .CreateRenderTarget(size, new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb), name: "enlarged-light-copy");
+        }
+
+        args.WorldHandle.RenderInRenderTarget(EnlargedLightTarget,
+            () =>
+            {
+            }, _clyde.GetClearColor(args.MapUid));
+    }
+}

Content.Client/Light/EntitySystems/PlanetLightSystem.cs

@@ -0,0 +1,36 @@
+using Robust.Client.Graphics;
+
+namespace Content.Client.Light.EntitySystems;
+
+public sealed class PlanetLightSystem : EntitySystem
+{
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<GetClearColorEvent>(OnClearColor);
+
+        _overlayMan.AddOverlay(new BeforeLightTargetOverlay());
+        _overlayMan.AddOverlay(new RoofOverlay(EntityManager));
+        _overlayMan.AddOverlay(new TileEmissionOverlay(EntityManager));
+        _overlayMan.AddOverlay(new LightBlurOverlay());
+        _overlayMan.AddOverlay(new AfterLightTargetOverlay());
+    }
+
+    private void OnClearColor(ref GetClearColorEvent ev)
+    {
+        ev.Color = Color.Transparent;
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _overlayMan.RemoveOverlay<BeforeLightTargetOverlay>();
+        _overlayMan.RemoveOverlay<RoofOverlay>();
+        _overlayMan.RemoveOverlay<TileEmissionOverlay>();
+        _overlayMan.RemoveOverlay<LightBlurOverlay>();
+        _overlayMan.RemoveOverlay<AfterLightTargetOverlay>();
+    }
+}

Content.Client/Light/EntitySystems/RoofSystem.cs

@@ -0,0 +1,9 @@
+using Content.Shared.Light.EntitySystems;
+
+namespace Content.Client.Light.EntitySystems;
+
+/// <inheritdoc/>
+public sealed class RoofSystem : SharedRoofSystem
+{
+
+}