Fix showbb

matrices momento

.github/CODEOWNERS

@@ -1,14 +1,7 @@
-# Lines starting with '#' are comments.
-# Each line is a file pattern followed by one or more owners.
+# Last match in file takes precedence.
 
-# These owners will be the default owners for everything in the repo.
-# * @defunkt
-* @Acruid @PJB3005 @Silvertorch5
+# Be they Fluent translations or Freemarker templates, I know them both!
+*.ftl @RemieRichards
 
-# Order is important. The last matching pattern has the most precedence.
-# So if a pull request only touches javascript files, only these owners
-# will be requested to review.
-# *.js    @octocat @github/js
-
-# You can also use email addresses if you prefer.
-# docs/*  docs@example.com
+# Ping for all PRs
+* @Acruid @PJB3005 @Silvertorch5

Avalonia.Base/Avalonia.Base.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net5.0</TargetFramework>
+    </PropertyGroup>
+
+</Project>

Avalonia.Base/README.md

@@ -0,0 +1,2 @@
+See `Robust.Client/UserInterface/XAML/RiderNotes.md` for why this project exists.
+We are not actually using Avalonia (yet).

README.md

@@ -1,25 +1,16 @@
 ![Robust Toolbox](https://raw.githubusercontent.com/space-wizards/asset-dump/3dd3078e49e3a7e06709a6e0fc6e3223d8d44ca2/robust.png)
 
-[![Build status](https://ci.appveyor.com/api/projects/status/ygb7t8hsj3wt7pnm/branch/master?svg=true)](https://ci.appveyor.com/project/Silvertorch5/space-station-14/branch/master)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=ss14&metric=coverage)](https://sonarcloud.io/dashboard?id=ss14)
+Robust Toolbox is an engine primarily being developed for [Space Station 14](https://github.com/space-wizards/space-station-14), although we're working on making it usable for both [singleplayer](https://github.com/space-wizards/RobustToolboxTemplateSingleplayer) and [multiplayer](https://github.com/space-wizards/RobustToolboxTemplate) projects.
 
-Robust Toolbox is a client/server backend for [Space Station 14](https://github.com/space-wizards/space-station-14).
+Use the [content repo](https://github.com/space-wizards/space-station-14) for actual development, even if you're modifying the engine itself.
 
-### *This repository is the *engine* section of SS14. This is the base engine all SS14 servers will be built on. As such, it does not start on its own: it needs the [content repo](https://github.com/space-wizards/space-station-14). Use said repo for actual development, even if you're modifying the engine itself. Think of Robust Toolbox as BYOND in the context of Spacestation 13.*
+## Project Links
 
-## Getting in Touch
+[Website](https://spacestation14.io/) | [Discord](https://discord.gg/t2jac3p) | [Forum](https://forum.spacestation14.io/) | [Steam](https://store.steampowered.com/app/1255460/Space_Station_14/) | [Standalone Download](https://spacestation14.io/about/nightlies/)
 
-* Website: [spacestation14.io](https://spacestation14.io/)
-* Discord: [Invite Link](https://discord.gg/t2jac3p)
-* IRC: `irc.rizon.net#spacebus`
-* Code Analysis: [Sonar Cloud](https://sonarcloud.io/dashboard?id=ss14)
-* Automatic Content Builds: [builds.spacestation14.io](https://builds.spacestation14.io/jenkins/)
+## Documentation/Wiki
 
-The IRC is setup to relay back and forth to the Discord server so [IRC nerds](https://xkcd.com/1782/) will not be left out.
-
-## Documentation
-
-We have various technical documentation articles on the [HackMD Wiki](https://hackmd.io/@ss14/docs/%2F%40ss14%2Ftechnical-documentation-overview).
+The [HackMD Wiki](https://hackmd.io/@ss14/docs/wiki) has documentation on SS14s content, engine, game design and more. We also have lots of resources for new contributors to the project.
 
 ## Contributing
 
@@ -27,8 +18,8 @@ We are happy to accept contributions from anybody. Get in Discord or IRC if you
 
 ## Building
 
-**In practice, you usually don't build this repository directly.**
+This repository is the **engine** part of SS14. It's the base engine all SS14 servers will be built on. As such, it does not start on its own: it needs the [content repo](https://github.com/space-wizards/space-station-14). Think of Robust Toolbox as BYOND in the context of Spacestation 13.
 
 ## Legal Info
 
-See `legal.md` for licenses and copyright.
+See [legal.md](https://github.com/space-wizards/RobustToolbox/blob/master/legal.md) for licenses and copyright.

Resources/EngineCredits/Libraries.yml

@@ -574,29 +574,22 @@
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE.
 
-- name: NGetText
+- name: Fluent.Net
   license: |
-    The MIT License (MIT)
+    blushingpenguin and Contributors
 
-    Copyright (c) 2012 Vitaly Zilnik
+    All rights reserved.
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+        http://www.apache.org/licenses/LICENSE-2.0
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+    Unless required by applicable law or agreed to in writing, software distributed
+    under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+    CONDITIONS OF ANY KIND, either express or implied. See the License for the
+    specific language governing permissions and limitations under the License.
 
 - name: NetSerializer
   license: |

Resources/Locale/en-US/ss14window.ftl

@@ -0,0 +1 @@
+ss14window-placeholder-title = Exemplary Window Title Here

Resources/Shaders/Internal/fov-lighting.swsl

@@ -28,5 +28,10 @@ void fragment()
 
     highp float occlusion = ChebyshevUpperBound(occlDist, ourDist);
 
+    if (occlusion >= 1.0)
+    {
+        discard;
+    }
+
     COLOR = vec4(0.0, 0.0, 0.0, 1.0 - occlusion);
 }

Resources/Shaders/Internal/light-soft.swsl

@@ -1,5 +1,11 @@
 #include "/Shaders/Internal/light_shared.swsl"
 
+highp vec4 calcGaussianWeights(highp float sigma, highp vec4 offset)
+{
+    highp vec4 eExp = offset * offset / (2.0 * sigma * sigma);
+    return exp(-eExp) / (sigma * sqrt(2.0 * PI));
+}
+
 highp float createOcclusion(highp vec2 diff)
 {
     // Calculate vector perpendicular to light vector.
@@ -8,23 +14,57 @@ highp float createOcclusion(highp vec2 diff)
 
     highp float ourDist = length(diff);
 
-    highp vec2 occlDist = occludeDepth(diff, shadowMap, lightIndex);
+    // Sample 7 points on a line perpendicular to the light source.
+    // Depending on the closest point, we change the gaussian weights down below
+    // to change the "narrowness" of the samples.
+    perpendicular *= lightSoftness * 1.5;
+
+    // Get all the samples we need.
+    highp vec2 sample1 = occludeDepth(diff, shadowMap, lightIndex);
+    highp vec2 sample2 = occludeDepth(diff + perpendicular, shadowMap, lightIndex);
+    highp vec2 sample3 = occludeDepth(diff - perpendicular, shadowMap, lightIndex);
+    highp vec2 sample4 = occludeDepth(diff + perpendicular * 2.0, shadowMap, lightIndex);
+    highp vec2 sample5 = occludeDepth(diff - perpendicular * 2.0, shadowMap, lightIndex);
+    highp vec2 sample6 = occludeDepth(diff + perpendicular * 3.0, shadowMap, lightIndex);
+    highp vec2 sample7 = occludeDepth(diff - perpendicular * 3.0, shadowMap, lightIndex);
+
+    highp float mindist =
+        min(sample1.x,
+        min(sample2.x,
+        min(sample3.x,
+        min(sample4.x,
+        min(sample5.x,
+        min(sample6.x,
+            sample7.x))))));
+
+    mindist = max(0.001, mindist);
 
     // Change soft shadow size based on distance from primary occluder.
-    highp float distRatio = (ourDist - occlDist.x) / occlDist.x / 2.0;
+    highp float distRatio = (ourDist - mindist);
 
-    perpendicular *= distRatio * lightSoftness;
+    // Sigma can never be zero so make sure to clamp.
+    // TODO: Scaling the dist ratio here in a more sane way might make shadows look better buuuut I'm lazy.
+    // Shadows look pretty nice already.
+    highp float sigma = max(0.001, distRatio * 0.75);
+    highp vec4 weights = calcGaussianWeights(sigma, vec4(0.0, 1.0, 2.0, 3.0));
 
-    // Totally not hacky PCF on top of VSM.
-    highp float occlusion = smoothstep(0.1, 1.0, ChebyshevUpperBound(occlDist, ourDist));
+    // Calculation of gaussian weights here is broken because it doesn't add up to 1.
+    // Fixing this is hard and if I had to guess too expensive for GPU shaders.
+    // So instead we add up the total weights and scale the result with that,
+    // so that we still end up with 0-1.
+    highp float totalWeigths = weights.x + weights.y * 2.0 + weights.z * 2.0 + weights.w * 2.0;
 
-    occlusion += shadowContrib(diff + perpendicular);
-    occlusion += shadowContrib(diff - perpendicular);
-    occlusion += shadowContrib(diff + perpendicular * 2.0);
-    occlusion += shadowContrib(diff - perpendicular * 2.0);
-    occlusion += shadowContrib(diff + perpendicular * 3.0);
-    occlusion += shadowContrib(diff - perpendicular * 3.0);
+    highp float occlusion = 0.0;
 
-    return occlusion / 7.0;
+    // Calculate actual occlusion with new weights.
+    occlusion += ChebyshevUpperBound(sample1, ourDist) * weights.x;
+    occlusion += ChebyshevUpperBound(sample2, ourDist) * weights.y;
+    occlusion += ChebyshevUpperBound(sample3, ourDist) * weights.y;
+    occlusion += ChebyshevUpperBound(sample4, ourDist) * weights.z;
+    occlusion += ChebyshevUpperBound(sample5, ourDist) * weights.z;
+    occlusion += ChebyshevUpperBound(sample6, ourDist) * weights.w;
+    occlusion += ChebyshevUpperBound(sample7, ourDist) * weights.w;
+
+    return occlusion / totalWeigths;
 }
 

Resources/Textures/debugRotation.rsi/meta.json

@@ -0,0 +1,17 @@
+{
+    "version": 1,
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [{
+            "name": "direction1",
+            "directions": 1,
+            "delays": [[1.0]]
+        }, {
+            "name": "direction4",
+            "directions": 4,
+            "delays": [[1.0], [1.0], [1.0], [1.0]]
+        }
+    ]
+}

Robust.Analyzers/Diagnostics.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis;
+
+namespace Robust.Generators
+{
+    public static class Diagnostics
+    {
+        public static SuppressionDescriptor MeansImplicitAssignment =>
+            new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");
+    }
+}

Robust.Analyzers/MeansImplicitAssigmentSuppressor.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Generators;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class MeansImplicitAssigmentSuppressor : DiagnosticSuppressor
+    {
+        const string MeansImplicitAssignmentAttribute = "Robust.Shared.MeansImplicitAssignmentAttribute";
+
+        public override void ReportSuppressions(SuppressionAnalysisContext context)
+        {
+            var implAttr = context.Compilation.GetTypeByMetadataName(MeansImplicitAssignmentAttribute);
+            foreach (var reportedDiagnostic in context.ReportedDiagnostics)
+            {
+                if(reportedDiagnostic.Id != Diagnostics.MeansImplicitAssignment.SuppressedDiagnosticId) continue;
+
+                var node = reportedDiagnostic.Location.SourceTree?.GetRoot(context.CancellationToken).FindNode(reportedDiagnostic.Location.SourceSpan);
+                if (node == null) continue;
+
+                var symbol = context.GetSemanticModel(reportedDiagnostic.Location.SourceTree).GetDeclaredSymbol(node);
+
+                if (symbol == null || !symbol.GetAttributes().Any(a =>
+                    a.AttributeClass?.GetAttributes().Any(attr =>
+                        SymbolEqualityComparer.Default.Equals(attr.AttributeClass, implAttr)) == true))
+                {
+                    continue;
+                }
+
+                context.ReportSuppression(Suppression.Create(
+                    Diagnostics.MeansImplicitAssignment,
+                    reportedDiagnostic));
+            }
+        }
+
+        public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(Diagnostics.MeansImplicitAssignment);
+    }
+}

Robust.Benchmarks/Program.cs

@@ -0,0 +1,12 @@
+using BenchmarkDotNet.Running;
+
+namespace Robust.Benchmarks
+{
+    internal class Program
+    {
+        public static void Main(string[] args)
+        {
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run();
+        }
+    }
+}

Robust.Benchmarks/Robust.Benchmarks.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <Import Project="..\MSBuild\Robust.Properties.targets" />
+    <Import Project="..\MSBuild\Robust.Engine.props" />
+    <PropertyGroup>
+        <IsPackable>false</IsPackable>
+        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+        <OutputPath>../bin/Benchmarks</OutputPath>
+        <OutputType>Exe</OutputType>
+    </PropertyGroup>
+    <ItemGroup>
+      <ProjectReference Include="..\Robust.Server\Robust.Server.csproj" />
+      <ProjectReference Include="..\Robust.Shared\Robust.Shared.csproj" />
+    </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    </ItemGroup>
+    <Import Project="..\MSBuild\Robust.Engine.targets" />
+</Project>

Robust.Benchmarks/Serialization/DataDefinitionWithString.cs

@@ -0,0 +1,11 @@
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Robust.Benchmarks.Serialization
+{
+    [DataDefinition]
+    public class DataDefinitionWithString
+    {
+        [field: DataField("string")]
+        private string StringField { get; } = default!;
+    }
+}

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -0,0 +1,83 @@
+using System;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using Robust.Server;
+using Robust.Shared.Configuration;
+using Robust.Shared.ContentPack;
+using Robust.Shared.IoC;
+using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using YamlDotNet.RepresentationModel;
+
+namespace Robust.Benchmarks.Serialization.Read
+{
+    public class SerializationReadBenchmark
+    {
+        public SerializationReadBenchmark()
+        {
+            IoCManager.InitThread();
+            ServerIoC.RegisterIoC();
+            IoCManager.BuildGraph();
+
+            var assemblies = new[]
+            {
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Server"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Benchmarks")
+            };
+
+            foreach (var assembly in assemblies)
+            {
+                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
+            }
+
+            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
+
+            SerializationManager = IoCManager.Resolve<ISerializationManager>();
+            SerializationManager.Initialize();
+
+            StringDataDefNode = new MappingDataNode();
+            StringDataDefNode.AddNode(new ValueDataNode("string"), new ValueDataNode("ABC"));
+
+            var yamlStream = new YamlStream();
+            yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
+
+            SeedNode = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
+        }
+
+        private ISerializationManager SerializationManager { get; }
+
+        private ValueDataNode StringNode { get; } = new("ABC");
+
+        private ValueDataNode IntNode { get; } = new("1");
+
+        private MappingDataNode StringDataDefNode { get; }
+
+        private MappingDataNode SeedNode { get; }
+
+        [Benchmark]
+        public string? ReadString()
+        {
+            return SerializationManager.ReadValue<string>(StringNode);
+        }
+
+        [Benchmark]
+        public int? ReadInteger()
+        {
+            return SerializationManager.ReadValue<int>(IntNode);
+        }
+
+        [Benchmark]
+        public DataDefinitionWithString? ReadDataDefinitionWithString()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString>(StringDataDefNode);
+        }
+
+        [Benchmark]
+        public SeedDataDefinition? ReadSeedDataDefinition()
+        {
+            return SerializationManager.ReadValue<SeedDataDefinition>(SeedNode);
+        }
+    }
+}

Robust.Benchmarks/Serialization/SeedDataDefinition.cs

@@ -0,0 +1,184 @@
+using System.Collections.Generic;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
+
+namespace Robust.Benchmarks.Serialization
+{
+    [Prototype("seed")]
+    public class SeedDataDefinition : IPrototype
+    {
+        public const string Prototype = @"
+- type: seed
+  id: tobacco
+  name: tobacco
+  seedName: tobacco
+  displayName: tobacco plant
+  productPrototypes:
+    - LeavesTobacco
+  harvestRepeat: Repeat
+  lifespan: 75
+  maturation: 5
+  production: 5
+  yield: 2
+  potency: 20
+  growthStages: 3
+  idealLight: 9
+  idealHeat: 298
+  chemicals:
+    chem.Nicotine:
+      Min: 1
+      Max: 10
+      PotencyDivisor: 10";
+
+        private const string SeedPrototype = "SeedBase";
+
+        [ViewVariables]
+        [field: DataField("id", required: true)]
+        public string ID { get; private init; } = default!;
+
+        /// <summary>
+        ///     Unique identifier of this seed. Do NOT set this.
+        /// </summary>
+        public int Uid { get; internal set; } = -1;
+
+        #region Tracking
+
+        [ViewVariables] [DataField("name")] public string Name { get; set; } = string.Empty;
+        [ViewVariables] [DataField("seedName")] public string SeedName { get; set; } = string.Empty;
+
+        [ViewVariables]
+        [DataField("seedNoun")]
+        public string SeedNoun { get; set; } = "seeds";
+        [ViewVariables] [DataField("displayName")] public string DisplayName { get; set; } = string.Empty;
+
+        [ViewVariables]
+        [DataField("roundStart")]
+        public bool RoundStart { get; private set; } = true;
+        [ViewVariables] [DataField("mysterious")] public bool Mysterious { get; set; }
+        [ViewVariables] [DataField("immutable")] public bool Immutable { get; set; }
+        #endregion
+
+        #region Output
+
+        [ViewVariables]
+        [DataField("productPrototypes")]
+        public List<string> ProductPrototypes { get; set; } = new();
+
+        [ViewVariables]
+        [DataField("chemicals")]
+        public Dictionary<string, SeedChemQuantity> Chemicals { get; set; } = new();
+
+        [ViewVariables]
+        [DataField("consumeGasses")]
+        public Dictionary<Gas, float> ConsumeGasses { get; set; } = new();
+
+        [ViewVariables]
+        [DataField("exudeGasses")]
+        public Dictionary<Gas, float> ExudeGasses { get; set; } = new();
+        #endregion
+
+        #region Tolerances
+
+        [ViewVariables]
+        [DataField("nutrientConsumption")]
+        public float NutrientConsumption { get; set; } = 0.25f;
+
+        [ViewVariables] [DataField("waterConsumption")] public float WaterConsumption { get; set; } = 3f;
+        [ViewVariables] [DataField("idealHeat")] public float IdealHeat { get; set; } = 293f;
+        [ViewVariables] [DataField("heatTolerance")] public float HeatTolerance { get; set; } = 20f;
+        [ViewVariables] [DataField("idealLight")] public float IdealLight { get; set; } = 7f;
+        [ViewVariables] [DataField("lightTolerance")] public float LightTolerance { get; set; } = 5f;
+        [ViewVariables] [DataField("toxinsTolerance")] public float ToxinsTolerance { get; set; } = 4f;
+
+        [ViewVariables]
+        [DataField("lowPressureTolerance")]
+        public float LowPressureTolerance { get; set; } = 25f;
+
+        [ViewVariables]
+        [DataField("highPressureTolerance")]
+        public float HighPressureTolerance { get; set; } = 200f;
+
+        [ViewVariables]
+        [DataField("pestTolerance")]
+        public float PestTolerance { get; set; } = 5f;
+
+        [ViewVariables]
+        [DataField("weedTolerance")]
+        public float WeedTolerance { get; set; } = 5f;
+        #endregion
+
+        #region General traits
+
+        [ViewVariables]
+        [DataField("endurance")]
+        public float Endurance { get; set; } = 100f;
+        [ViewVariables] [DataField("yield")] public int Yield { get; set; }
+        [ViewVariables] [DataField("lifespan")] public float Lifespan { get; set; }
+        [ViewVariables] [DataField("maturation")] public float Maturation { get; set; }
+        [ViewVariables] [DataField("production")] public float Production { get; set; }
+        [ViewVariables] [DataField("growthStages")] public int GrowthStages { get; set; } = 6;
+        [ViewVariables] [DataField("harvestRepeat")] public HarvestType HarvestRepeat { get; set; } = HarvestType.NoRepeat;
+
+        [ViewVariables] [DataField("potency")] public float Potency { get; set; } = 1f;
+        // No, I'm not removing these.
+        //public PlantSpread Spread { get; set; }
+        //public PlantMutation Mutation { get; set; }
+        //public float AlterTemperature { get; set; }
+        //public PlantCarnivorous Carnivorous { get; set; }
+        //public bool Parasite { get; set; }
+        //public bool Hematophage { get; set; }
+        //public bool Thorny { get; set; }
+        //public bool Stinging { get; set; }
+        [DataField("ligneous")]
+        public bool Ligneous { get; set; }
+        // public bool Teleporting { get; set; }
+        // public PlantJuicy Juicy { get; set; }
+        #endregion
+
+        #region Cosmetics
+
+        [ViewVariables]
+        [DataField("plantRsi", required: true)]
+        public ResourcePath PlantRsi { get; set; } = default!;
+
+        [ViewVariables]
+        [DataField("plantIconState")]
+        public string PlantIconState { get; set; } = "produce";
+
+        [ViewVariables]
+        [DataField("bioluminescent")]
+        public bool Bioluminescent { get; set; }
+
+        [ViewVariables]
+        [DataField("bioluminescentColor")]
+        public Color BioluminescentColor { get; set; } = Color.White;
+
+        [ViewVariables]
+        [DataField("splatPrototype")]
+        public string? SplatPrototype { get; set; }
+
+        #endregion
+    }
+
+    public enum HarvestType
+    {
+        NoRepeat,
+        Repeat
+    }
+
+    public enum Gas {}
+
+    [DataDefinition]
+    public struct SeedChemQuantity
+    {
+        [DataField("Min")]
+        public int Min;
+        [DataField("Max")]
+        public int Max;
+        [DataField("PotencyDivisor")]
+        public int PotencyDivisor;
+    }
+}

Robust.Client.Injectors/MathParsing.cs

@@ -29,9 +29,9 @@ namespace Robust.Build.Tasks
         public static Parser<char, float[]> Thickness { get; }
             = SkipWhitespaces.Then(
                 OneOf(
-                    Try(Single1.Select(c => new[] {c})),
+                    Try(Single4.Select(c => new[] {c.Item1, c.Item2, c.Item3, c.Item4})),
                     Try(Single2.Select(c => new[] {c.Item1, c.Item2})),
-                    Try(Single4.Select(c => new[] {c.Item1, c.Item2, c.Item3, c.Item4}))
+                    Try(Single1.Select(c => new[] {c}))
                 ));
     }
 }

Robust.Client.Injectors/RXamlColorAstNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection.Emit;
+using XamlX.Ast;
+using XamlX.Emit;
+using XamlX.IL;
+using XamlX.TypeSystem;
+
+namespace Robust.Build.Tasks
+{
+    internal class RXamlColorAstNode
+        : XamlAstNode, IXamlAstValueNode, IXamlAstILEmitableNode
+    {
+        private readonly IXamlMethod _method;
+        private readonly string _color;
+
+        public RXamlColorAstNode(IXamlLineInfo lineInfo, RXamlWellKnownTypes types, string color) : base(lineInfo)
+        {
+            _color = color;
+            Type = new XamlAstClrTypeReference(lineInfo, types.Color, false);
+            _method = types.ColorFromXaml;
+        }
+
+        public IXamlAstTypeReference Type { get; }
+
+        public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
+        {
+            codeGen.Ldstr(_color);
+            codeGen.EmitCall(_method);
+
+            return XamlILNodeEmitResult.Type(0, Type.GetClrType());
+        }
+    }
+}

Robust.Client.Injectors/RXamlWellKnownTypes.cs

@@ -13,6 +13,10 @@ namespace Robust.Build.Tasks
         public IXamlConstructor Vector2ConstructorFull { get; }
         public IXamlType Vector2i { get; }
         public IXamlConstructor Vector2iConstructorFull { get; }
+        public IXamlType Thickness { get; }
+        public IXamlConstructor ThicknessConstructorFull { get; }
+        public IXamlType Color { get; }
+        public IXamlMethod ColorFromXaml { get; }
 
         public RXamlWellKnownTypes(TransformerConfiguration cfg)
         {
@@ -23,6 +27,7 @@ namespace Robust.Build.Tasks
 
             (Vector2, Vector2ConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Vector2", Single, 2);
             (Vector2i, Vector2iConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Vector2i", Int32, 2);
+            (Thickness, ThicknessConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Thickness", Single, 4);
 
             (IXamlType, IXamlConstructor) GetNumericTypeInfo(string name, IXamlType componentType, int componentCount)
             {
@@ -31,6 +36,12 @@ namespace Robust.Build.Tasks
 
                 return (type, ctor);
             }
+
+            Color = cfg.TypeSystem.GetType("Robust.Shared.Maths.Color");
+            ColorFromXaml = Color.GetMethod(new FindMethodMethodSignature("FromXaml", Color, XamlIlTypes.String)
+            {
+                IsStatic = true
+            });
         }
     }
 

Robust.Client.Injectors/XamlCompiler.cs

@@ -329,6 +329,77 @@ namespace Robust.Build.Tasks
                 return true;
             }
 
+            if (type.Equals(types.Thickness))
+            {
+                var foo = MathParsing.Thickness.Parse(text);
+
+                if (!foo.Success)
+                    throw new XamlLoadException($"Unable to parse \"{text}\" as a Thickness", node);
+
+                var val = foo.Value;
+                float[] full;
+                if (val.Length == 1)
+                {
+                    var u = val[0];
+                    full = new[] {u, u, u, u};
+                }
+                else if (val.Length == 2)
+                {
+                    var h = val[0];
+                    var v = val[1];
+                    full = new[] {h, v, h, v};
+                }
+                else // 4
+                {
+                    full = val;
+                }
+
+                result = new RXamlSingleVecLikeConstAstNode(
+                    node,
+                    types.Thickness, types.ThicknessConstructorFull,
+                    types.Single, full);
+                return true;
+            }
+
+            if (type.Equals(types.Thickness))
+            {
+                var foo = MathParsing.Thickness.Parse(text);
+
+                if (!foo.Success)
+                    throw new XamlLoadException($"Unable to parse \"{text}\" as a Thickness", node);
+
+                var val = foo.Value;
+                float[] full;
+                if (val.Length == 1)
+                {
+                    var u = val[0];
+                    full = new[] {u, u, u, u};
+                }
+                else if (val.Length == 2)
+                {
+                    var h = val[0];
+                    var v = val[1];
+                    full = new[] {h, v, h, v};
+                }
+                else // 4
+                {
+                    full = val;
+                }
+
+                result = new RXamlSingleVecLikeConstAstNode(
+                    node,
+                    types.Thickness, types.ThicknessConstructorFull,
+                    types.Single, full);
+                return true;
+            }
+
+            if (type.Equals(types.Color))
+            {
+                // TODO: Interpret these colors at XAML compile time instead of at runtime.
+                result = new RXamlColorAstNode(node, types, text);
+                return true;
+            }
+
             result = null;
             return false;
         }

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -111,9 +111,10 @@ namespace Robust.Client.AutoGenerated
             compiler.Transform(parsed);
             var initialRoot = (XamlAstObjectNode) parsed.Root;
             var names = NameVisitor.GetNames(initialRoot);
+            var fieldAccess = classSymbol.IsSealed ? "private" : "protected";
             //var names = NameVisitor.GetNames((XamlAstObjectNode)XDocumentXamlParser.Parse(xamlFile).Root);
             var namedControls = names.Select(info => "        " +
-                                                     $"protected global::{info.type} {info.name} => " +
+                                                     $"{fieldAccess} global::{info.type} {info.name} => " +
                                                      $"this.FindControl<global::{info.type}>(\"{info.name}\");");
             return $@"// <auto-generated />
 using Robust.Client.UserInterface;

Robust.Client/Animations/Animation.cs

@@ -13,7 +13,7 @@ namespace Robust.Client.Animations
     /// <seealso cref="AnimationPlayerComponent"/>
     public sealed class Animation
     {
-        public readonly List<AnimationTrack> AnimationTracks = new();
+        public List<AnimationTrack> AnimationTracks { get; private set; } = new();
 
         public TimeSpan Length { get; set; }
     }

Robust.Client/Animations/AnimationTrackPlaySound.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using Robust.Client.GameObjects;
 using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
 
 namespace Robust.Client.Animations
 {
@@ -14,7 +15,7 @@ namespace Robust.Client.Animations
         /// <summary>
         ///     A list of key frames for when to fire flicks.
         /// </summary>
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; private set; } = new();
 
         public override (int KeyFrameIndex, float FramePlayingTime) InitPlayback()
         {
@@ -36,8 +37,7 @@ namespace Robust.Client.Animations
 
                 var keyFrame = KeyFrames[keyFrameIndex];
 
-                EntitySystem.Get<AudioSystem>()
-                    .Play(keyFrame.Resource, entity, keyFrame.AudioParamsFunc.Invoke());
+                SoundSystem.Play(Filter.Local(), keyFrame.Resource, entity, keyFrame.AudioParamsFunc.Invoke());
             }
 
             return (keyFrameIndex, playingTime);

Robust.Client/Animations/AnimationTrackProperty.cs

@@ -10,7 +10,7 @@ namespace Robust.Client.Animations
     /// </summary>
     public abstract class AnimationTrackProperty : AnimationTrack
     {
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; protected set; } = new();
 
         /// <summary>
         ///     How to interpolate values when between two keyframes.

Robust.Client/Animations/AnimationTrackSpriteFlick.cs

@@ -15,7 +15,7 @@ namespace Robust.Client.Animations
         /// <summary>
         ///     A list of key frames for when to fire flicks.
         /// </summary>
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; private set; } = new();
 
         // TODO: Should this layer key be per keyframe maybe?
         /// <summary>

Robust.Client/Audio/Midi/MidiManager.cs

@@ -11,8 +11,8 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Utility;
 using Logger = Robust.Shared.Log.Logger;
 
@@ -63,14 +63,18 @@ namespace Robust.Client.Audio.Midi
         bool IsAvailable { get; }
 
         public int OcclusionCollisionMask { get; set; }
+
+        void Shutdown();
     }
 
-    internal class MidiManager : IDisposable, IMidiManager
+    internal class MidiManager : IMidiManager
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
+        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+
         public bool IsAvailable
         {
             get
@@ -154,6 +158,7 @@ namespace Robust.Client.Audio.Midi
             _midiThread = new Thread(ThreadUpdate);
             _midiThread.Start();
 
+            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
             FluidsynthInitialized = true;
         }
 
@@ -298,7 +303,7 @@ namespace Robust.Client.Audio.Midi
                             var occlusion = 0f;
                             if (sourceRelative.Length > 0)
                             {
-                                occlusion = IoCManager.Resolve<IPhysicsManager>().IntersectRayPenetration(
+                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
                                     pos.MapId,
                                     new CollisionRay(
                                         pos.Position,
@@ -315,6 +320,11 @@ namespace Robust.Client.Audio.Midi
                             continue;
                         }
 
+                        if (renderer.TrackingEntity != null)
+                        {
+                            renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
+                        }
+
                         if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
                         {
                             // just duck out instead of move to NaN
@@ -352,7 +362,7 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
-        public void Dispose()
+        public void Shutdown()
         {
             _alive = false;
             _midiThread?.Join();

Robust.Client/BaseClient.cs

@@ -8,6 +8,7 @@ using Robust.Client.Utility;
 using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -96,6 +97,25 @@ namespace Robust.Client
             _net.ClientDisconnect(reason);
         }
 
+        /// <inheritdoc />
+        public void StartSinglePlayer()
+        {
+            DebugTools.Assert(RunLevel < ClientRunLevel.Connecting);
+            DebugTools.Assert(!_net.IsConnected);
+            _playMan.Startup();
+            _playMan.LocalPlayer!.Name = PlayerNameOverride ?? _configManager.GetCVar(CVars.PlayerName);
+            OnRunLevelChanged(ClientRunLevel.SinglePlayerGame);
+            GameStartedSetup();
+        }
+
+        /// <inheritdoc />
+        public void StopSinglePlayer()
+        {
+            DebugTools.Assert(RunLevel == ClientRunLevel.SinglePlayerGame);
+            DebugTools.Assert(!_net.IsConnected);
+            GameStoppedReset();
+        }
+
         /// <inheritdoc />
         public event EventHandler<RunLevelChangedEventArgs>? RunLevelChanged;
 
@@ -132,7 +152,7 @@ namespace Robust.Client
             var userId = _net.ServerChannel.UserId;
             _discord.Update(info.ServerName, userName, info.ServerMaxPlayers.ToString());
             // start up player management
-            _playMan.Startup(_net.ServerChannel!);
+            _playMan.Startup();
 
             _playMan.LocalPlayer!.UserId = userId;
             _playMan.LocalPlayer.Name = userName;
@@ -150,12 +170,18 @@ namespace Robust.Client
             DebugTools.Assert(RunLevel < ClientRunLevel.Connected);
             OnRunLevelChanged(ClientRunLevel.Connected);
 
+            GameStartedSetup();
+
+            PlayerJoinedServer?.Invoke(this, new PlayerEventArgs(session));
+        }
+
+        private void GameStartedSetup()
+        {
             _entityManager.Startup();
             _mapManager.Startup();
 
             _timing.ResetSimTime();
             _timing.Paused = false;
-            PlayerJoinedServer?.Invoke(this, new PlayerEventArgs(session));
         }
 
         /// <summary>
@@ -189,10 +215,15 @@ namespace Robust.Client
             PlayerLeaveServer?.Invoke(this, new PlayerEventArgs(_playMan.LocalPlayer?.Session));
 
             LastDisconnectReason = args.Reason;
+            GameStoppedReset();
+        }
 
+        private void GameStoppedReset()
+        {
             IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
+            IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Shutdown();
             _mapManager.Shutdown();
             _discord.ClearPresence();
@@ -249,6 +280,11 @@ namespace Robust.Client
         ///     The client is now in the game, moving around.
         /// </summary>
         InGame,
+
+        /// <summary>
+        ///     The client is now in singleplayer mode, in-game.
+        /// </summary>
+        SinglePlayerGame,
     }
 
     /// <summary>

Robust.Client/ClientIoC.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
 using Robust.Client.Debugging;
@@ -10,20 +10,25 @@ using Robust.Client.Input;
 using Robust.Client.Map;
 using Robust.Client.Placement;
 using Robust.Client.Player;
+using Robust.Client.Prototypes;
 using Robust.Client.Reflection;
 using Robust.Client.ResourceManagement;
 using Robust.Client.State;
+using Robust.Client.Timing;
 using Robust.Client.UserInterface;
 using Robust.Client.Utility;
 using Robust.Client.ViewVariables;
 using Robust.Shared;
+using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Players;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
+using Robust.Shared.Timing;
 
 namespace Robust.Client
 {
@@ -33,8 +38,14 @@ namespace Robust.Client
         {
             SharedIoC.RegisterIoC();
 
-            IoCManager.Register<IPrototypeManager, PrototypeManager>();
+            IoCManager.Register<IGameTiming, ClientGameTiming>();
+            IoCManager.Register<IClientGameTiming, ClientGameTiming>();
+            IoCManager.Register<IPrototypeManager, ClientPrototypeManager>();
+            IoCManager.Register<IMapManager, ClientMapManager>();
+            IoCManager.Register<IMapManagerInternal, ClientMapManager>();
+            IoCManager.Register<IClientMapManager, ClientMapManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
+            IoCManager.Register<IEntityLookup, SharedEntityLookup>();
             IoCManager.Register<IComponentFactory, ClientComponentFactory>();
             IoCManager.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
             IoCManager.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();
@@ -47,10 +58,12 @@ namespace Robust.Client
             IoCManager.Register<IResourceCacheInternal, ResourceCache>();
             IoCManager.Register<IClientNetManager, NetManager>();
             IoCManager.Register<IClientEntityManager, ClientEntityManager>();
-            IoCManager.Register<IEntityNetworkManager, ClientEntityNetworkManager>();
+            IoCManager.Register<IClientEntityManagerInternal, ClientEntityManager>();
+            IoCManager.Register<IEntityNetworkManager, ClientEntityManager>();
             IoCManager.Register<IClientGameStateManager, ClientGameStateManager>();
             IoCManager.Register<IBaseClient, BaseClient>();
             IoCManager.Register<IPlayerManager, PlayerManager>();
+            IoCManager.Register<ISharedPlayerManager, PlayerManager>();
             IoCManager.Register<IStateManager, StateManager>();
             IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
             IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
@@ -59,8 +72,7 @@ namespace Robust.Client
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IFontManager, FontManager>();
-            IoCManager.Register<IFontManagerInternal, FontManager>();
+            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IMidiManager, MidiManager>();
             IoCManager.Register<IAuthManager, AuthManager>();
             switch (mode)
@@ -87,8 +99,9 @@ namespace Robust.Client
                     throw new ArgumentOutOfRangeException();
             }
 
+            IoCManager.Register<IFontManager, FontManager>();
+            IoCManager.Register<IFontManagerInternal, FontManager>();
             IoCManager.Register<IEyeManager, EyeManager>();
-
             IoCManager.Register<IPlacementManager, PlacementManager>();
             IoCManager.Register<IOverlayManager, OverlayManager>();
             IoCManager.Register<IOverlayManagerInternal, OverlayManager>();
@@ -96,7 +109,6 @@ namespace Robust.Client
             IoCManager.Register<IViewVariablesManagerInternal, ViewVariablesManager>();
             IoCManager.Register<IClientConGroupController, ClientConGroupController>();
             IoCManager.Register<IScriptClient, ScriptClient>();
-            //IoCManager.Register<IXamlCompiler, XamlCompiler>();
         }
     }
 }

Robust.Client/Console/Commands/Debug.cs

@@ -12,7 +12,6 @@ using Robust.Client.Input;
 using Robust.Client.Debugging;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
-using Robust.Client.ResourceManagement.ResourceTypes;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
@@ -481,6 +480,8 @@ namespace Robust.Client.Console.Commands
             {
                 _writeNode(root, 0, writer);
             }
+
+            shell.WriteLine("Saved guidump");
         }
 
         private static void _writeNode(Control control, int indents, TextWriter writer)
@@ -542,7 +543,7 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var window = new SS14Window { CustomMinimumSize = (500, 400)};
+            var window = new SS14Window { MinSize = (500, 400)};
             var tabContainer = new TabContainer();
             window.Contents.AddChild(tabContainer);
             var scroll = new ScrollContainer();
@@ -562,7 +563,7 @@ namespace Robust.Client.Console.Commands
             optionButton.OnItemSelected += eventArgs => optionButton.SelectId(eventArgs.Id);
             vBox.AddChild(optionButton);
 
-            var tree = new Tree { SizeFlagsVertical = Control.SizeFlags.FillExpand };
+            var tree = new Tree { VerticalExpand = true };
             var root = tree.CreateItem();
             root.Text = "Honk!";
             var child = tree.CreateItem();
@@ -599,7 +600,7 @@ namespace Robust.Client.Console.Commands
                 {
                     grid.AddChild(new Button
                     {
-                        CustomMinimumSize = (50, 50),
+                        MinSize = (50, 50),
                         Text = $"{x}, {y}"
                     });
                 }
@@ -631,6 +632,29 @@ namespace Robust.Client.Console.Commands
                 }
             });
 
+            tabContainer.AddChild(new HSplitContainer
+            {
+                Children =
+                {
+                    new PanelContainer
+                    {
+                        PanelOverride = new StyleBoxFlat {BackgroundColor = Color.Red},
+                        Children =
+                        {
+                            new Label{  Text = "FOOBARBAZ"},
+                        }
+                    },
+                    new PanelContainer
+                    {
+                        PanelOverride = new StyleBoxFlat {BackgroundColor = Color.Blue},
+                        Children =
+                        {
+                            new Label{  Text = "FOOBARBAZ"},
+                        }
+                    },
+                }
+            });
+
             window.OpenCentered();
         }
     }

Robust.Client/Console/Commands/MonitorCommands.cs

@@ -0,0 +1,44 @@
+using System.Linq;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Console.Commands
+{
+    [UsedImplicitly]
+    public sealed class LsMonitorCommand : IConsoleCommand
+    {
+        public string Command => "lsmonitor";
+        public string Description => "";
+        public string Help => "";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            foreach (var monitor in clyde.EnumerateMonitors())
+            {
+                shell.WriteLine(
+                    $"[{monitor.Id}] {monitor.Name}: {monitor.Size.X}x{monitor.Size.Y}@{monitor.RefreshRate}Hz");
+            }
+        }
+    }
+
+    [UsedImplicitly]
+    public sealed class SetMonitorCommand : IConsoleCommand
+    {
+        public string Command => "setmonitor";
+        public string Description => "";
+        public string Help => "Usage: setmonitor <id>";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            var id = int.Parse(args[0]);
+            var monitor = clyde.EnumerateMonitors().Single(m => m.Id == id);
+            clyde.SetWindowMonitor(monitor);
+        }
+    }
+}

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -0,0 +1,41 @@
+using Robust.Client.Debugging;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public sealed class PhysicsOverlayCommands : IConsoleCommand
+    {
+        public string Command => "physics";
+        public string Description => $"{Command} <contactnormals / contactpoints / shapes>";
+        public string Help => $"{Command} <overlay>";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (args.Length != 1)
+            {
+                shell.WriteLine($"Invalid number of args supplied");
+                return;
+            }
+
+            var system = EntitySystem.Get<DebugPhysicsSystem>();
+
+            switch (args[0])
+            {
+                case "contactnormals":
+                    system.Flags ^= PhysicsDebugFlags.ContactNormals;
+                    break;
+                case "contactpoints":
+                    system.Flags ^= PhysicsDebugFlags.ContactPoints;
+                    break;
+                case "shapes":
+                    system.Flags ^= PhysicsDebugFlags.Shapes;
+                    break;
+                default:
+                    shell.WriteLine($"{args[0]} is not a recognised overlay");
+                    return;
+            }
+
+            return;
+        }
+    }
+}

Robust.Client/Console/Commands/ReloadLocalizationsCommand.cs

@@ -0,0 +1,20 @@
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+
+namespace Robust.Client.Console.Commands
+{
+    internal sealed class ReloadLocalizationsCommand : IConsoleCommand
+    {
+        public string Command => "rldloc";
+        public string Description => "Reloads localization (client & server)";
+        public string Help => "Usage: rldloc";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            IoCManager.Resolve<ILocalizationManager>().ReloadLocalizations();
+
+            shell.RemoteExecuteCommand("sudo rldloc");
+        }
+    }
+}

Robust.Client/Console/Commands/VelocitiesCommand.cs

@@ -0,0 +1,17 @@
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public class VelocitiesCommand : IConsoleCommand
+    {
+        public string Command => "showvelocities";
+        public string Description => "Displays your angular and linear velocities";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<VelocityDebugSystem>().Enabled ^= true;
+        }
+    }
+}

Robust.Client/Console/ScriptConsoleClient.cs

@@ -1,5 +1,8 @@
 #if CLIENT_SCRIPTING
+using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Text;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
@@ -36,6 +39,8 @@ namespace Robust.Client.Console
         private readonly ScriptGlobals _globals;
         private ScriptState? _state;
 
+        private (string[] imports, string code)? _autoImportRepeatBuffer;
+
         public ScriptConsoleClient()
         {
             Title = Loc.GetString("Robust C# Interactive (CLIENT)");
@@ -54,38 +59,56 @@ namespace Robust.Client.Console
             var code = InputBar.Text;
             InputBar.Clear();
 
-            // Remove > or . at the end of the output panel.
-            OutputPanel.RemoveEntry(^1);
-
-            _inputBuffer.AppendLine(code);
-            _linesEntered += 1;
-
-            var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(_inputBuffer.ToString()), ScriptInstanceShared.ParseOptions);
-
-            if (!SyntaxFactory.IsCompleteSubmission(tree))
+            if (_autoImportRepeatBuffer.HasValue && code == "y")
             {
-                if (_linesEntered == 1)
+                var (imports, repeatCode) = _autoImportRepeatBuffer.Value;
+                var sb = new StringBuilder();
+                foreach (var import in imports)
                 {
-                    OutputPanel.AddText($"> {code}");
+                    sb.AppendFormat("using {0};\n", import);
                 }
-                else
-                {
-                    OutputPanel.AddText($". {code}");
-                }
-                OutputPanel.AddText(".");
-                return;
+
+                sb.Append(repeatCode);
+
+                code = sb.ToString();
             }
-
-            code = _inputBuffer.ToString().Trim();
-
-            // Remove echo of partial submission from the output panel.
-            for (var i = 1; i < _linesEntered; i++)
+            else
             {
+                // Remove > or . at the end of the output panel.
                 OutputPanel.RemoveEntry(^1);
-            }
 
-            _inputBuffer.Clear();
-            _linesEntered = 0;
+                _inputBuffer.AppendLine(code);
+                _linesEntered += 1;
+
+                var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(_inputBuffer.ToString()),
+                    ScriptInstanceShared.ParseOptions);
+
+                if (!SyntaxFactory.IsCompleteSubmission(tree))
+                {
+                    if (_linesEntered == 1)
+                    {
+                        OutputPanel.AddText($"> {code}");
+                    }
+                    else
+                    {
+                        OutputPanel.AddText($". {code}");
+                    }
+
+                    OutputPanel.AddText(".");
+                    return;
+                }
+
+                code = _inputBuffer.ToString().Trim();
+
+                // Remove echo of partial submission from the output panel.
+                for (var i = 1; i < _linesEntered; i++)
+                {
+                    OutputPanel.RemoveEntry(^1);
+                }
+
+                _inputBuffer.Clear();
+                _linesEntered = 0;
+            }
 
             Script newScript;
 
@@ -135,6 +158,8 @@ namespace Robust.Client.Console
 
                 OutputPanel.AddMessage(msg);
                 OutputPanel.AddText(">");
+
+                PromptAutoImports(e.Diagnostics, code);
                 return;
             }
 
@@ -148,13 +173,23 @@ namespace Robust.Client.Console
             else if (ScriptInstanceShared.HasReturnValue(newScript))
             {
                 var msg = new FormattedMessage();
-                msg.AddText(CSharpObjectFormatter.Instance.FormatObject(_state.ReturnValue));
+                msg.AddText(ScriptInstanceShared.SafeFormat(_state.ReturnValue));
                 OutputPanel.AddMessage(msg);
             }
 
             OutputPanel.AddText(">");
         }
 
+        private void PromptAutoImports(IEnumerable<Diagnostic> diags, string code)
+        {
+            if (!ScriptInstanceShared.CalcAutoImports(_reflectionManager, diags, out var found))
+                return;
+
+            OutputPanel.AddText($"Auto-import {string.Join(", ", found)} (enter 'y')?");
+
+            _autoImportRepeatBuffer = (found.ToArray(), code);
+        }
+
         private sealed class ScriptGlobalsImpl : ScriptGlobals
         {
             private readonly ScriptConsoleClient _owner;
@@ -180,7 +215,7 @@ namespace Robust.Client.Console
 
             public override void show(object obj)
             {
-                write(CSharpObjectFormatter.Instance.FormatObject(obj));
+                write(ScriptInstanceShared.SafeFormat(obj));
             }
         }
     }

Robust.Client/Console/WatchWindow.cs

@@ -20,8 +20,6 @@ namespace Robust.Client.Console
     {
         private readonly IReflectionManager _reflectionManager;
 
-        protected override Vector2? CustomSize => (300, 300);
-
         private readonly VBoxContainer _watchesVBox;
         private readonly LineEdit _addWatchEdit;
         private readonly Button _addWatchButton;
@@ -37,12 +35,12 @@ namespace Robust.Client.Console
 
             var mainVBox = new VBoxContainer
             {
-                CustomMinimumSize = (500, 300),
+                MinSize = (500, 300),
                 Children =
                 {
                     (_watchesVBox = new VBoxContainer
                     {
-                        SizeFlagsVertical = SizeFlags.FillExpand
+                        VerticalExpand = true
                     }),
                     new HBoxContainer
                     {
@@ -50,7 +48,7 @@ namespace Robust.Client.Console
                         {
                             (_addWatchEdit = new HistoryLineEdit
                             {
-                                SizeFlagsHorizontal = SizeFlags.FillExpand,
+                                HorizontalExpand = true,
                                 PlaceHolder = Loc.GetString("Add watch (C# interactive)")
                             }),
                             (_addWatchButton = new Button
@@ -66,6 +64,8 @@ namespace Robust.Client.Console
             _addWatchEdit.OnTextEntered += _ => AddWatch();
 
             Contents.AddChild(mainVBox);
+
+            SetSize = (300, 300);
         }
 
         private void AddWatch()
@@ -113,7 +113,7 @@ namespace Robust.Client.Console
                     {
                         (_outputLabel = new Label
                         {
-                            SizeFlagsHorizontal = SizeFlags.FillExpand,
+                            HorizontalExpand = true,
                             ClipText = true
                         }),
                         (delButton = new Button
@@ -176,7 +176,7 @@ namespace Robust.Client.Console
                         {
                             Text = message,
                             ClipText = true,
-                            SizeFlagsHorizontal = SizeFlags.FillExpand
+                            HorizontalExpand = true
                         },
                         (delButton = new Button {Text = Loc.GetString("Remove")})
                     }

Robust.Client/ContentStart.cs

@@ -5,10 +5,15 @@ namespace Robust.Client
         public static void Start(string[] args)
         {
 #if FULL_RELEASE
-            throw new System.InvalidOperationException("ContentStart is not available on a full release.");
+            throw new System.InvalidOperationException("ContentStart.Start is not available on a full release.");
 #else
             GameController.Start(args, true);
 #endif
         }
+
+        public static void StartLibrary(string[] args, GameControllerOptions options)
+        {
+            GameController.Start(args, true, null, options);
+        }
     }
 }

Robust.Client/Debugging/DebugDrawing.cs

@@ -1,12 +1,18 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
+using Robust.Shared;
+using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
+using Robust.Shared.Physics.Dynamics.Joints;
 using Robust.Shared.Prototypes;
 
 namespace Robust.Client.Debugging
@@ -15,11 +21,10 @@ namespace Robust.Client.Debugging
     public class DebugDrawing : IDebugDrawing
     {
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
-        [Dependency] private readonly IComponentManager _componentManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
 
         private bool _debugColliders;
@@ -38,14 +43,14 @@ namespace Robust.Client.Debugging
 
                 _debugColliders = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<PhysicsOverlay>())
                 {
-                    _overlayManager.AddOverlay(new PhysicsOverlay(_componentManager, _eyeManager,
-                        _prototypeManager, _inputManager, _physicsManager));
+                    _overlayManager.AddOverlay(new PhysicsOverlay(_eyeManager,
+                        _prototypeManager, _inputManager, _mapManager));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(PhysicsOverlay));
+                    _overlayManager.RemoveOverlay<PhysicsOverlay>();
                 }
             }
         }
@@ -63,23 +68,22 @@ namespace Robust.Client.Debugging
 
                 _debugPositions = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
                 {
                     _overlayManager.AddOverlay(new EntityPositionOverlay(_entityManager, _eyeManager));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(EntityPositionOverlay));
+                    _overlayManager.RemoveOverlay<EntityPositionOverlay>();
                 }
             }
         }
 
         private class PhysicsOverlay : Overlay
         {
-            private readonly IComponentManager _componentManager;
             private readonly IEyeManager _eyeManager;
+            private readonly IMapManager _mapManager;
             private readonly IInputManager _inputManager;
-            private readonly IPhysicsManager _physicsManager;
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
             private readonly ShaderInstance _shader;
@@ -88,13 +92,12 @@ namespace Robust.Client.Debugging
             private Vector2 _hoverStartScreen = Vector2.Zero;
             private List<IPhysBody> _hoverBodies = new();
 
-            public PhysicsOverlay(IComponentManager compMan, IEyeManager eyeMan, IPrototypeManager protoMan, IInputManager inputManager, IPhysicsManager physicsManager)
-                : base(nameof(PhysicsOverlay))
+
+            public PhysicsOverlay(IEyeManager eyeMan, IPrototypeManager protoMan, IInputManager inputManager, IMapManager mapManager)
             {
-                _componentManager = compMan;
                 _eyeManager = eyeMan;
                 _inputManager = inputManager;
-                _physicsManager = physicsManager;
+                _mapManager = mapManager;
 
                 _shader = protoMan.Index<ShaderPrototype>("unshaded").Instance();
                 var cache = IoCManager.Resolve<IResourceCache>();
@@ -102,22 +105,23 @@ namespace Robust.Client.Debugging
             }
 
             /// <inheritdoc />
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
-                switch (currentSpace)
+                switch (args.Space)
                 {
                     case OverlaySpace.ScreenSpace:
-                        DrawScreen((DrawingHandleScreen) handle);
+                        DrawScreen(args);
                         break;
                     case OverlaySpace.WorldSpace:
-                        DrawWorld((DrawingHandleWorld) handle);
+                        DrawWorld(args);
                         break;
                 }
 
             }
 
-            private void DrawScreen(DrawingHandleScreen screenHandle)
+            private void DrawScreen(in OverlayDrawArgs args)
             {
+                var screenHandle = args.ScreenHandle;
                 var lineHeight = _font.GetLineHeight(1f);
                 Vector2 drawPos = _hoverStartScreen + new Vector2(20, 0) + new Vector2(0, -(_hoverBodies.Count * 4 * lineHeight / 2f));
                 int row = 0;
@@ -130,20 +134,21 @@ namespace Robust.Client.Debugging
                         row++;
                     }
 
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Entity}");
+                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Owner}");
                     row++;
                     DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
                     row++;
                     DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
                     row++;
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {((IPhysicsComponent)body).Anchored}");
+                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
                     row++;
                 }
 
             }
 
-            private void DrawWorld(DrawingHandleWorld worldHandle)
+            private void DrawWorld(in OverlayDrawArgs args)
             {
+                var worldHandle = args.WorldHandle;
                 worldHandle.UseShader(_shader);
                 var drawing = new PhysDrawingAdapter(worldHandle);
 
@@ -157,20 +162,31 @@ namespace Robust.Client.Debugging
                 if (viewport.IsEmpty()) return;
 
                 var mapId = _eyeManager.CurrentMap;
+                var sleepThreshold = IoCManager.Resolve<IConfigurationManager>().GetCVar(CVars.TimeToSleep);
+                var colorEdge = Color.Red.WithAlpha(0.33f);
+                var drawnJoints = new HashSet<Joint>();
 
-                foreach (var physBody in _physicsManager.GetCollidingEntities(mapId, viewport))
+                foreach (var physBody in EntitySystem.Get<SharedBroadPhaseSystem>().GetCollidingEntities(mapId, viewport))
                 {
                     // all entities have a TransformComponent
-                    var transform = physBody.Entity.Transform;
+                    var transform = physBody.Owner.Transform;
 
-                    var worldBox = physBody.WorldAABB;
+                    var worldBox = physBody.GetWorldAABB(_mapManager);
                     if (worldBox.IsEmpty()) continue;
 
-                    var colorEdge = Color.Red.WithAlpha(0.33f);
-
-                    foreach (var shape in physBody.PhysicsShapes)
+                    foreach (var fixture in physBody.Fixtures)
                     {
-                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport, physBody.SleepAccumulator / (float) physBody.SleepThreshold);
+                        var shape = fixture.Shape;
+                        var sleepPercent = physBody.Awake ? physBody.SleepTime / sleepThreshold : 1.0f;
+                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport, sleepPercent);
+                    }
+
+                    foreach (var joint in physBody.Joints)
+                    {
+                        if (drawnJoints.Contains(joint)) continue;
+                        drawnJoints.Add(joint);
+
+                        joint.DebugDraw(drawing, in viewport);
                     }
 
                     if (worldBox.Contains(mouseWorldPos))
@@ -187,9 +203,9 @@ namespace Robust.Client.Debugging
             {
                 var baseLine = new Vector2(pos.X, font.GetAscent(1) + pos.Y);
 
-                foreach (var chr in str)
+                foreach (var rune in str.EnumerateRunes())
                 {
-                    var advance = font.DrawChar(handle, chr, baseLine, 1, Color.White);
+                    var advance = font.DrawChar(handle, rune, baseLine, 1, Color.White);
                     baseLine += new Vector2(advance, 0);
                 }
             }
@@ -233,6 +249,16 @@ namespace Robust.Client.Debugging
                     _handle.DrawCircle(origin, radius, color);
                 }
 
+                public override void DrawPolygonShape(Vector2[] vertices, in Color color)
+                {
+                    _handle.DrawPrimitives(DrawPrimitiveTopology.TriangleFan, vertices, color);
+                }
+
+                public override void DrawLine(Vector2 start, Vector2 end, in Color color)
+                {
+                    _handle.DrawLine(start, end, color);
+                }
+
                 public override void SetTransform(in Matrix3 transform)
                 {
                     _handle.SetTransform(transform);
@@ -249,17 +275,17 @@ namespace Robust.Client.Debugging
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public EntityPositionOverlay(IEntityManager entityManager, IEyeManager eyeManager) : base(nameof(EntityPositionOverlay))
+            public EntityPositionOverlay(IEntityManager entityManager, IEyeManager eyeManager)
             {
                 _entityManager = entityManager;
                 _eyeManager = eyeManager;
             }
 
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
                 const float stubLength = 0.25f;
 
-                var worldHandle = (DrawingHandleWorld) handle;
+                var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
                 foreach (var entity in _entityManager.GetEntities())
                 {
                     var transform = entity.Transform;

Robust.Client/Debugging/DebugDrawingManager.cs

@@ -1,10 +1,11 @@
-using Robust.Shared.IoC;
+using Robust.Shared.IoC;
 using Robust.Shared.Network.Messages;
 using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Timing;
+using Robust.Shared.Enums;
 using Robust.Shared.Network;
 
 namespace Robust.Client.Debugging
@@ -38,13 +39,13 @@ namespace Robust.Client.Debugging
 
                 _debugDrawRays = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<DebugDrawRayOverlay>())
                 {
                     _overlayManager.AddOverlay(new DebugDrawRayOverlay(this));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(DebugDrawRayOverlay));
+                    _overlayManager.RemoveOverlay<DebugDrawRayOverlay>();
                 }
             }
         }
@@ -81,13 +82,14 @@ namespace Robust.Client.Debugging
             private readonly DebugDrawingManager _owner;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public DebugDrawRayOverlay(DebugDrawingManager owner) : base(nameof(DebugDrawRayOverlay))
+            public DebugDrawRayOverlay(DebugDrawingManager owner)
             {
                 _owner = owner;
             }
 
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
+                var handle = args.WorldHandle;
                 foreach (var ray in _owner.raysWithLifeTime)
                 {
                     handle.DrawLine(

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -0,0 +1,164 @@
+/*
+* Farseer Physics Engine:
+* Copyright (c) 2012 Ian Qvist
+*
+* Original source Box2D:
+* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+* misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* Heavily inspired by Farseer */
+
+using System;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics.Collision;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Dynamics.Contacts;
+
+namespace Robust.Client.Debugging
+{
+    internal sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
+    {
+        /*
+         * Used for debugging shapes, controllers, joints, contacts
+         */
+
+        private const int MaxContactPoints = 2048;
+        internal int PointCount;
+
+        internal ContactPoint[] _points = new ContactPoint[MaxContactPoints];
+
+        public PhysicsDebugFlags Flags
+        {
+            get => _flags;
+            set
+            {
+                if (value == _flags) return;
+
+                if (_flags == PhysicsDebugFlags.None)
+                    IoCManager.Resolve<IOverlayManager>().AddOverlay(new PhysicsDebugOverlay(this));
+
+                if (value == PhysicsDebugFlags.None)
+                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
+
+                _flags = value;
+            }
+        }
+
+        private PhysicsDebugFlags _flags;
+
+        public override void HandlePreSolve(Contact contact, in Manifold oldManifold)
+        {
+            if ((Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            {
+                Manifold manifold = contact.Manifold;
+
+                if (manifold.PointCount == 0)
+                    return;
+
+                Fixture fixtureA = contact.FixtureA!;
+
+                PointState[] state1, state2;
+                CollisionManager.GetPointStates(out state1, out state2, oldManifold, manifold);
+
+                Span<Vector2> points = stackalloc Vector2[2];
+                Vector2 normal;
+                contact.GetWorldManifold(out normal, points);
+
+                for (int i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
+                {
+                    if (fixtureA == null)
+                        _points[i] = new ContactPoint();
+
+                    ContactPoint cp = _points[PointCount];
+                    cp.Position = points[i];
+                    cp.Normal = normal;
+                    cp.State = state2[i];
+                    _points[PointCount] = cp;
+                    ++PointCount;
+                }
+            }
+        }
+
+        internal struct ContactPoint
+        {
+            public Vector2 Normal;
+            public Vector2 Position;
+            public PointState State;
+        }
+    }
+
+    [Flags]
+    internal enum PhysicsDebugFlags : byte
+    {
+        None = 0,
+        ContactPoints = 1 << 0,
+        ContactNormals = 1 << 1,
+        Shapes = 1 << 2,
+    }
+
+    internal sealed class PhysicsDebugOverlay : Overlay
+    {
+        private DebugPhysicsSystem _physics = default!;
+
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+        public PhysicsDebugOverlay(DebugPhysicsSystem system)
+        {
+            _physics = system;
+        }
+
+        protected internal override void Draw(in OverlayDrawArgs args)
+        {
+            if (_physics.Flags == PhysicsDebugFlags.None) return;
+
+            var worldHandle = args.WorldHandle;
+
+            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0)
+            {
+                // Port DebugDrawing over.
+            }
+
+            if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            {
+                const float axisScale = 0.3f;
+
+                for (int i = 0; i < _physics.PointCount; ++i)
+                {
+                    DebugPhysicsSystem.ContactPoint point = _physics._points[i];
+
+                    if (point.State == PointState.Add)
+                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 243, 77));
+                    else if (point.State == PointState.Persist)
+                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 77, 77));
+
+                    if ((_physics.Flags & PhysicsDebugFlags.ContactNormals) != 0)
+                    {
+                        Vector2 p1 = point.Position;
+                        Vector2 p2 = p1 + point.Normal * axisScale;
+                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 102));
+                    }
+                }
+
+                _physics.PointCount = 0;
+            }
+        }
+    }
+}

Robust.Client/GameController.cs

@@ -1,7 +1,9 @@
 using System;
 using System.IO;
+using System.Management;
 using System.Net;
 using System.Threading.Tasks;
+using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
 using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
@@ -26,7 +28,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
-using Robust.Shared.Timers;
+using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -44,9 +46,10 @@ namespace Robust.Client
         [Dependency] private readonly IUserInterfaceManagerInternal _userInterfaceManager = default!;
         [Dependency] private readonly IBaseClient _client = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
-        [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
+        [Dependency] private readonly IClientConsoleHost _console = default!;
         [Dependency] private readonly ITimerManager _timerManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
+        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly IPlacementManager _placementManager = default!;
         [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
         [Dependency] private readonly IOverlayManagerInternal _overlayManager = default!;
@@ -58,16 +61,18 @@ namespace Robust.Client
         [Dependency] private readonly IFontManagerInternal _fontManager = default!;
         [Dependency] private readonly IModLoaderInternal _modLoader = default!;
         [Dependency] private readonly IScriptClient _scriptClient = default!;
-        [Dependency] private readonly IComponentManager _componentManager = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IRobustMappedStringSerializer _stringSerializer = default!;
         [Dependency] private readonly IAuthManager _authManager = default!;
+        [Dependency] private readonly IMidiManager _midiManager = default!;
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
 
         private CommandLineArgs? _commandLineArgs;
-        private bool _disableAssemblyLoadContext;
+
         // Arguments for loader-load. Not used otherwise.
         private IMainArgs? _loaderArgs;
 
+        public bool ContentStart { get; set; } = false;
+        public GameControllerOptions Options { get; private set; } = new();
         public InitialLaunchState LaunchState { get; private set; } = default!;
 
         public bool LoadConfigAndUserData { get; set; } = true;
@@ -78,6 +83,77 @@ namespace Robust.Client
         }
 
         public bool Startup(Func<ILogHandler>? logHandlerFactory = null)
+        {
+            if (!StartupSystemSplash(logHandlerFactory))
+                return false;
+
+            // Disable load context usage on content start.
+            // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
+            _modLoader.SetUseLoadContext(!ContentStart);
+            _modLoader.SetEnableSandboxing(Options.Sandboxing);
+
+            if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), Options.ContentModulePrefix))
+            {
+                Logger.Fatal("Errors while loading content assemblies.");
+                return false;
+            }
+
+            foreach (var loadedModule in _modLoader.LoadedModules)
+            {
+                _configurationManager.LoadCVarsFromAssembly(loadedModule);
+            }
+
+            IoCManager.Resolve<ISerializationManager>().Initialize();
+
+            // Call Init in game assemblies.
+            _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
+            _modLoader.BroadcastRunLevel(ModRunLevel.Init);
+
+            _resourceCache.PreloadTextures();
+            _userInterfaceManager.Initialize();
+            _eyeManager.Initialize();
+            _networkManager.Initialize(false);
+            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
+            _serializer.Initialize();
+            _inputManager.Initialize();
+            _console.Initialize();
+            _prototypeManager.Initialize();
+            _prototypeManager.LoadDirectory(Options.PrototypeDirectory);
+            _prototypeManager.Resync();
+            _mapManager.Initialize();
+            _entityManager.Initialize();
+            IoCManager.Resolve<IEntityLookup>().Initialize();
+            _gameStateManager.Initialize();
+            _placementManager.Initialize();
+            _viewVariablesManager.Initialize();
+            _scriptClient.Initialize();
+
+            _client.Initialize();
+            _discord.Initialize();
+            _modLoader.BroadcastRunLevel(ModRunLevel.PostInit);
+
+            if (_commandLineArgs?.Username != null)
+            {
+                _client.PlayerNameOverride = _commandLineArgs.Username;
+            }
+
+            _authManager.LoadFromEnv();
+
+            GC.Collect();
+
+            _clyde.Ready();
+
+            if (!Options.DisableCommandLineConnect &&
+                (_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
+                && LaunchState.ConnectEndpoint != null)
+            {
+                _client.ConnectToServer(LaunchState.ConnectEndpoint);
+            }
+
+            return true;
+        }
+
+        private bool StartupSystemSplash(Func<ILogHandler>? logHandlerFactory)
         {
             ReadInitialLaunchState();
 
@@ -97,7 +173,7 @@ namespace Robust.Client
 
             if (LoadConfigAndUserData)
             {
-                var configFile = Path.Combine(userDataDir, "client_config.toml");
+                var configFile = Path.Combine(userDataDir, Options.ConfigFileName);
                 if (File.Exists(configFile))
                 {
                     // Load config from user data if available.
@@ -117,9 +193,16 @@ namespace Robust.Client
                 _configurationManager.OverrideConVars(_commandLineArgs.CVars);
             }
 
+            ProfileOptSetup.Setup(_configurationManager);
+
             _resourceCache.Initialize(LoadConfigAndUserData ? userDataDir : null);
 
-            ProgramShared.DoMounts(_resourceCache, _commandLineArgs?.MountOptions, "Content.Client", _loaderArgs != null);
+            var mountOptions = _commandLineArgs != null
+                ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions) : Options.MountOptions;
+
+            ProgramShared.DoMounts(_resourceCache, mountOptions, Options.ContentBuildDirectory,
+                _loaderArgs != null && !Options.ResourceMountDisabled, ContentStart);
+
             if (_loaderArgs != null)
             {
                 _stringSerializer.EnableCaching = false;
@@ -127,70 +210,22 @@ namespace Robust.Client
                 _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
             }
 
+            _clyde.TextEntered += TextEntered;
+            _clyde.MouseMove += MouseMove;
+            _clyde.KeyUp += KeyUp;
+            _clyde.KeyDown += KeyDown;
+            _clyde.MouseWheel += MouseWheel;
+            _clyde.CloseWindow += Shutdown;
+
             // Bring display up as soon as resources are mounted.
             if (!_clyde.Initialize())
             {
                 return false;
             }
 
-            _clyde.SetWindowTitle("Space Station 14");
-
-            _fontManager.Initialize();
-
-            // Disable load context usage on content start.
-            // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
-            _modLoader.SetUseLoadContext(!_disableAssemblyLoadContext);
-            _modLoader.SetEnableSandboxing(true);
-
-            if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), "Content."))
-            {
-                Logger.Fatal("Errors while loading content assemblies.");
-                return false;
-            }
-
-            foreach (var loadedModule in _modLoader.LoadedModules)
-            {
-                _configurationManager.LoadCVarsFromAssembly(loadedModule);
-            }
-
-            // Call Init in game assemblies.
-            _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
-            _modLoader.BroadcastRunLevel(ModRunLevel.Init);
-
-            _userInterfaceManager.Initialize();
-            _networkManager.Initialize(false);
-            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
-            _serializer.Initialize();
-            _inputManager.Initialize();
-            _consoleHost.Initialize();
-            _prototypeManager.LoadDirectory(new ResourcePath(@"/Prototypes/"));
-            _prototypeManager.Resync();
-            _mapManager.Initialize();
-            _entityManager.Initialize();
-            _gameStateManager.Initialize();
-            _placementManager.Initialize();
-            _viewVariablesManager.Initialize();
-            _scriptClient.Initialize();
-
-            _client.Initialize();
-            _discord.Initialize();
-            _modLoader.BroadcastRunLevel(ModRunLevel.PostInit);
-
-            if (_commandLineArgs?.Username != null)
-            {
-                _client.PlayerNameOverride = _commandLineArgs.Username;
-            }
-
-            _authManager.LoadFromEnv();
-
-            _clyde.Ready();
-
-            if ((_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
-                && LaunchState.ConnectEndpoint != null)
-            {
-                _client.ConnectToServer(LaunchState.ConnectEndpoint);
-            }
+            _clyde.SetWindowTitle(Options.DefaultWindowTitle);
 
+            _fontManager.SetFontDpi((uint) _configurationManager.GetCVar(CVars.DisplayFontDpi));
             return true;
         }
 
@@ -267,17 +302,20 @@ namespace Robust.Client
             _modLoader.BroadcastUpdate(ModUpdateLevel.PreEngine, frameEventArgs);
             _timerManager.UpdateTimers(frameEventArgs);
             _taskManager.ProcessPendingTasks();
-            _userInterfaceManager.Update(frameEventArgs);
 
-            if (_client.RunLevel >= ClientRunLevel.Connected)
+            // GameStateManager is in full control of the simulation update in multiplayer.
+            if (_client.RunLevel == ClientRunLevel.InGame || _client.RunLevel == ClientRunLevel.Connected)
             {
-                _componentManager.CullRemovedComponents();
                 _gameStateManager.ApplyGameState();
-                _entityManager.Update(frameEventArgs.DeltaSeconds);
-                _playerManager.Update(frameEventArgs.DeltaSeconds);
             }
 
-            _stateManager.Update(frameEventArgs);
+            // In singleplayer, however, we're in full control instead.
+            else if (_client.RunLevel == ClientRunLevel.SinglePlayerGame)
+            {
+                _entityManager.TickUpdate(frameEventArgs.DeltaSeconds);
+                _lookup.Update();
+            }
+
             _modLoader.BroadcastUpdate(ModUpdateLevel.PostEngine, frameEventArgs);
         }
 
@@ -298,11 +336,6 @@ namespace Robust.Client
             _modLoader.BroadcastUpdate(ModUpdateLevel.FramePostEngine, frameEventArgs);
         }
 
-        private void Render()
-        {
-
-        }
-
         internal static void SetupLogging(ILogManager logManager, Func<ILogHandler> logHandlerFactory)
         {
             logManager.RootSawmill.AddHandler(logHandlerFactory());
@@ -318,6 +351,7 @@ namespace Robust.Client
             logManager.GetSawmill("discord").Level = LogLevel.Warning;
             logManager.GetSawmill("net.predict").Level = LogLevel.Info;
             logManager.GetSawmill("szr").Level = LogLevel.Info;
+            logManager.GetSawmill("loc").Level = LogLevel.Error;
 
 #if DEBUG_ONLY_FCE_INFO
 #if DEBUG_ONLY_FCE_LOG
@@ -376,6 +410,9 @@ namespace Robust.Client
 
         private void Cleanup()
         {
+            _networkManager.Shutdown("Client shutting down");
+            _midiManager.Shutdown();
+            IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Shutdown();
             _clyde.Shutdown();
         }

Robust.Client/GameController/GameController.IoC.cs

@@ -17,7 +17,6 @@ namespace Robust.Client
             RegisterReflection();
         }
 
-
         internal static void RegisterReflection()
         {
             // Gets a handle to the shared and the current (client) dll.

Robust.Client/GameController/GameController.Standalone.cs

@@ -19,7 +19,7 @@ namespace Robust.Client
             Start(args);
         }
 
-        public static void Start(string[] args, bool contentStart = false, IMainArgs? loaderArgs=null)
+        public static void Start(string[] args, bool contentStart = false, IMainArgs? loaderArgs=null, GameControllerOptions? options = null)
         {
             if (_hasStarted)
             {
@@ -30,11 +30,11 @@ namespace Robust.Client
 
             if (CommandLineArgs.TryParse(args, out var parsed))
             {
-                ParsedMain(parsed, contentStart, loaderArgs);
+                ParsedMain(parsed, contentStart, loaderArgs, options);
             }
         }
 
-        private static void ParsedMain(CommandLineArgs args, bool contentStart, IMainArgs? loaderArgs)
+        private static void ParsedMain(CommandLineArgs args, bool contentStart, IMainArgs? loaderArgs, GameControllerOptions? options)
         {
             IoCManager.InitThread();
 
@@ -45,11 +45,13 @@ namespace Robust.Client
             var gc = (GameController) IoCManager.Resolve<IGameController>();
             gc.SetCommandLineArgs(args);
             gc._loaderArgs = loaderArgs;
+            if(options != null)
+                gc.Options = options;
 
             // When the game is ran with the startup executable being content,
             // we have to disable the separate load context.
             // Otherwise the content assemblies will be loaded twice which causes *many* fun bugs.
-            gc._disableAssemblyLoadContext = contentStart;
+            gc.ContentStart = contentStart;
             if (!gc.Startup())
             {
                 Logger.Fatal("Failed to start game controller!");

Robust.Client/GameControllerOptions.cs

@@ -0,0 +1,60 @@
+using Robust.Shared;
+using Robust.Shared.Utility;
+
+namespace Robust.Client
+{
+    public class GameControllerOptions
+    {
+        /// <summary>
+        ///     Whether content sandboxing will be enabled & enforced.
+        /// </summary>
+        public bool Sandboxing { get; init; } = true;
+
+        // TODO: Expose mounting methods to games using Robust as a library.
+        /// <summary>
+        ///     Lists of mount options to mount.
+        /// </summary>
+        public MountOptions MountOptions { get; init; } = new();
+
+        /// <summary>
+        ///     Name the userdata directory will have.
+        /// </summary>
+        public string UserDataDirectoryName { get; init; } = "Space Station 14";
+
+        /// <summary>
+        ///     Name of the configuration file in the user data directory.
+        /// </summary>
+        public string ConfigFileName { get; init; } = "client_config.toml";
+
+        // TODO: Define engine branding from json file in resources.
+        /// <summary>
+        ///     Default window title.
+        /// </summary>
+        public string DefaultWindowTitle { get; init; } = "Space Station 14";
+
+        /// <summary>
+        ///     Assemblies with this prefix will be loaded.
+        /// </summary>
+        public string ContentModulePrefix { get; init; } = "Content.";
+
+        /// <summary>
+        ///     Name of the content build directory, for game pack mounting purposes.
+        /// </summary>
+        public string ContentBuildDirectory { get; init; } = "Content.Client";
+
+        /// <summary>
+        ///     Directory to load all prototypes from.
+        /// </summary>
+        public ResourcePath PrototypeDirectory { get; init; } = new(@"/Prototypes/");
+
+        /// <summary>
+        ///     Whether to disable mounting the "Resources/" folder on FULL_RELEASE.
+        /// </summary>
+        public bool ResourceMountDisabled { get; init; } = false;
+
+        /// <summary>
+        ///     Whether to disable command line args server auto-connecting.
+        /// </summary>
+        public bool DisableCommandLineConnect { get; init; } = false;
+    }
+}

Robust.Client/GameObjects/ClientComponentFactory.cs

@@ -1,4 +1,5 @@
-using Robust.Shared.GameObjects;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Physics;
 
 namespace Robust.Client.GameObjects
@@ -23,9 +24,13 @@ namespace Robust.Client.GameObjects
 
             Register<PhysicsComponent>();
             RegisterReference<PhysicsComponent, IPhysBody>();
-            RegisterReference<PhysicsComponent, IPhysicsComponent>();
+
+            Register<CollisionWakeComponent>();
+
+            Register<ContainerManagerComponent>();
+            RegisterReference<ContainerManagerComponent, IContainerManager>();
+
             RegisterIgnore("KeyBindingInput");
-            Register<PointLightComponent>();
 
             Register<InputComponent>();
 
@@ -50,14 +55,10 @@ namespace Robust.Client.GameObjects
 
             Register<AnimationPlayerComponent>();
 
-            Register<ContainerManagerComponent>();
-            RegisterReference<ContainerManagerComponent, IContainerManager>();
-
             Register<TimerComponent>();
 
 #if DEBUG
             Register<DebugExceptionOnAddComponent>();
-            Register<DebugExceptionExposeDataComponent>();
             Register<DebugExceptionInitializeComponent>();
             Register<DebugExceptionStartupComponent>();
 #endif

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -1,11 +1,17 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
+using Prometheus;
+using Robust.Client.GameStates;
 using Robust.Shared.Exceptions;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
+using Robust.Shared.Network;
+using Robust.Shared.Network.Messages;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
@@ -13,303 +19,152 @@ namespace Robust.Client.GameObjects
     /// <summary>
     /// Manager for entities -- controls things like template loading and instantiation
     /// </summary>
-    public sealed class ClientEntityManager : EntityManager, IClientEntityManager
+    public sealed class ClientEntityManager : EntityManager, IClientEntityManagerInternal
     {
-        [Dependency] private readonly IMapManager _mapManager = default!;
-        [Dependency] private readonly IComponentFactory _compFactory = default!;
-#if EXCEPTION_TOLERANCE
-        [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
-#endif
+        [Dependency] private readonly IClientNetManager _networkManager = default!;
+        [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
+        [Dependency] private readonly IGameTiming _gameTiming = default!;
 
-        private int _nextClientEntityUid = EntityUid.ClientUid + 1;
+        protected override int NextEntityUid { get; set; } = EntityUid.ClientUid + 1;
 
-        public override void Startup()
+        public override void Initialize()
         {
-            base.Startup();
+            SetupNetworking();
+            ReceivedComponentMessage += (_, compMsg) => DispatchComponentMessage(compMsg);
+            ReceivedSystemMessage += (_, systemMsg) => EventBus.RaiseEvent(EventSource.Network, systemMsg);
 
-            if (Started)
-            {
-                throw new InvalidOperationException("Startup() called multiple times");
-            }
-
-            EntitySystemManager.Initialize();
-            Started = true;
+            base.Initialize();
         }
 
-        public List<EntityUid> ApplyEntityStates(EntityState[]? curEntStates, IEnumerable<EntityUid>? deletions,
-            EntityState[]? nextEntStates)
+        IEntity IClientEntityManagerInternal.CreateEntity(string? prototypeName, EntityUid? uid)
         {
-            var toApply = new Dictionary<IEntity, (EntityState?, EntityState?)>();
-            var toInitialize = new List<Entity>();
-            var created = new List<EntityUid>();
-            deletions ??= new EntityUid[0];
+            return base.CreateEntity(prototypeName, uid);
+        }
 
-            if (curEntStates != null && curEntStates.Length != 0)
+        void IClientEntityManagerInternal.InitializeEntity(IEntity entity)
+        {
+            EntityManager.InitializeEntity((Entity)entity);
+        }
+
+        void IClientEntityManagerInternal.StartEntity(IEntity entity)
+        {
+            base.StartEntity((Entity)entity);
+        }
+
+        #region IEntityNetworkManager impl
+
+        public override IEntityNetworkManager EntityNetManager => this;
+
+        /// <inheritdoc />
+        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
+
+        /// <inheritdoc />
+        public event EventHandler<object>? ReceivedSystemMessage;
+
+        private readonly PriorityQueue<(uint seq, MsgEntity msg)> _queue = new(new MessageTickComparer());
+        private uint _incomingMsgSequence = 0;
+
+        /// <inheritdoc />
+        public void SetupNetworking()
+        {
+            _networkManager.RegisterNetMessage<MsgEntity>(MsgEntity.NAME, HandleEntityNetworkMessage);
+        }
+
+        public override void TickUpdate(float frameTime, Histogram? histogram)
+        {
+            using (histogram?.WithLabels("EntityNet").NewTimer())
             {
-                foreach (var es in curEntStates)
+                while (_queue.Count != 0 && _queue.Peek().msg.SourceTick <= _gameStateManager.CurServerTick)
                 {
-                    //Known entities
-                    if (Entities.TryGetValue(es.Uid, out var entity))
-                    {
-                        toApply.Add(entity, (es, null));
-                    }
-                    else //Unknown entities
-                    {
-                        var metaState = (MetaDataComponentState?) es.ComponentStates
-                            ?.FirstOrDefault(c => c.NetID == NetIDs.META_DATA);
-                        if (metaState == null)
-                        {
-                            throw new InvalidOperationException($"Server sent new entity state for {es.Uid} without metadata component!");
-                        }
-                        var newEntity = CreateEntity(metaState.PrototypeId, es.Uid);
-                        toApply.Add(newEntity, (es, null));
-                        toInitialize.Add(newEntity);
-                        created.Add(newEntity.Uid);
-                    }
+                    var (_, msg) = _queue.Take();
+                    // Logger.DebugS("net.ent", "Dispatching: {0}: {1}", seq, msg);
+                    DispatchMsgEntity(msg);
                 }
             }
 
-            if (nextEntStates != null && nextEntStates.Length != 0)
-            {
-                foreach (var es in nextEntStates)
-                {
-                    if (Entities.TryGetValue(es.Uid, out var entity))
-                    {
-                        if (toApply.TryGetValue(entity, out var state))
-                        {
-                            toApply[entity] = (state.Item1, es);
-                        }
-                        else
-                        {
-                            toApply[entity] = (null, es);
-                        }
-                    }
-                }
-            }
-
-            // Make sure this is done after all entities have been instantiated.
-            foreach (var kvStates in toApply)
-            {
-                var ent = kvStates.Key;
-                var entity = (Entity) ent;
-                HandleEntityState(entity.EntityManager.ComponentManager, entity, kvStates.Value.Item1,
-                    kvStates.Value.Item2);
-            }
-
-            foreach (var kvp in toApply)
-            {
-                UpdateEntityTree(kvp.Key);
-            }
-
-            foreach (var id in deletions)
-            {
-                DeleteEntity(id);
-            }
-
-#if EXCEPTION_TOLERANCE
-            HashSet<Entity> brokenEnts = new HashSet<Entity>();
-#endif
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                try
-                {
-#endif
-                    InitializeEntity(entity);
-#if EXCEPTION_TOLERANCE
-                }
-                catch (Exception e)
-                {
-                    Logger.ErrorS("state", $"Server entity threw in Init: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
-                    brokenEnts.Add(entity);
-                }
-#endif
-            }
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                if(brokenEnts.Contains(entity))
-                    continue;
-
-                try
-                {
-#endif
-                    StartEntity(entity);
-#if EXCEPTION_TOLERANCE
-                }
-                catch (Exception e)
-                {
-                    Logger.ErrorS("state", $"Server entity threw in Start: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
-                    brokenEnts.Add(entity);
-                }
-#endif
-            }
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                if(brokenEnts.Contains(entity))
-                    continue;
-#endif
-                UpdateEntityTree(entity);
-            }
-#if EXCEPTION_TOLERANCE
-            foreach (var entity in brokenEnts)
-            {
-                entity.Delete();
-            }
-#endif
-
-            return created;
+            base.TickUpdate(frameTime, histogram);
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName)
+        public void SendSystemNetworkMessage(EntityEventArgs message)
         {
-            return CreateEntity(prototypeName);
+            SendSystemNetworkMessage(message, default(uint));
+        }
+
+        public void SendSystemNetworkMessage(EntityEventArgs message, uint sequence)
+        {
+            var msg = _networkManager.CreateNetMessage<MsgEntity>();
+            msg.Type = EntityMessageType.SystemMessage;
+            msg.SystemMessage = message;
+            msg.SourceTick = _gameTiming.CurTick;
+            msg.Sequence = sequence;
+
+            _networkManager.ClientSendMessage(msg);
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName, EntityCoordinates coordinates)
+        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel channel)
         {
-            var newEntity = CreateEntity(prototypeName, GenerateEntityUid());
-
-            if (TryGetEntity(coordinates.EntityId, out var entity))
-            {
-                newEntity.Transform.AttachParent(entity);
-                newEntity.Transform.Coordinates = coordinates;
-            }
-
-            return newEntity;
+            throw new NotSupportedException();
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName, MapCoordinates coordinates)
+        public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component, ComponentMessage message)
         {
-            var newEntity = CreateEntity(prototypeName, GenerateEntityUid());
-            newEntity.Transform.AttachParent(_mapManager.GetMapEntity(coordinates.MapId));
-            newEntity.Transform.WorldPosition = coordinates.Position;
-            return newEntity;
+            if (!component.NetID.HasValue)
+                throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
+
+            var msg = _networkManager.CreateNetMessage<MsgEntity>();
+            msg.Type = EntityMessageType.ComponentMessage;
+            msg.EntityUid = entity.Uid;
+            msg.NetId = component.NetID.Value;
+            msg.ComponentMessage = message;
+            msg.SourceTick = _gameTiming.CurTick;
+
+            _networkManager.ClientSendMessage(msg);
         }
 
-        /// <inheritdoc />
-        public override IEntity SpawnEntity(string? protoName, EntityCoordinates coordinates)
+        private void HandleEntityNetworkMessage(MsgEntity message)
         {
-            var newEnt = CreateEntityUninitialized(protoName, coordinates);
-            InitializeAndStartEntity((Entity) newEnt);
-            UpdateEntityTree(newEnt);
-            return newEnt;
-        }
-
-        /// <inheritdoc />
-        public override IEntity SpawnEntity(string? protoName, MapCoordinates coordinates)
-        {
-            var entity = CreateEntityUninitialized(protoName, coordinates);
-            InitializeAndStartEntity((Entity) entity);
-            UpdateEntityTree(entity);
-            return entity;
-        }
-
-        /// <inheritdoc />
-        public override IEntity SpawnEntityNoMapInit(string? protoName, EntityCoordinates coordinates)
-        {
-            return SpawnEntity(protoName, coordinates);
-        }
-
-        protected override EntityUid GenerateEntityUid()
-        {
-            return new(_nextClientEntityUid++);
-        }
-
-        private void HandleEntityState(IComponentManager compMan, IEntity entity, EntityState? curState,
-            EntityState? nextState)
-        {
-            var compStateWork = new Dictionary<uint, (ComponentState? curState, ComponentState? nextState)>();
-            var entityUid = entity.Uid;
-
-            if (curState?.ComponentChanges != null)
+            if (message.SourceTick <= _gameStateManager.CurServerTick)
             {
-                foreach (var compChange in curState.ComponentChanges)
-                {
-                    if (compChange.Deleted)
-                    {
-                        if (compMan.TryGetComponent(entityUid, compChange.NetID, out var comp))
-                        {
-                            compMan.RemoveComponent(entityUid, comp);
-                        }
-                    }
-                    else
-                    {
-                        if (compMan.HasComponent(entityUid, compChange.NetID))
-                            continue;
-
-                        var newComp = (Component) _compFactory.GetComponent(compChange.ComponentName!);
-                        newComp.Owner = entity;
-                        compMan.AddComponent(entity, newComp, true);
-                    }
-                }
+                DispatchMsgEntity(message);
+                return;
             }
 
-            if (curState?.ComponentStates != null)
-            {
-                foreach (var compState in curState.ComponentStates)
-                {
-                    compStateWork[compState.NetID] = (compState, null);
-                }
-            }
+            // MsgEntity is sent with ReliableOrdered so Lidgren guarantees ordering of incoming messages.
+            // We still need to store a sequence input number to ensure ordering remains consistent in
+            // the priority queue.
+            _queue.Add((++_incomingMsgSequence, message));
+        }
 
-            if (nextState?.ComponentStates != null)
+        private void DispatchMsgEntity(MsgEntity message)
+        {
+            switch (message.Type)
             {
-                foreach (var compState in nextState.ComponentStates)
-                {
-                    if (compStateWork.TryGetValue(compState.NetID, out var state))
-                    {
-                        compStateWork[compState.NetID] = (state.curState, compState);
-                    }
-                    else
-                    {
-                        compStateWork[compState.NetID] = (null, compState);
-                    }
-                }
-            }
+                case EntityMessageType.ComponentMessage:
+                    ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message));
+                    return;
 
-            foreach (var (netId, (cur, next)) in compStateWork)
-            {
-                if (compMan.TryGetComponent(entityUid, netId, out var component))
-                {
-                    try
-                    {
-                        component.HandleComponentState(cur, next);
-                    }
-                    catch (Exception e)
-                    {
-                        var wrapper = new ComponentStateApplyException(
-                            $"Failed to apply comp state: entity={component.Owner}, comp={component.Name}", e);
-#if EXCEPTION_TOLERANCE
-                    _runtimeLog.LogException(wrapper, "Component state apply");
-#else
-                        throw wrapper;
-#endif
-                    }
-                }
-                else
-                {
-                    // The component can be null here due to interp.
-                    // Because the NEXT state will have a new component, but this one doesn't yet.
-                    // That's fine though.
-                    if (cur == null)
-                    {
-                        continue;
-                    }
-
-                    var eUid = entityUid;
-                    var eRegisteredNetUidName = _compFactory.GetRegistration(netId).Name;
-                    DebugTools.Assert(
-                        $"Component does not exist for state: entUid={eUid}, expectedNetId={netId}, expectedName={eRegisteredNetUidName}");
-                }
+                case EntityMessageType.SystemMessage:
+                    ReceivedSystemMessage?.Invoke(this, message.SystemMessage);
+                    return;
             }
         }
+
+        private sealed class MessageTickComparer : IComparer<(uint seq, MsgEntity msg)>
+        {
+            public int Compare((uint seq, MsgEntity msg) x, (uint seq, MsgEntity msg) y)
+            {
+                var cmp = y.msg.SourceTick.CompareTo(x.msg.SourceTick);
+                if (cmp != 0)
+                {
+                    return cmp;
+                }
+
+                return y.seq.CompareTo(x.seq);
+            }
+        }
+        #endregion
     }
 }

Robust.Client/GameObjects/ClientEntityNetworkManager.cs

@@ -1,128 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Robust.Client.GameStates;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Network;
-using Robust.Shared.Network.Messages;
-using Robust.Shared.Timing;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects
-{
-    /// <summary>
-    /// The client implementation of the Entity Network Manager.
-    /// </summary>
-    public class ClientEntityNetworkManager : IEntityNetworkManager
-    {
-        [Dependency] private readonly IClientNetManager _networkManager = default!;
-        [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
-        [Dependency] private readonly IGameTiming _gameTiming = default!;
-
-        /// <inheritdoc />
-        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
-
-        /// <inheritdoc />
-        public event EventHandler<object>? ReceivedSystemMessage;
-
-        private readonly PriorityQueue<(uint seq, MsgEntity msg)> _queue = new(new MessageTickComparer());
-        private uint _incomingMsgSequence = 0;
-
-        /// <inheritdoc />
-        public void SetupNetworking()
-        {
-            _networkManager.RegisterNetMessage<MsgEntity>(MsgEntity.NAME, HandleEntityNetworkMessage);
-        }
-
-        public void Update()
-        {
-            while (_queue.Count != 0 && _queue.Peek().msg.SourceTick <= _gameStateManager.CurServerTick)
-            {
-                var (_, msg) = _queue.Take();
-                // Logger.DebugS("net.ent", "Dispatching: {0}: {1}", seq, msg);
-                DispatchMsgEntity(msg);
-            }
-        }
-
-        /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message)
-        {
-            SendSystemNetworkMessage(message, default(uint));
-        }
-
-        public void SendSystemNetworkMessage(EntitySystemMessage message, uint sequence)
-        {
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.SystemMessage;
-            msg.SystemMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-            msg.Sequence = sequence;
-
-            _networkManager.ClientSendMessage(msg);
-        }
-
-        /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel channel)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc />
-        public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component, ComponentMessage message)
-        {
-            if (!component.NetID.HasValue)
-                throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
-
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity.Uid;
-            msg.NetId = component.NetID.Value;
-            msg.ComponentMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-
-            _networkManager.ClientSendMessage(msg);
-        }
-
-        private void HandleEntityNetworkMessage(MsgEntity message)
-        {
-            if (message.SourceTick <= _gameStateManager.CurServerTick)
-            {
-                DispatchMsgEntity(message);
-                return;
-            }
-
-            // MsgEntity is sent with ReliableOrdered so Lidgren guarantees ordering of incoming messages.
-            // We still need to store a sequence input number to ensure ordering remains consistent in
-            // the priority queue.
-            _queue.Add((++_incomingMsgSequence, message));
-        }
-
-        private void DispatchMsgEntity(MsgEntity message)
-        {
-            switch (message.Type)
-            {
-                case EntityMessageType.ComponentMessage:
-                    ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message));
-                    return;
-
-                case EntityMessageType.SystemMessage:
-                    ReceivedSystemMessage?.Invoke(this, message.SystemMessage);
-                    return;
-            }
-        }
-
-        private sealed class MessageTickComparer : IComparer<(uint seq, MsgEntity msg)>
-        {
-            public int Compare((uint seq, MsgEntity msg) x, (uint seq, MsgEntity msg) y)
-            {
-                var cmp = y.msg.SourceTick.CompareTo(x.msg.SourceTick);
-                if (cmp != 0)
-                {
-                    return cmp;
-                }
-
-                return y.seq.CompareTo(x.seq);
-            }
-        }
-    }
-}

Robust.Client/GameObjects/Components/Appearance/AppearanceComponent.cs

@@ -4,8 +4,7 @@ using System.Diagnostics.CodeAnalysis;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Reflection;
-using Robust.Shared.Serialization;
-using Robust.Shared.Utility;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 using YamlDotNet.RepresentationModel;
 
@@ -15,13 +14,11 @@ namespace Robust.Client.GameObjects
     {
         [ViewVariables]
         private Dictionary<object, object> data = new();
+
         [ViewVariables]
+        [DataField("visuals")]
         internal List<AppearanceVisualizer> Visualizers = new();
 
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-
-        private static bool _didRegisterSerializer;
-
         [ViewVariables]
         private bool _appearanceDirty;
 
@@ -97,8 +94,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            EntitySystem.Get<AppearanceSystem>()
-                .EnqueueAppearanceUpdate(this);
+            EntitySystem.Get<AppearanceSystem>().EnqueueUpdate(this);
             _appearanceDirty = true;
         }
 
@@ -107,18 +103,6 @@ namespace Robust.Client.GameObjects
             _appearanceDirty = false;
         }
 
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            if (!_didRegisterSerializer)
-            {
-                YamlObjectSerializer.RegisterTypeSerializer(typeof(AppearanceVisualizer),
-                    new VisualizerTypeSerializer(_reflectionManager));
-                _didRegisterSerializer = true;
-            }
-
-            serializer.DataField(ref Visualizers, "visuals", new List<AppearanceVisualizer>());
-        }
-
         public override void Initialize()
         {
             base.Initialize();
@@ -130,108 +114,15 @@ namespace Robust.Client.GameObjects
 
             MarkDirty();
         }
-
-        class VisualizerTypeSerializer : YamlObjectSerializer.TypeSerializer
-        {
-            private readonly IReflectionManager _reflectionManager;
-
-            public VisualizerTypeSerializer(IReflectionManager reflectionManager)
-            {
-                _reflectionManager = reflectionManager;
-            }
-
-            public override object NodeToType(Type type, YamlNode node, YamlObjectSerializer serializer)
-            {
-                var mapping = (YamlMappingNode) node;
-                var nodeType = mapping.GetNode("type");
-                switch (nodeType.AsString())
-                {
-                    case SpriteLayerToggle.NAME:
-                        var keyString = mapping.GetNode("key").AsString();
-                        object key;
-                        if (_reflectionManager.TryParseEnumReference(keyString, out var @enum))
-                        {
-                            key = @enum;
-                        }
-                        else
-                        {
-                            key = keyString;
-                        }
-
-                        var layer = mapping.GetNode("layer").AsInt();
-                        return new SpriteLayerToggle(key, layer);
-
-                    default:
-                        var visType = _reflectionManager.LooseGetType(nodeType.AsString());
-                        if (!typeof(AppearanceVisualizer).IsAssignableFrom(visType))
-                        {
-                            throw new InvalidOperationException();
-                        }
-
-                        var vis = (AppearanceVisualizer) Activator.CreateInstance(visType)!;
-                        vis.LoadData(mapping);
-                        return vis;
-                }
-            }
-
-            public override YamlNode TypeToNode(object obj, YamlObjectSerializer serializer)
-            {
-                switch (obj)
-                {
-                    case SpriteLayerToggle spriteLayerToggle:
-                        YamlScalarNode key;
-                        if (spriteLayerToggle.Key is Enum)
-                        {
-                            var name = spriteLayerToggle.Key.GetType().FullName;
-                            key = new YamlScalarNode($"{name}.{spriteLayerToggle.Key}");
-                        }
-                        else
-                        {
-                            key = new YamlScalarNode(spriteLayerToggle.Key.ToString());
-                        }
-
-                        return new YamlMappingNode
-                        {
-                            {new YamlScalarNode("type"), new YamlScalarNode(SpriteLayerToggle.NAME)},
-                            {new YamlScalarNode("key"), key},
-                            {new YamlScalarNode("layer"), new YamlScalarNode(spriteLayerToggle.SpriteLayer.ToString())},
-                        };
-                    default:
-                        // TODO: A proper way to do serialization here.
-                        // I can't use the ExposeData system here since that's specific to entity serializers.
-                        return new YamlMappingNode();
-                }
-            }
-        }
-
-        internal class SpriteLayerToggle : AppearanceVisualizer
-        {
-            public const string NAME = "sprite_layer_toggle";
-
-            public readonly object Key;
-            public readonly int SpriteLayer;
-
-            public SpriteLayerToggle(object key, int spriteLayer)
-            {
-                Key = key;
-                SpriteLayer = spriteLayer;
-            }
-        }
     }
 
     /// <summary>
     ///     Handles the visualization of data inside of an appearance component.
     ///     Implementations of this class are NOT bound to a specific entity, they are flyweighted across multiple.
     /// </summary>
+    [ImplicitDataDefinitionForInheritors]
     public abstract class AppearanceVisualizer
     {
-        /// <summary>
-        ///     Load data from the prototype declaring this visualizer, to configure settings and such.
-        /// </summary>
-        public virtual void LoadData(YamlMappingNode node)
-        {
-        }
-
         /// <summary>
         ///     Initializes an entity to be managed by this appearance controller.
         ///     DO NOT assume this is your only entity. Visualizers are shared.

Robust.Client/GameObjects/Components/Containers/ContainerManagerComponent.ClientContainer.cs

@@ -1,86 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using Robust.Shared.GameObjects;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.GameObjects
-{
-    public sealed partial class ContainerManagerComponent
-    {
-        [DebuggerDisplay("ClientContainer {Owner.Uid}/{ID}")]
-        private sealed class ClientContainer : IContainer
-        {
-            public List<IEntity> Entities { get; } = new List<IEntity>();
-
-            public ClientContainer(string id, ContainerManagerComponent manager)
-            {
-                ID = id;
-                Manager = manager;
-            }
-
-            [ViewVariables] public IContainerManager Manager { get; }
-            [ViewVariables] public string ID { get; }
-            [ViewVariables] public IEntity Owner => Manager.Owner;
-            [ViewVariables] public bool Deleted { get; private set; }
-            [ViewVariables] public IReadOnlyList<IEntity> ContainedEntities => Entities;
-            [ViewVariables]
-            public bool ShowContents { get; set; }
-            [ViewVariables]
-            public bool OccludesLight { get; set; }
-
-            public bool CanInsert(IEntity toinsert)
-            {
-                return false;
-            }
-
-            public bool Insert(IEntity toinsert)
-            {
-                return false;
-            }
-
-            public bool CanRemove(IEntity toremove)
-            {
-                return false;
-            }
-
-            public bool Remove(IEntity toremove)
-            {
-                return false;
-            }
-
-            public void ForceRemove(IEntity toRemove)
-            {
-                throw new NotSupportedException("Cannot directly modify containers on the client");
-            }
-
-            public bool Contains(IEntity contained)
-            {
-                return Entities.Contains(contained);
-            }
-
-            public void DoInsert(IEntity entity)
-            {
-                Entities.Add(entity);
-
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(entity));
-            }
-
-            public void DoRemove(IEntity entity)
-            {
-                Entities.Remove(entity);
-
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(entity));
-            }
-
-            public void Shutdown()
-            {
-                Deleted = true;
-            }
-        }
-
-        public override void InternalContainerShutdown(IContainer container)
-        {
-        }
-    }
-}

Robust.Client/GameObjects/Components/Containers/ContainerManagerComponent.cs

@@ -1,168 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using Robust.Shared.GameObjects;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.GameObjects
-{
-    public sealed partial class ContainerManagerComponent : SharedContainerManagerComponent
-    {
-        [ViewVariables]
-        private readonly Dictionary<string, ClientContainer> _containers = new();
-
-        public override T MakeContainer<T>(string id)
-        {
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        public override bool Remove(IEntity entity)
-        {
-            // TODO: This will probably need relaxing if we want to predict things like inventories.
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        protected override IEnumerable<IContainer> GetAllContainersImpl()
-        {
-            return _containers.Values.Where(c => !c.Deleted);
-        }
-
-        public override IContainer GetContainer(string id)
-        {
-            return _containers[id];
-        }
-
-        public override bool HasContainer(string id)
-        {
-            return _containers.ContainsKey(id);
-        }
-
-        public override bool TryGetContainer(string id, [NotNullWhen(true)] out IContainer? container)
-        {
-            var ret = _containers.TryGetValue(id, out var cont);
-            container = cont!;
-            return ret;
-        }
-
-        /// <inheritdoc />
-        public override bool TryGetContainer(IEntity entity, [NotNullWhen(true)] out IContainer? container)
-        {
-            foreach (var contain in _containers.Values)
-            {
-                if (!contain.Deleted && contain.Contains(entity))
-                {
-                    container = contain;
-                    return true;
-                }
-            }
-
-            container = default;
-            return false;
-        }
-
-        public override bool ContainsEntity(IEntity entity)
-        {
-            foreach (var container in _containers.Values)
-            {
-                if (!container.Deleted && container.Contains(entity))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        public override void ForceRemove(IEntity entity)
-        {
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
-        {
-            if(!(curState is ContainerManagerComponentState cast))
-                return;
-
-            // Delete now-gone containers.
-            List<string>? toDelete = null;
-            foreach (var (id, container) in _containers)
-            {
-                if (!cast.Containers.ContainsKey(id))
-                {
-                    container.Shutdown();
-                    toDelete ??= new List<string>();
-                    toDelete.Add(id);
-                }
-            }
-
-            if (toDelete != null)
-            {
-                foreach (var dead in toDelete)
-                {
-                    _containers.Remove(dead);
-                }
-            }
-
-            // Add new containers and update existing contents.
-            foreach (var (id, data) in cast.Containers)
-            {
-
-                if (!_containers.TryGetValue(id, out var container))
-                {
-                    container = new ClientContainer(id, this);
-                    _containers.Add(id, container);
-                }
-
-                // sync show flag
-                container.ShowContents = data.ShowContents;
-                container.OccludesLight = data.OccludesLight;
-
-                // Remove gone entities.
-                List<IEntity>? toRemove = null;
-                foreach (var entity in container.Entities)
-                {
-                    if (!data.ContainedEntities.Contains(entity.Uid))
-                    {
-                        toRemove ??= new List<IEntity>();
-                        toRemove.Add(entity);
-                    }
-                }
-
-                if (toRemove != null)
-                {
-                    foreach (var goner in toRemove)
-                    {
-                        container.DoRemove(goner);
-                    }
-                }
-
-                // Add new entities.
-                foreach (var uid in data.ContainedEntities)
-                {
-                    var entity = Owner.EntityManager.GetEntity(uid);
-
-                    if (!container.Entities.Contains(entity))
-                    {
-                        container.DoInsert(entity);
-                    }
-                }
-            }
-        }
-
-        protected override void Shutdown()
-        {
-            base.Shutdown();
-
-            // On shutdown we won't get to process remove events in the containers so this has to be manually done.
-            foreach (var container in _containers.Values)
-            {
-                foreach (var containerEntity in container.Entities)
-                {
-                    Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                        new UpdateContainerOcclusionMessage(containerEntity));
-                }
-            }
-        }
-    }
-}

Robust.Client/GameObjects/Components/Eye/EyeComponent.cs

@@ -1,9 +1,11 @@
-using Robust.Client.Graphics;
+using Robust.Client.Graphics;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
@@ -20,8 +22,10 @@ namespace Robust.Client.GameObjects
 
         // Horrible hack to get around ordering issues.
         private bool _setCurrentOnInitialize;
-        private bool _setDrawFovOnInitialize;
-        private Vector2 _setZoomOnInitialize = Vector2.One/2f;
+        [DataField("drawFov")]
+        private bool _setDrawFovOnInitialize = true;
+        [DataField("zoom")]
+        private Vector2 _setZoomOnInitialize = Vector2.One;
         private Vector2 _offset = Vector2.Zero;
 
         public IEye? Eye => _eye;
@@ -148,6 +152,7 @@ namespace Robust.Client.GameObjects
             Zoom = state.Zoom;
             Offset = state.Offset;
             Rotation = state.Rotation;
+            VisibilityMask = state.VisibilityMask;
         }
 
         public override void OnRemove()
@@ -157,15 +162,6 @@ namespace Robust.Client.GameObjects
             Current = false;
         }
 
-        /// <inheritdoc />
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            base.ExposeData(serializer);
-
-            serializer.DataFieldCached(ref _setZoomOnInitialize, "zoom", Vector2.One/2f);
-            serializer.DataFieldCached(ref _setDrawFovOnInitialize, "drawFov", true);
-        }
-
         /// <summary>
         /// Updates the Eye of this entity with the transform position. This has to be called every frame to
         /// keep the view following the entity.

Robust.Client/GameObjects/Components/Icon/IconComponent.cs

@@ -1,105 +1,51 @@
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Client.Utility;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
     [RegisterComponent]
-    public class IconComponent : Component
+    public class IconComponent : Component, ISerializationHooks
     {
         public override string Name => "Icon";
         public IDirectionalTextureProvider? Icon { get; private set; }
 
-        [Dependency] private readonly IResourceCache _resourceCache = default!;
+        [DataField("sprite")]
+        private ResourcePath? rsi;
+        [DataField("state")]
+        private string? stateID;
+
+        void ISerializationHooks.AfterDeserialization()
+        {
+            if (rsi != null && stateID != null)
+            {
+                Icon = new SpriteSpecifier.Rsi(rsi, stateID).Frame0();
+            }
+        }
 
         public const string LogCategory = "go.comp.icon";
         const string SerializationCache = "icon";
 
-        public override void ExposeData(ObjectSerializer serializer)
+        private static IRsiStateLike TextureForConfig(IconComponent compData, IResourceCache resourceCache)
         {
-            base.ExposeData(serializer);
-
-            // TODO: Does this need writing?
-            if (serializer.Reading)
-            {
-                Icon = TextureForConfig(serializer, _resourceCache);
-            }
-        }
-
-        private static IRsiStateLike TextureForConfig(ObjectSerializer serializer, IResourceCache resourceCache)
-        {
-            DebugTools.Assert(serializer.Reading);
-
-            if (serializer.TryGetCacheData<IRsiStateLike>(SerializationCache, out var dirTex))
-            {
-                return dirTex;
-            }
-
-            var tex = serializer.ReadDataField<string?>("texture", null);
-            if (!string.IsNullOrWhiteSpace(tex))
-            {
-                dirTex = resourceCache.GetResource<TextureResource>(SpriteComponent.TextureRoot / tex).Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            RSI rsi;
-
-            var rsiPath = serializer.ReadDataField<string?>("sprite", null);
-
-            if (string.IsNullOrWhiteSpace(rsiPath))
-            {
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            var path = SpriteComponent.TextureRoot / rsiPath;
-
-            try
-            {
-                rsi = resourceCache.GetResource<RSIResource>(path).RSI;
-            }
-            catch
-            {
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            var stateId = serializer.ReadDataField<string?>("state", null);
-            if (string.IsNullOrWhiteSpace(stateId))
-            {
-                Logger.ErrorS(LogCategory, "No state specified.");
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            if (rsi.TryGetState(stateId, out var state))
-            {
-                serializer.SetCacheData(SerializationCache, state);
-                return state;
-            }
-            else
-            {
-                Logger.ErrorS(LogCategory, "State '{0}' does not exist on RSI.", stateId);
-                return resourceCache.GetFallback<TextureResource>().Texture;
-            }
+            return compData.Icon?.Default ?? resourceCache.GetFallback<TextureResource>().Texture;
         }
 
         public static IRsiStateLike? GetPrototypeIcon(EntityPrototype prototype, IResourceCache resourceCache)
         {
-            if (!prototype.Components.TryGetValue("Icon", out var mapping))
+            if (!prototype.Components.TryGetValue("Icon", out var compData))
             {
                 return null;
             }
-            return TextureForConfig(YamlObjectSerializer.NewReader(mapping), resourceCache);
+
+            return TextureForConfig((IconComponent)compData, resourceCache);
         }
     }
 }

Robust.Client/GameObjects/Components/IgnorePauseComponent.cs

@@ -1,11 +0,0 @@
-using Robust.Shared.GameObjects;
-
-namespace Robust.Client.GameObjects
-{
-    [RegisterComponent]
-    [ComponentReference(typeof(SharedIgnorePauseComponent))]
-    public sealed class IgnorePauseComponent : SharedIgnorePauseComponent
-    {
-
-    }
-}

Robust.Client/GameObjects/Components/Input/InputComponent.cs

@@ -1,6 +1,8 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
@@ -17,14 +19,7 @@ namespace Robust.Client.GameObjects
         ///     The context that will be made active for a client that attaches to this entity.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
-        public string ContextName { get; set; } = default!;
-
-        /// <inheritdoc />
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            base.ExposeData(serializer);
-
-            serializer.DataReadWriteFunction("context", InputContextContainer.DefaultContextName, value => ContextName = value, () => ContextName);
-        }
+        [DataField("context")]
+        public string ContextName { get; set; } = InputContextContainer.DefaultContextName;
     }
 }

Robust.Client/GameObjects/Components/Light/PointLightComponent.cs

@@ -7,12 +7,17 @@ using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
-    public class PointLightComponent : Component
+    [RegisterComponent]
+    [ComponentReference(typeof(IPointLightComponent))]
+    public class PointLightComponent : Component, IPointLightComponent, ISerializationHooks
     {
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
+
         public override string Name => "PointLight";
         public override uint? NetID => NetIDs.POINT_LIGHT;
 
@@ -65,6 +70,21 @@ namespace Robust.Client.GameObjects
             set => _rotation = value;
         }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// The resource path to the mask texture the light will use.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public string? MaskPath
+        {
+            get => _maskPath;
+            set
+            {
+                _maskPath = value;
+                UpdateMask();
+            }
+        }
+
         /// <summary>
         ///     Set a mask texture that will be applied to the light while rendering.
         ///     The mask's red channel will be linearly multiplied.p
@@ -115,16 +135,26 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        private float _radius = 5;
+        [DataField("radius")]
+        private float _radius = 5f;
+        [DataField("nestedvisible")]
         private bool _visibleNested = true;
-        private bool _lightOnParent = false;
+        private bool _lightOnParent;
+        [DataField("color")]
         private Color _color = Color.White;
-        private Vector2 _offset;
+        [DataField("offset")]
+        private Vector2 _offset = Vector2.Zero;
+        [DataField("enabled")]
         private bool _enabled = true;
+        [DataField("autoRot")]
         private bool _maskAutoRotate;
         private Angle _rotation;
-        private float _energy;
-        private float _softness;
+        [DataField("energy")]
+        private float _energy = 1f;
+        [DataField("softness")]
+        private float _softness = 1f;
+        [DataField("mask")]
+        private string? _maskPath;
 
         /// <summary>
         ///     Radius, in meters.
@@ -141,12 +171,34 @@ namespace Robust.Client.GameObjects
             }
         }
 
+        private void UpdateMask()
+        {
+            if (_maskPath is not null)
+                Mask = _resourceCache.GetResource<TextureResource>(_maskPath);
+            else
+                Mask = null;
+        }
+
+        void ISerializationHooks.AfterDeserialization()
+        {
+            if (_maskPath != null)
+            {
+                Mask = IoCManager.Resolve<IResourceCache>().GetResource<TextureResource>(_maskPath);
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            UpdateMask();
+        }
+
         /// <inheritdoc />
         public override void HandleMessage(ComponentMessage message, IComponent? component)
         {
             base.HandleMessage(message, component);
 
-            if ((message is ParentChangedMessage msg))
+            if (message is ParentChangedMessage msg)
             {
                 HandleTransformParentChanged(msg);
             }
@@ -170,23 +222,6 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            serializer.DataFieldCached(ref _offset, "offset", Vector2.Zero);
-            serializer.DataFieldCached(ref _radius, "radius", 5f);
-            serializer.DataFieldCached(ref _color, "color", Color.White);
-            serializer.DataFieldCached(ref _enabled, "enabled", true);
-            serializer.DataFieldCached(ref _energy, "energy", 1f);
-            serializer.DataFieldCached(ref _softness, "softness", 1f);
-            serializer.DataFieldCached(ref _maskAutoRotate, "autoRot", false);
-            serializer.DataFieldCached(ref _visibleNested, "nestedvisible", true);
-
-            if (serializer.Reading && serializer.TryReadDataField<string>("mask", out var value))
-            {
-                Mask = IoCManager.Resolve<IResourceCache>().GetResource<TextureResource>(value);
-            }
-        }
-
         public override void OnRemove()
         {
             base.OnRemove();

Robust.Client/GameObjects/Components/Renderable/ISpriteComponent.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Animations;
@@ -49,8 +49,26 @@ namespace Robust.Client.GameObjects
         ///     Rotation transformations on individual layers still apply.
         ///     If false, all layers get locked to south and rotation is a transformation.
         /// </summary>
+        [Obsolete("Use NoRotation and/or DirectionOverride")]
         bool Directional { get; set; }
 
+        /// <summary>
+        /// All sprite rotation is locked, and will always be drawn upright on
+        /// the screen, regardless of world or view orientation.
+        /// </summary>
+        bool NoRotation {get; set; }
+
+        /// <summary>
+        /// Enables overriding the calculated directional RSI state for this sprite.
+        /// The state to use is defined in <see cref="DirectionOverride"/>.
+        /// </summary>
+        bool EnableDirectionOverride { get; set; }
+
+        /// <summary>
+        /// The directional RSI state that will always be displayed, regardless of orientation.
+        /// </summary>
+        Direction DirectionOverride { get; set; }
+
         // NOTE: The below are ALL designed to NOT throw exceptions ever,
         // instead making a bunch of noisy error logs.
 
@@ -64,6 +82,8 @@ namespace Robust.Client.GameObjects
         uint RenderOrder { get; set; }
         bool IsInert { get; }
 
+        Matrix3 GetLocalMatrix();
+
         /// <summary>
         ///     Sets a layer key to the layer map, creating it if it does not exist.
         /// </summary>
@@ -202,5 +222,12 @@ namespace Robust.Client.GameObjects
         ISpriteLayer this[object layerKey] { get; }
 
         IEnumerable<ISpriteLayer> AllLayers { get; }
+
+        int GetLayerDirectionCount(ISpriteLayer layer);
+
+        /// <summary>
+        ///     Calculate sprite bounding box in world-space coordinates.
+        /// </summary>
+        Box2 CalculateBoundingBox();
     }
-}
+}

Robust.Client/GameObjects/Components/Renderable/ISpriteLayer.cs

@@ -26,5 +26,17 @@ namespace Robust.Client.GameObjects
         RSI.State.Direction EffectiveDirection(Angle worldRotation);
 
         Vector2 LocalToLayer(Vector2 localPos);
+
+        /// <summary>
+        ///     Layer size in pixels.
+        ///     Don't account layer scale or sprite world transform.
+        /// </summary>
+        Vector2i PixelSize { get; }
+
+        /// <summary>
+        ///     Calculate layer bounding box in sprite local-space coordinates.
+        /// </summary>
+        /// <returns>Bounding box in sprite local-space coordinates.</returns>
+        Box2 CalculateBoundingBox();
     }
 }

Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs

@@ -6,41 +6,31 @@ using Robust.Shared.Network;
 using Robust.Shared.Players;
 using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 
 namespace Robust.Client.GameObjects
 {
-    public class ClientUserInterfaceComponent : SharedUserInterfaceComponent
+    public class ClientUserInterfaceComponent : SharedUserInterfaceComponent, ISerializationHooks
     {
+        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
+
         private readonly Dictionary<object, BoundUserInterface> _openInterfaces =
             new();
 
-        private Dictionary<object, PrototypeData> _interfaceData = default!;
-#pragma warning disable 649
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
-#pragma warning restore 649
+        private readonly Dictionary<object, PrototypeData> _interfaces = new();
 
-        public override void ExposeData(ObjectSerializer serializer)
+        [DataField("interfaces", readOnly: true)]
+        private List<PrototypeData> _interfaceData = new();
+
+        void ISerializationHooks.AfterDeserialization()
         {
-            base.ExposeData(serializer);
+            _interfaces.Clear();
 
-            const string cache = "ui_cache";
-
-            if (serializer.TryGetCacheData<Dictionary<object, PrototypeData>>(cache, out var interfaceData))
+            foreach (var data in _interfaceData)
             {
-                _interfaceData = interfaceData;
-                return;
+                _interfaces[data.UiKey] = data;
             }
-
-            var data = serializer.ReadDataFieldCached("interfaces", new List<PrototypeData>());
-            interfaceData = new Dictionary<object, PrototypeData>();
-            foreach (var prototypeData in data)
-            {
-                interfaceData[prototypeData.UiKey] = prototypeData;
-            }
-
-            serializer.SetCacheData(cache, interfaceData);
-            _interfaceData = interfaceData;
         }
 
         public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel,
@@ -81,7 +71,7 @@ namespace Robust.Client.GameObjects
 
         private void OpenInterface(BoundInterfaceMessageWrapMessage wrapped)
         {
-            var data = _interfaceData[wrapped.UiKey];
+            var data = _interfaces[wrapped.UiKey];
             // TODO: This type should be cached, but I'm too lazy.
             var type = _reflectionManager.LooseGetType(data.ClientType);
             var boundInterface = (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[]{this, wrapped.UiKey});

Robust.Client/GameObjects/EntityManagerExt.cs

@@ -9,13 +9,13 @@ namespace Robust.Client.GameObjects
     public static class EntityManagerExt
     {
         public static void RaisePredictiveEvent<T>(this IEntityManager entityManager, T msg)
-            where T : EntitySystemMessage
+            where T : EntityEventArgs
         {
             var localPlayer = IoCManager.Resolve<IPlayerManager>().LocalPlayer;
             DebugTools.AssertNotNull(localPlayer);
 
             var sequence = IoCManager.Resolve<IClientGameStateManager>().SystemMessageDispatched(msg);
-            entityManager.EntityNetManager.SendSystemNetworkMessage(msg, sequence);
+            entityManager.EntityNetManager?.SendSystemNetworkMessage(msg, sequence);
 
             var eventArgs = new EntitySessionEventArgs(localPlayer!.Session);
 

Robust.Client/GameObjects/EntitySystems/AppearanceSystem.cs

@@ -1,51 +1,33 @@
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
 
 namespace Robust.Client.GameObjects
 {
+    [UsedImplicitly]
     internal sealed class AppearanceSystem : EntitySystem
     {
-        private readonly Queue<AppearanceComponent> _updatesQueued = new();
+        private readonly Queue<AppearanceComponent> _queuedUpdates = new();
+
+        public void EnqueueUpdate(AppearanceComponent component)
+        {
+            _queuedUpdates.Enqueue(component);
+        }
 
         public override void FrameUpdate(float frameTime)
         {
-            while (_updatesQueued.TryDequeue(out var appearance))
+            while (_queuedUpdates.TryDequeue(out var appearance))
             {
-                UpdateComponent(appearance);
+                if (appearance.Deleted)
+                    return;
+
+                foreach (var visualizer in appearance.Visualizers)
+                {
+                    visualizer.OnChangeData(appearance);
+                }
+
                 appearance.UnmarkDirty();
             }
         }
-
-        private static void UpdateComponent(AppearanceComponent component)
-        {
-            if (component.Deleted)
-                return;
-
-            foreach (var visualizer in component.Visualizers)
-            {
-                switch (visualizer)
-                {
-                    case AppearanceComponent.SpriteLayerToggle spriteLayerToggle:
-                        UpdateSpriteLayerToggle(component, spriteLayerToggle);
-                        break;
-
-                    default:
-                        visualizer.OnChangeData(component);
-                        break;
-                }
-            }
-        }
-
-        private static void UpdateSpriteLayerToggle(AppearanceComponent component, AppearanceComponent.SpriteLayerToggle toggle)
-        {
-            component.TryGetData(toggle.Key, out bool visible);
-            var sprite = component.Owner.GetComponent<SpriteComponent>();
-            sprite.LayerSetVisible(toggle.SpriteLayer, visible);
-        }
-
-        public void EnqueueAppearanceUpdate(AppearanceComponent component)
-        {
-            _updatesQueued.Enqueue(component);
-        }
     }
 }

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Client.Audio;
@@ -9,14 +8,15 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
+using Robust.Shared.Player;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
     [UsedImplicitly]
-    public class AudioSystem : EntitySystem
+    public class AudioSystem : EntitySystem, IAudioSystem
     {
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
@@ -24,17 +24,32 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
-        private readonly List<PlayingStream> _playingClydeStreams = new();
+        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
 
-        public int OcclusionCollisionMask;
+        private readonly List<PlayingStream> _playingClydeStreams = new();
 
         /// <inheritdoc />
         public override void Initialize()
         {
+            base.Initialize();
             SubscribeNetworkEvent<PlayAudioEntityMessage>(PlayAudioEntityHandler);
             SubscribeNetworkEvent<PlayAudioGlobalMessage>(PlayAudioGlobalHandler);
             SubscribeNetworkEvent<PlayAudioPositionalMessage>(PlayAudioPositionalHandler);
             SubscribeNetworkEvent<StopAudioMessageClient>(StopAudioMessageHandler);
+
+            SubscribeLocalEvent<SoundSystem.QueryAudioSystem>((ev => ev.Audio = this));
+            _broadPhaseSystem = Get<SharedBroadPhaseSystem>();
+        }
+
+        public override void Shutdown()
+        {
+            base.Shutdown();
+            UnsubscribeNetworkEvent<PlayAudioEntityMessage>();
+            UnsubscribeNetworkEvent<PlayAudioGlobalMessage>();
+            UnsubscribeNetworkEvent<PlayAudioPositionalMessage>();
+            UnsubscribeNetworkEvent<StopAudioMessageClient>();
+
+            UnsubscribeLocalEvent<SoundSystem.QueryAudioSystem>();
         }
 
         private void StopAudioMessageHandler(StopAudioMessageClient ev)
@@ -141,7 +156,7 @@ namespace Robust.Client.GameObjects
                             var occlusion = 0f;
                             if (sourceRelative.Length > 0)
                             {
-                                occlusion = IoCManager.Resolve<IPhysicsManager>().IntersectRayPenetration(
+                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
                                     pos.MapId,
                                     new CollisionRay(
                                         pos.Position,
@@ -160,6 +175,12 @@ namespace Robust.Client.GameObjects
                             Logger.Warning("Interrupting positional audio, can't set position.");
                             stream.Source.StopPlaying();
                         }
+
+                        if (stream.TrackingEntity != null)
+                        {
+                            stream.Source.SetVelocity(stream.TrackingEntity.GlobalLinearVelocity());
+                        }
+
                     }
                 }
             }
@@ -176,7 +197,6 @@ namespace Robust.Client.GameObjects
         {
             stream.Source.Dispose();
             stream.Done = true;
-            stream.DoPlaybackDone();
         }
 
         /// <summary>
@@ -184,7 +204,7 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -200,7 +220,7 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream Play(AudioStream stream, AudioParams? audioParams = null)
+        private IPlayingAudioStream Play(AudioStream stream, AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
             ApplyAudioParams(audioParams, source);
@@ -222,7 +242,7 @@ namespace Robust.Client.GameObjects
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, IEntity entity, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -239,7 +259,7 @@ namespace Robust.Client.GameObjects
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(AudioStream stream, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(AudioStream stream, IEntity entity, AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
             if (!source.SetPosition(entity.Transform.WorldPosition))
@@ -268,7 +288,7 @@ namespace Robust.Client.GameObjects
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -285,7 +305,7 @@ namespace Robust.Client.GameObjects
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
+        private IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
             AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
@@ -335,92 +355,30 @@ namespace Robust.Client.GameObjects
             {
                 Source.StopPlaying();
             }
-
-            public event Action? PlaybackDone;
-
-            public void DoPlaybackDone()
-            {
-                PlaybackDone?.Invoke();
-            }
-        }
-    }
-
-    public interface IPlayingAudioStream
-    {
-        void Stop();
-
-        event Action PlaybackDone;
-    }
-
-    public static class AudioSystemExtensions
-    {
-
-        /// <summary>
-        ///     Play an audio file following an entity.
-        /// </summary>
-        /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-        /// <param name="entity">The entity "emitting" the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this IEntity entity,
-            string filename,
-            AudioParams? audioParams,
-            AudioSystem? audioSystem = null)
-        {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(filename, entity, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio stream following an entity.
-        /// </summary>
-        /// <param name="stream">The audio stream to play.</param>
-        /// <param name="entity">The entity "emitting" the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this IEntity entity,
-            AudioStream stream,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public int DefaultSoundRange => 25;
+
+        /// <inheritdoc />
+        public int OcclusionCollisionMask { get; set; }
+
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(stream, entity, audioParams);
+            return Play(filename, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio file at a static position.
-        /// </summary>
-        /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-        /// <param name="coordinates">The coordinates at which to play the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this EntityCoordinates coordinates,
-            string filename,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, IEntity entity, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(filename, coordinates, audioParams);
+            return Play(filename, entity, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio stream at a static position.
-        /// </summary>
-        /// <param name="stream">The audio stream to play.</param>
-        /// <param name="coordinates">The coordinates at which to play the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this EntityCoordinates coordinates,
-            AudioStream stream,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(stream, coordinates, audioParams);
+            return Play(filename, coordinates, audioParams);
         }
     }
 }

Robust.Client/GameObjects/EntitySystems/ClientContainerSystem.cs

@@ -4,7 +4,7 @@ using Robust.Shared.GameObjects;
 
 namespace Robust.Client.GameObjects
 {
-    public class ContainerSystem : EntitySystem
+    public class ClientContainerSystem : ContainerSystem
     {
         private readonly HashSet<IEntity> _updateQueue = new();
 
@@ -91,14 +91,4 @@ namespace Robust.Client.GameObjects
             }
         }
     }
-
-    internal readonly struct UpdateContainerOcclusionMessage
-    {
-        public UpdateContainerOcclusionMessage(IEntity entity)
-        {
-            Entity = entity;
-        }
-
-        public IEntity Entity { get; }
-    }
 }

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -106,7 +106,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     ///     Event raised by a <see cref="ClientOccluderComponent"/> when it needs to be recalculated.
     /// </summary>
-    internal sealed class OccluderDirtyEvent : EntitySystemMessage
+    internal sealed class OccluderDirtyEvent : EntityEventArgs
     {
         public OccluderDirtyEvent(IEntity sender, (GridId grid, Vector2i pos)? lastPosition, SnapGridOffset offset)
         {

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -11,6 +11,7 @@ using Robust.Shared.Log;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
+using Robust.Shared.Enums;
 
 namespace Robust.Client.GameObjects
 {
@@ -42,7 +43,7 @@ namespace Robust.Client.GameObjects
         {
             base.Shutdown();
 
-            overlayManager.RemoveOverlay("EffectSystem");
+            overlayManager.RemoveOverlay(typeof(EffectOverlay));
         }
 
         public void CreateEffect(EffectSystemMessage message)
@@ -329,7 +330,6 @@ namespace Robust.Client.GameObjects
         {
             private readonly IPlayerManager _playerManager;
 
-            public override bool AlwaysDirty => true;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
             private readonly ShaderInstance _unshadedShader;
@@ -337,8 +337,7 @@ namespace Robust.Client.GameObjects
             private readonly IMapManager _mapManager;
             private readonly IEntityManager _entityManager;
 
-            public EffectOverlay(EffectSystem owner, IPrototypeManager protoMan, IMapManager mapMan, IPlayerManager playerMan, IEntityManager entityManager) : base(
-                "EffectSystem")
+            public EffectOverlay(EffectSystem owner, IPrototypeManager protoMan, IMapManager mapMan, IPlayerManager playerMan, IEntityManager entityManager)
             {
                 _owner = owner;
                 _unshadedShader = protoMan.Index<ShaderPrototype>("unshaded").Instance();
@@ -347,11 +346,11 @@ namespace Robust.Client.GameObjects
                 _entityManager = entityManager;
             }
 
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
                 var map = _owner.eyeManager.CurrentMap;
 
-                var worldHandle = (DrawingHandleWorld) handle;
+                var worldHandle = args.WorldHandle;
                 ShaderInstance? currentShader = null;
                 var player = _playerManager.LocalPlayer?.ControlledEntity;
 

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -40,7 +40,7 @@ namespace Robust.Client.GameObjects
         /// <param name="message">Arguments for this event.</param>
         /// <param name="replay">if true, current cmd state will not be checked or updated - use this for "replaying" an
         /// old input that was saved or buffered until further processing could be done</param>
-        public bool HandleInputCommand(ICommonSession session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false)
+        public bool HandleInputCommand(ICommonSession? session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false)
         {
             #if DEBUG
 
@@ -97,7 +97,7 @@ namespace Robust.Client.GameObjects
         private void DispatchInputCommand(FullInputCmdMessage message)
         {
             _stateManager.InputCommandDispatched(message);
-            EntityNetworkManager.SendSystemNetworkMessage(message, message.InputSequence);
+            EntityManager.EntityNetManager?.SendSystemNetworkMessage(message, message.InputSequence);
         }
 
         public override void Initialize()
@@ -157,7 +157,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     ///     Entity system message that is raised when the player changes attached entities.
     /// </summary>
-    public class PlayerAttachSysMessage : EntitySystemMessage
+    public class PlayerAttachSysMessage : EntityEventArgs
     {
         /// <summary>
         ///     New entity the player is attached to.

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -19,19 +19,19 @@ namespace Robust.Client.GameObjects
 
         [Dependency] private readonly IMapManagerInternal _mapManager = default!;
 
-        private readonly Dictionary<MapId, MapTrees> _mapTrees = new();
+        private readonly Dictionary<MapId, Dictionary<GridId, MapTrees>> _gridTrees = new();
 
         private readonly List<SpriteComponent> _spriteQueue = new();
         private readonly List<PointLightComponent> _lightQueue = new();
 
-        internal DynamicTree<SpriteComponent> GetSpriteTreeForMap(MapId map)
+        internal DynamicTree<SpriteComponent> GetSpriteTreeForMap(MapId map, GridId grid)
         {
-            return _mapTrees[map].SpriteTree;
+            return _gridTrees[map][grid].SpriteTree;
         }
 
-        internal DynamicTree<PointLightComponent> GetLightTreeForMap(MapId map)
+        internal DynamicTree<PointLightComponent> GetLightTreeForMap(MapId map, GridId grid)
         {
-            return _mapTrees[map].LightTree;
+            return _gridTrees[map][grid].LightTree;
         }
 
         public override void Initialize()
@@ -44,6 +44,8 @@ namespace Robust.Client.GameObjects
 
             _mapManager.MapCreated += MapManagerOnMapCreated;
             _mapManager.MapDestroyed += MapManagerOnMapDestroyed;
+            _mapManager.OnGridCreated += MapManagerOnGridCreated;
+            _mapManager.OnGridRemoved += MapManagerOnGridRemoved;
 
             SubscribeLocalEvent<EntMapIdChangedMessage>(EntMapIdChanged);
             SubscribeLocalEvent<MoveEvent>(EntMoved);
@@ -53,18 +55,40 @@ namespace Robust.Client.GameObjects
             SubscribeLocalEvent<RenderTreeRemoveLightMessage>(RemoveLight);
         }
 
+        public override void Shutdown()
+        {
+            base.Shutdown();
+            _mapManager.MapCreated -= MapManagerOnMapCreated;
+            _mapManager.MapDestroyed -= MapManagerOnMapDestroyed;
+            _mapManager.OnGridCreated -= MapManagerOnGridCreated;
+            _mapManager.OnGridRemoved -= MapManagerOnGridRemoved;
+
+            UnsubscribeLocalEvent<EntMapIdChangedMessage>();
+            UnsubscribeLocalEvent<MoveEvent>();
+            UnsubscribeLocalEvent<EntParentChangedMessage>();
+            UnsubscribeLocalEvent<PointLightRadiusChangedMessage>();
+            UnsubscribeLocalEvent<RenderTreeRemoveSpriteMessage>();
+            UnsubscribeLocalEvent<RenderTreeRemoveLightMessage>();
+        }
+
         // For these next 2 methods (the Remove* ones):
         // If the Transform is removed BEFORE the Sprite/Light,
         // then the MapIdChanged code will handle and remove it (because MapId gets set to nullspace).
         // Otherwise these will still have their past MapId and that's all we need..
         private void RemoveLight(RenderTreeRemoveLightMessage ev)
         {
-            _mapTrees[ev.Map].LightTree.Remove(ev.Light);
+            foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Map, MapTrees.LightAabbFunc(ev.Light), true))
+            {
+                _gridTrees[ev.Map][gridId].LightTree.Remove(ev.Light);
+            }
         }
 
         private void RemoveSprite(RenderTreeRemoveSpriteMessage ev)
         {
-            _mapTrees[ev.Map].SpriteTree.Remove(ev.Sprite);
+            foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Map, MapTrees.SpriteAabbFunc(ev.Sprite), true))
+            {
+                _gridTrees[ev.Map][gridId].SpriteTree.Remove(ev.Sprite);
+            }
         }
 
         private void PointLightRadiusChanged(PointLightRadiusChangedMessage ev)
@@ -119,27 +143,69 @@ namespace Robust.Client.GameObjects
         {
             // Nullspace is a valid map ID for stuff to have but we also aren't gonna bother indexing it.
             // So that's why there's a GetValueOrDefault.
-            var oldMapTrees = _mapTrees.GetValueOrDefault(ev.OldMapId);
-            var newMapTrees = _mapTrees.GetValueOrDefault(ev.Entity.Transform.MapID);
+            var oldMapTrees = _gridTrees.GetValueOrDefault(ev.OldMapId);
 
+            // TODO: MMMM probably a better way to do this.
             if (ev.Entity.TryGetComponent(out SpriteComponent? sprite))
             {
-                oldMapTrees?.SpriteTree.Remove(sprite);
+                if (oldMapTrees != null)
+                {
+                    foreach (var (_, gridTree) in oldMapTrees)
+                    {
+                        gridTree.SpriteTree.Remove(sprite);
+                    }
+                }
 
-                newMapTrees?.SpriteTree.AddOrUpdate(sprite);
+                var bounds = MapTrees.SpriteAabbFunc(sprite);
+
+                foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Entity.Transform.MapID, bounds, true))
+                {
+                    Box2 gridBounds;
+
+                    if (gridId == GridId.Invalid)
+                    {
+                        gridBounds = bounds;
+                    }
+                    else
+                    {
+                        gridBounds = bounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
+                    }
+                    _gridTrees[ev.Entity.Transform.MapID][gridId].SpriteTree.AddOrUpdate(sprite, gridBounds);
+                }
             }
 
             if (ev.Entity.TryGetComponent(out PointLightComponent? light))
             {
-                oldMapTrees?.LightTree.Remove(light);
+                if (oldMapTrees != null)
+                {
+                    foreach (var (_, gridTree) in oldMapTrees)
+                    {
+                        gridTree.LightTree.Remove(light);
+                    }
+                }
 
-                newMapTrees?.LightTree.AddOrUpdate(light);
+                var bounds = MapTrees.LightAabbFunc(light);
+
+                foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Entity.Transform.MapID, bounds, true))
+                {
+                    Box2 gridBounds;
+
+                    if (gridId == GridId.Invalid)
+                    {
+                        gridBounds = bounds;
+                    }
+                    else
+                    {
+                        gridBounds = bounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
+                    }
+                    _gridTrees[ev.Entity.Transform.MapID][gridId].LightTree.AddOrUpdate(light, gridBounds);
+                }
             }
         }
 
         private void MapManagerOnMapDestroyed(object? sender, MapEventArgs e)
         {
-            _mapTrees.Remove(e.Map);
+            _gridTrees.Remove(e.Map);
         }
 
         private void MapManagerOnMapCreated(object? sender, MapEventArgs e)
@@ -149,36 +215,59 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            _mapTrees.Add(e.Map, new MapTrees());
+            _gridTrees.Add(e.Map, new Dictionary<GridId, MapTrees>
+            {
+                {GridId.Invalid, new MapTrees()}
+            });
+        }
+
+        private void MapManagerOnGridCreated(MapId mapId, GridId gridId)
+        {
+            _gridTrees[mapId].Add(gridId, new MapTrees());
+        }
+
+        private void MapManagerOnGridRemoved(MapId mapId, GridId gridId)
+        {
+            _gridTrees[mapId].Remove(gridId);
         }
 
         public override void FrameUpdate(float frameTime)
         {
             foreach (var queuedUpdateSprite in _spriteQueue)
             {
-                var transform = queuedUpdateSprite.Owner.Transform;
-                var map = transform.MapID;
+                var map = queuedUpdateSprite.Owner.Transform.MapID;
                 if (map == MapId.Nullspace)
                 {
                     continue;
                 }
-                var updateMapTree = _mapTrees[map].SpriteTree;
 
-                updateMapTree.AddOrUpdate(queuedUpdateSprite);
+                var mapTree = _gridTrees[map];
+
+                foreach (var gridId in _mapManager.FindGridIdsIntersecting(map,
+                    MapTrees.SpriteAabbFunc(queuedUpdateSprite), true))
+                {
+                    mapTree[gridId].SpriteTree.AddOrUpdate(queuedUpdateSprite);
+                }
+
                 queuedUpdateSprite.TreeUpdateQueued = false;
             }
 
             foreach (var queuedUpdateLight in _lightQueue)
             {
-                var transform = queuedUpdateLight.Owner.Transform;
-                var map = transform.MapID;
+                var map = queuedUpdateLight.Owner.Transform.MapID;
                 if (map == MapId.Nullspace)
                 {
                     continue;
                 }
-                var updateMapTree = _mapTrees[map].LightTree;
 
-                updateMapTree.AddOrUpdate(queuedUpdateLight);
+                var mapTree = _gridTrees[map];
+
+                foreach (var gridId in _mapManager.FindGridIdsIntersecting(map,
+                    MapTrees.LightAabbFunc(queuedUpdateLight), true))
+                {
+                    mapTree[gridId].LightTree.AddOrUpdate(queuedUpdateLight);
+                }
+
                 queuedUpdateLight.TreeUpdateQueued = false;
             }
 
@@ -197,14 +286,14 @@ namespace Robust.Client.GameObjects
                 LightTree = new DynamicTree<PointLightComponent>(LightAabbFunc);
             }
 
-            private static Box2 SpriteAabbFunc(in SpriteComponent value)
+            internal static Box2 SpriteAabbFunc(in SpriteComponent value)
             {
                 var worldPos = value.Owner.Transform.WorldPosition;
 
                 return new Box2(worldPos, worldPos);
             }
 
-            private static Box2 LightAabbFunc(in PointLightComponent value)
+            internal static Box2 LightAabbFunc(in PointLightComponent value)
             {
                 var worldPos = value.Owner.Transform.WorldPosition;
 

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -3,6 +3,7 @@ using Robust.Client.Graphics;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
+using Robust.Shared.Maths;
 
 namespace Robust.Client.GameObjects
 {
@@ -13,6 +14,7 @@ namespace Robust.Client.GameObjects
     public class SpriteSystem : EntitySystem
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
 
         /// <inheritdoc />
         public override void FrameUpdate(float frameTime)
@@ -29,18 +31,32 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            var mapTree = renderTreeSystem.GetSpriteTreeForMap(currentMap);
-
-            mapTree.QueryAabb(ref frameTime, (ref float state, in SpriteComponent value) =>
+            foreach (var gridId in _mapManager.FindGridIdsIntersecting(currentMap, pvsBounds, true))
             {
-                if (value.IsInert)
+                Box2 gridBounds;
+
+                if (gridId == GridId.Invalid)
                 {
-                    return true;
+                    gridBounds = pvsBounds;
+                }
+                else
+                {
+                    gridBounds = pvsBounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
                 }
 
-                value.FrameUpdate(state);
-                return true;
-            }, pvsBounds, approx: true);
+                var mapTree = renderTreeSystem.GetSpriteTreeForMap(currentMap, gridId);
+
+                mapTree.QueryAabb(ref frameTime, (ref float state, in SpriteComponent value) =>
+                {
+                    if (value.IsInert)
+                    {
+                        return true;
+                    }
+
+                    value.FrameUpdate(state);
+                    return true;
+                }, gridBounds, approx: true);
+            }
         }
     }
 }

Robust.Client/GameObjects/EntitySystems/VelocityDebugSystem.cs

@@ -0,0 +1,51 @@
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.GameObjects
+{
+    public class VelocityDebugSystem : EntitySystem
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+        internal bool Enabled { get; set; }
+
+        private Label _label = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _label = new Label();
+            IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+        }
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+            if (!Enabled)
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var player = _playerManager.LocalPlayer?.ControlledEntity;
+
+            if (player == null || !player.TryGetComponent(out PhysicsComponent? body))
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var screenPos = _eyeManager.WorldToScreen(player.Transform.WorldPosition);
+            LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
+            _label.Visible = true;
+
+            _label.Text = $"Speed: {body.LinearVelocity.Length}\nLinear: {body.LinearVelocity.X:0.00}, {body.LinearVelocity.Y:0.00}\nAngular:{body.AngularVelocity}";
+        }
+    }
+}

Robust.Client/GameObjects/IClientEntityManager.cs

@@ -3,10 +3,8 @@ using Robust.Shared.GameObjects;
 
 namespace Robust.Client.GameObjects
 {
-    public interface IClientEntityManager : IEntityManager
+    public interface IClientEntityManager : IEntityManager, IEntityNetworkManager
     {
-        /// <returns>The list of new entities created.</returns>
-        List<EntityUid> ApplyEntityStates(EntityState[]? curEntStates, IEnumerable<EntityUid>? deletions,
-            EntityState[]? nextEntStates);
+
     }
 }

Robust.Client/GameObjects/IClientEntityManagerInternal.cs

@@ -0,0 +1,15 @@
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects
+{
+    internal interface IClientEntityManagerInternal : IClientEntityManager
+    {
+        // These methods are used by the Game State Manager.
+
+        IEntity CreateEntity(string? prototypeName, EntityUid? uid = null);
+
+        void InitializeEntity(IEntity entity);
+
+        void StartEntity(IEntity entity);
+    }
+}

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -1,13 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 using Robust.Client.GameObjects;
 using Robust.Client.Input;
+using Robust.Client.Map;
 using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Network.Messages;
 using Robust.Client.Player;
+using Robust.Client.Timing;
 using Robust.Shared;
 using Robust.Shared.Configuration;
+using Robust.Shared.Exceptions;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Log;
@@ -26,20 +31,25 @@ namespace Robust.Client.GameStates
         private uint _nextInputCmdSeq = 1;
         private readonly Queue<FullInputCmdMessage> _pendingInputs = new();
 
-        private readonly Queue<(uint sequence, GameTick sourceTick, EntitySystemMessage msg, object sessionMsg)>
+        private readonly Queue<(uint sequence, GameTick sourceTick, EntityEventArgs msg, object sessionMsg)>
             _pendingSystemMessages
                 = new();
 
-        [Dependency] private readonly IClientEntityManager _entities = default!;
+        [Dependency] private readonly IComponentFactory _compFactory = default!;
+        [Dependency] private readonly IClientEntityManagerInternal _entities = default!;
+        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly IPlayerManager _players = default!;
         [Dependency] private readonly IClientNetManager _network = default!;
         [Dependency] private readonly IBaseClient _client = default!;
-        [Dependency] private readonly IMapManager _mapManager = default!;
-        [Dependency] private readonly IGameTiming _timing = default!;
+        [Dependency] private readonly IClientMapManager _mapManager = default!;
+        [Dependency] private readonly IClientGameTiming _timing = default!;
         [Dependency] private readonly INetConfigurationManager _config = default!;
         [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
         [Dependency] private readonly IComponentManager _componentManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
+#if EXCEPTION_TOLERANCE
+        [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
+#endif
 
         /// <inheritdoc />
         public int MinBufferSize => _processor.MinBufferSize;
@@ -125,7 +135,7 @@ namespace Robust.Client.GameStates
             _nextInputCmdSeq++;
         }
 
-        public uint SystemMessageDispatched<T>(T message) where T : EntitySystemMessage
+        public uint SystemMessageDispatched<T>(T message) where T : EntityEventArgs
         {
             if (!Predicting)
             {
@@ -241,65 +251,69 @@ namespace Robust.Client.GameStates
 
             if (!Predicting) return;
 
-            using var _ = _timing.StartPastPredictionArea();
-
-
-            if (_pendingInputs.Count > 0)
+            using(var _ = _timing.StartPastPredictionArea())
             {
-                Logger.DebugS(CVars.NetPredict.Name,  "CL> Predicted:");
+                if (_pendingInputs.Count > 0)
+                {
+                    Logger.DebugS(CVars.NetPredict.Name,  "CL> Predicted:");
+                }
+
+                var pendingInputEnumerator = _pendingInputs.GetEnumerator();
+                var pendingMessagesEnumerator = _pendingSystemMessages.GetEnumerator();
+                var hasPendingInput = pendingInputEnumerator.MoveNext();
+                var hasPendingMessage = pendingMessagesEnumerator.MoveNext();
+
+                var ping = _network.ServerChannel!.Ping / 1000f + PredictLagBias; // seconds.
+                var targetTick = _timing.CurTick.Value + _processor.TargetBufferSize +
+                                 (int) Math.Ceiling(_timing.TickRate * ping) + PredictTickBias;
+
+                // Logger.DebugS("net.predict", $"Predicting from {_lastProcessedTick} to {targetTick}");
+
+                for (var t = _lastProcessedTick.Value + 1; t <= targetTick; t++)
+                {
+                    var tick = new GameTick(t);
+                    _timing.CurTick = tick;
+
+                    while (hasPendingInput && pendingInputEnumerator.Current.Tick <= tick)
+                    {
+                        var inputCmd = pendingInputEnumerator.Current;
+
+                        _inputManager.NetworkBindMap.TryGetKeyFunction(inputCmd.InputFunctionId, out var boundFunc);
+
+                        Logger.DebugS(CVars.NetPredict.Name,
+                            $"    seq={inputCmd.InputSequence}, sub={inputCmd.SubTick}, dTick={tick}, func={boundFunc.FunctionName}, " +
+                            $"state={inputCmd.State}");
+
+
+                        input.PredictInputCommand(inputCmd);
+
+                        hasPendingInput = pendingInputEnumerator.MoveNext();
+                    }
+
+                    while (hasPendingMessage && pendingMessagesEnumerator.Current.sourceTick <= tick)
+                    {
+                        var msg = pendingMessagesEnumerator.Current.msg;
+
+                        _entities.EventBus.RaiseEvent(EventSource.Local, msg);
+                        _entities.EventBus.RaiseEvent(EventSource.Local, pendingMessagesEnumerator.Current.sessionMsg);
+
+                        hasPendingMessage = pendingMessagesEnumerator.MoveNext();
+                    }
+
+                    if (t != targetTick)
+                    {
+                        // Don't run EntitySystemManager.TickUpdate if this is the target tick,
+                        // because the rest of the main loop will call into it with the target tick later,
+                        // and it won't be a past prediction.
+                        _entitySystemManager.TickUpdate((float) _timing.TickPeriod.TotalSeconds);
+                        ((IBroadcastEventBusInternal) _entities.EventBus).ProcessEventQueue();
+                    }
+                }
             }
 
-            var pendingInputEnumerator = _pendingInputs.GetEnumerator();
-            var pendingMessagesEnumerator = _pendingSystemMessages.GetEnumerator();
-            var hasPendingInput = pendingInputEnumerator.MoveNext();
-            var hasPendingMessage = pendingMessagesEnumerator.MoveNext();
+            _entities.TickUpdate((float) _timing.TickPeriod.TotalSeconds);
 
-            var ping = _network.ServerChannel!.Ping / 1000f + PredictLagBias; // seconds.
-            var targetTick = _timing.CurTick.Value + _processor.TargetBufferSize +
-                             (int) Math.Ceiling(_timing.TickRate * ping) + PredictTickBias;
-
-            // Logger.DebugS("net.predict", $"Predicting from {_lastProcessedTick} to {targetTick}");
-
-            for (var t = _lastProcessedTick.Value + 1; t <= targetTick; t++)
-            {
-                var tick = new GameTick(t);
-                _timing.CurTick = tick;
-
-                while (hasPendingInput && pendingInputEnumerator.Current.Tick <= tick)
-                {
-                    var inputCmd = pendingInputEnumerator.Current;
-
-                    _inputManager.NetworkBindMap.TryGetKeyFunction(inputCmd.InputFunctionId, out var boundFunc);
-
-                    Logger.DebugS(CVars.NetPredict.Name,
-                        $"    seq={inputCmd.InputSequence}, sub={inputCmd.SubTick}, dTick={tick}, func={boundFunc.FunctionName}, " +
-                        $"state={inputCmd.State}");
-
-
-                    input.PredictInputCommand(inputCmd);
-
-                    hasPendingInput = pendingInputEnumerator.MoveNext();
-                }
-
-                while (hasPendingMessage && pendingMessagesEnumerator.Current.sourceTick <= tick)
-                {
-                    var msg = pendingMessagesEnumerator.Current.msg;
-
-                    _entities.EventBus.RaiseEvent(EventSource.Local, msg);
-                    _entities.EventBus.RaiseEvent(EventSource.Local, pendingMessagesEnumerator.Current.sessionMsg);
-
-                    hasPendingMessage = pendingMessagesEnumerator.MoveNext();
-                }
-
-                if (t != targetTick)
-                {
-                    // Don't run EntitySystemManager.Update if this is the target tick,
-                    // because the rest of the main loop will call into it with the target tick later,
-                    // and it won't be a past prediction.
-                    _entitySystemManager.Update((float) _timing.TickPeriod.TotalSeconds);
-                    ((IEntityEventBus) _entities.EventBus).ProcessEventQueue();
-                }
-            }
+            _lookup.Update();
         }
 
         private void ResetPredictedEntities(GameTick curTick)
@@ -352,7 +366,10 @@ namespace Robust.Client.GameStates
 
                 foreach (var component in _componentManager.GetNetComponents(createdEntity))
                 {
-                    var state = component.GetComponentState();
+                    Debug.Assert(_players.LocalPlayer != null, "_players.LocalPlayer != null");
+
+                    var player = _players.LocalPlayer.Session;
+                    var state = component.GetComponentState(player);
 
                     if (state.GetType() == typeof(ComponentState))
                     {
@@ -377,7 +394,7 @@ namespace Robust.Client.GameStates
         {
             _config.TickProcessMessages();
             _mapManager.ApplyGameStatePre(curState.MapData);
-            var createdEntities = _entities.ApplyEntityStates(curState.EntityStates, curState.EntityDeletions,
+            var createdEntities = ApplyEntityStates(curState.EntityStates, curState.EntityDeletions,
                 nextState?.EntityStates);
             _players.ApplyPlayerStates(curState.PlayerStates);
             _mapManager.ApplyGameStatePost(curState.MapData);
@@ -385,6 +402,218 @@ namespace Robust.Client.GameStates
             GameStateApplied?.Invoke(new GameStateAppliedArgs(curState));
             return createdEntities;
         }
+
+        private List<EntityUid> ApplyEntityStates(EntityState[]? curEntStates, IEnumerable<EntityUid>? deletions,
+            EntityState[]? nextEntStates)
+        {
+            var toApply = new Dictionary<IEntity, (EntityState?, EntityState?)>();
+            var toInitialize = new List<Entity>();
+            var created = new List<EntityUid>();
+            deletions ??= new EntityUid[0];
+
+            if (curEntStates != null && curEntStates.Length != 0)
+            {
+                foreach (var es in curEntStates)
+                {
+                    //Known entities
+                    if (_entities.TryGetEntity(es.Uid, out var entity))
+                    {
+                        toApply.Add(entity, (es, null));
+                    }
+                    else //Unknown entities
+                    {
+                        var metaState = (MetaDataComponentState?) es.ComponentStates
+                            ?.FirstOrDefault(c => c.NetID == NetIDs.META_DATA);
+                        if (metaState == null)
+                        {
+                            throw new InvalidOperationException($"Server sent new entity state for {es.Uid} without metadata component!");
+                        }
+                        var newEntity = (Entity)_entities.CreateEntity(metaState.PrototypeId, es.Uid);
+                        toApply.Add(newEntity, (es, null));
+                        toInitialize.Add(newEntity);
+                        created.Add(newEntity.Uid);
+                    }
+                }
+            }
+
+            if (nextEntStates != null && nextEntStates.Length != 0)
+            {
+                foreach (var es in nextEntStates)
+                {
+                    if (_entities.TryGetEntity(es.Uid, out var entity))
+                    {
+                        if (toApply.TryGetValue(entity, out var state))
+                        {
+                            toApply[entity] = (state.Item1, es);
+                        }
+                        else
+                        {
+                            toApply[entity] = (null, es);
+                        }
+                    }
+                }
+            }
+
+            // Make sure this is done after all entities have been instantiated.
+            foreach (var kvStates in toApply)
+            {
+                var ent = kvStates.Key;
+                var entity = (Entity) ent;
+                HandleEntityState(entity.EntityManager.ComponentManager, entity, kvStates.Value.Item1,
+                    kvStates.Value.Item2);
+            }
+
+            foreach (var id in deletions)
+            {
+                _entities.DeleteEntity(id);
+            }
+
+#if EXCEPTION_TOLERANCE
+            HashSet<Entity> brokenEnts = new HashSet<Entity>();
+#endif
+
+            foreach (var entity in toInitialize)
+            {
+#if EXCEPTION_TOLERANCE
+                try
+                {
+#endif
+                    _entities.InitializeEntity(entity);
+#if EXCEPTION_TOLERANCE
+                }
+                catch (Exception e)
+                {
+                    Logger.ErrorS("state", $"Server entity threw in Init: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
+                    brokenEnts.Add(entity);
+                }
+#endif
+            }
+
+            foreach (var entity in toInitialize)
+            {
+#if EXCEPTION_TOLERANCE
+                if (brokenEnts.Contains(entity))
+                    continue;
+
+                try
+                {
+#endif
+                    _entities.StartEntity(entity);
+#if EXCEPTION_TOLERANCE
+                }
+                catch (Exception e)
+                {
+                    Logger.ErrorS("state", $"Server entity threw in Start: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
+                    brokenEnts.Add(entity);
+                }
+#endif
+            }
+
+            foreach (var entity in toInitialize)
+            {
+#if EXCEPTION_TOLERANCE
+                if (brokenEnts.Contains(entity))
+                    continue;
+#endif
+            }
+#if EXCEPTION_TOLERANCE
+            foreach (var entity in brokenEnts)
+            {
+                entity.Delete();
+            }
+#endif
+
+            return created;
+        }
+
+        private void HandleEntityState(IComponentManager compMan, IEntity entity, EntityState? curState,
+            EntityState? nextState)
+        {
+            var compStateWork = new Dictionary<uint, (ComponentState? curState, ComponentState? nextState)>();
+            var entityUid = entity.Uid;
+
+            if (curState?.ComponentChanges != null)
+            {
+                foreach (var compChange in curState.ComponentChanges)
+                {
+                    if (compChange.Deleted)
+                    {
+                        if (compMan.TryGetComponent(entityUid, compChange.NetID, out var comp))
+                        {
+                            compMan.RemoveComponent(entityUid, comp);
+                        }
+                    }
+                    else
+                    {
+                        if (compMan.HasComponent(entityUid, compChange.NetID))
+                            continue;
+
+                        var newComp = (Component) _compFactory.GetComponent(compChange.ComponentName!);
+                        newComp.Owner = entity;
+                        compMan.AddComponent(entity, newComp, true);
+                    }
+                }
+            }
+
+            if (curState?.ComponentStates != null)
+            {
+                foreach (var compState in curState.ComponentStates)
+                {
+                    compStateWork[compState.NetID] = (compState, null);
+                }
+            }
+
+            if (nextState?.ComponentStates != null)
+            {
+                foreach (var compState in nextState.ComponentStates)
+                {
+                    if (compStateWork.TryGetValue(compState.NetID, out var state))
+                    {
+                        compStateWork[compState.NetID] = (state.curState, compState);
+                    }
+                    else
+                    {
+                        compStateWork[compState.NetID] = (null, compState);
+                    }
+                }
+            }
+
+            foreach (var (netId, (cur, next)) in compStateWork)
+            {
+                if (compMan.TryGetComponent(entityUid, netId, out var component))
+                {
+                    try
+                    {
+                        component.HandleComponentState(cur, next);
+                    }
+                    catch (Exception e)
+                    {
+                        var wrapper = new ComponentStateApplyException(
+                            $"Failed to apply comp state: entity={component.Owner}, comp={component.Name}", e);
+#if EXCEPTION_TOLERANCE
+                    _runtimeLog.LogException(wrapper, "Component state apply");
+#else
+                        throw wrapper;
+#endif
+                    }
+                }
+                else
+                {
+                    // The component can be null here due to interp.
+                    // Because the NEXT state will have a new component, but this one doesn't yet.
+                    // That's fine though.
+                    if (cur == null)
+                    {
+                        continue;
+                    }
+
+                    var eUid = entityUid;
+                    var eRegisteredNetUidName = _compFactory.GetRegistration(netId).Name;
+                    DebugTools.Assert(
+                        $"Component does not exist for state: entUid={eUid}, expectedNetId={netId}, expectedName={eRegisteredNetUidName}");
+                }
+            }
+        }
     }
 
     public class GameStateAppliedArgs : EventArgs

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -70,6 +70,6 @@ namespace Robust.Client.GameStates
         /// <param name="message">Message being dispatched.</param>
         void InputCommandDispatched(FullInputCmdMessage message);
 
-        uint SystemMessageDispatched<T>(T message) where T : EntitySystemMessage;
+        uint SystemMessageDispatched<T>(T message) where T : EntityEventArgs;
     }
 }

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -1,13 +1,16 @@
 using System.Collections.Generic;
 using Robust.Client.Graphics;
+using Robust.Client.Player;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Configuration;
 using Robust.Shared.Console;
+using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.GameStates
 {
@@ -27,13 +30,13 @@ namespace Robust.Client.GameStates
         private const int TrafficHistorySize = 64; // Size of the traffic history bar in game ticks.
 
         /// <inheritdoc />
-        public override OverlaySpace Space => OverlaySpace.ScreenSpace;
-        
+        public override OverlaySpace Space => OverlaySpace.ScreenSpace | OverlaySpace.WorldSpace;
+
         private readonly Font _font;
         private readonly int _lineHeight;
         private readonly List<NetEntity> _netEnts = new();
 
-        public NetEntityOverlay() : base(nameof(NetEntityOverlay))
+        public NetEntityOverlay()
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
@@ -42,12 +45,12 @@ namespace Robust.Client.GameStates
 
             _gameStateManager.GameStateApplied += HandleGameStateApplied;
         }
-        
+
         private void HandleGameStateApplied(GameStateAppliedArgs args)
         {
             if(_gameTiming.InPrediction) // we only care about real server states.
                 return;
-            
+
             // Shift traffic history down one
             for (var i = 0; i < _netEnts.Count; i++)
             {
@@ -74,7 +77,7 @@ namespace Robust.Client.GameStates
 
                         if (netEnt.Id != entityState.Uid)
                             continue;
-                    
+
                         //TODO: calculate size of state and record it here.
                         netEnt.Traffic[^1] = 1;
                         netEnt.LastUpdate = gameState.ToSequence;
@@ -94,15 +97,15 @@ namespace Robust.Client.GameStates
             }
 
             bool pvsEnabled = _configurationManager.GetCVar<bool>("net.pvs");
-            float pvsSize = _configurationManager.GetCVar<float>("net.maxupdaterange");
+            float pvsRange = _configurationManager.GetCVar<float>("net.maxupdaterange");
             var pvsCenter = _eyeManager.CurrentEye.Position;
-            Box2 pvsBox = Box2.CenteredAround(pvsCenter.Position, new Vector2(pvsSize*2, pvsSize*2));
+            Box2 pvsBox = Box2.CenteredAround(pvsCenter.Position, new Vector2(pvsRange*2, pvsRange*2));
 
             int timeout = _gameTiming.TickRate * 3;
             for (int i = 0; i < _netEnts.Count; i++)
             {
                 var netEnt = _netEnts[i];
-                
+
                 if(_entityManager.EntityExists(netEnt.Id))
                 {
                     //TODO: Whoever is working on PVS remake, change the InPVS detection.
@@ -123,22 +126,58 @@ namespace Robust.Client.GameStates
                 _netEnts[i] = netEnt; // copy struct back
             }
         }
-        
-        protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+
+        protected internal override void Draw(in OverlayDrawArgs args)
         {
             if (!_netManager.IsConnected)
                 return;
 
+            switch (args.Space)
+            {
+                case OverlaySpace.ScreenSpace:
+                    DrawScreen(args);
+                    break;
+                case OverlaySpace.WorldSpace:
+                    DrawWorld(args);
+                    break;
+            }
+        }
+
+        private void DrawWorld(in OverlayDrawArgs args)
+        {
+            bool pvsEnabled = _configurationManager.GetCVar<bool>("net.pvs");
+
+            if(!pvsEnabled)
+                return;
+
+            float pvsSize = _configurationManager.GetCVar<float>("net.maxupdaterange");
+            var pvsCenter = _eyeManager.CurrentEye.Position;
+            Box2 pvsBox = Box2.CenteredAround(pvsCenter.Position, new Vector2(pvsSize, pvsSize));
+
+            var worldHandle = args.WorldHandle;
+
+            worldHandle.DrawRect(pvsBox, Color.Red, false);
+        }
+
+        private void DrawScreen(in OverlayDrawArgs args)
+        {
             // remember, 0,0 is top left of ui with +X right and +Y down
-            var screenHandle = (DrawingHandleScreen)handle;
-            
+            var screenHandle = args.ScreenHandle;
+
             for (int i = 0; i < _netEnts.Count; i++)
             {
                 var netEnt = _netEnts[i];
 
+                if (!_entityManager.TryGetEntity(netEnt.Id, out var ent))
+                {
+                    _netEnts.RemoveSwap(i);
+                    i--;
+                    continue;
+                }
+
                 var xPos = 100;
                 var yPos = 10 + _lineHeight * i;
-                var name = $"({netEnt.Id}) {_entityManager.GetEntity(netEnt.Id).Prototype?.ID}";
+                var name = $"({netEnt.Id}) {ent.Prototype?.ID}";
                 var color = CalcTextColor(ref netEnt);
                 DrawString(screenHandle, _font, new Vector2(xPos + (TrafficHistorySize + 4), yPos), name, color);
                 DrawTrafficBox(screenHandle, ref netEnt, xPos, yPos);
@@ -179,20 +218,19 @@ namespace Robust.Client.GameStates
             return Color.Green; // Entity in PVS, but not updated recently.
         }
 
-        protected override void Dispose(bool disposing)
+        protected override void DisposeBehavior()
         {
             _gameStateManager.GameStateApplied -= HandleGameStateApplied;
-
-            base.Dispose(disposing);
+            base.DisposeBehavior();
         }
 
         private static void DrawString(DrawingHandleScreen handle, Font font, Vector2 pos, string str, Color textColor)
         {
             var baseLine = new Vector2(pos.X, font.GetAscent(1) + pos.Y);
 
-            foreach (var chr in str)
+            foreach (var rune in str.EnumerateRunes())
             {
-                var advance = font.DrawChar(handle, chr, baseLine, 1, textColor);
+                var advance = font.DrawChar(handle, rune, baseLine, 1, textColor);
                 baseLine += new Vector2(advance, 0);
             }
         }
@@ -225,7 +263,7 @@ namespace Robust.Client.GameStates
             {
                 if (args.Length != 1)
                 {
-                    shell.WriteError("Invalid argument amount. Expected 2 arguments.");
+                    shell.WriteError("Invalid argument amount. Expected 1 arguments.");
                     return;
                 }
 
@@ -238,14 +276,14 @@ namespace Robust.Client.GameStates
                 var bValue = iValue > 0;
                 var overlayMan = IoCManager.Resolve<IOverlayManager>();
 
-                if(bValue && !overlayMan.HasOverlay(nameof(NetEntityOverlay)))
+                if(bValue && !overlayMan.HasOverlay(typeof(NetEntityOverlay)))
                 {
                     overlayMan.AddOverlay(new NetEntityOverlay());
                     shell.WriteLine("Enabled network entity report overlay.");
                 }
-                else if(!bValue && overlayMan.HasOverlay(nameof(NetEntityOverlay)))
+                else if(!bValue && overlayMan.HasOverlay(typeof(NetEntityOverlay)))
                 {
-                    overlayMan.RemoveOverlay(nameof(NetEntityOverlay));
+                    overlayMan.RemoveOverlay(typeof(NetEntityOverlay));
                     shell.WriteLine("Disabled network entity report overlay.");
                 }
             }

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -1,7 +1,11 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Text;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
 using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
@@ -34,7 +38,11 @@ namespace Robust.Client.GameStates
 
         private readonly List<(GameTick Tick, int Payload, int lag, int interp)> _history = new(HistorySize+10);
 
-        public NetGraphOverlay() : base(nameof(NetGraphOverlay))
+        private int _totalHistoryPayload; // sum of all data point sizes in bytes
+
+        public EntityUid WatchEntId { get; set; }
+
+        public NetGraphOverlay()
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
@@ -58,7 +66,73 @@ namespace Robust.Client.GameStates
             // calc interp info
             var interpBuff = _gameStateManager.CurrentBufferSize - _gameStateManager.MinBufferSize;
 
+            _totalHistoryPayload += sz;
             _history.Add((toSeq, sz, lag, interpBuff));
+
+            // not watching an ent
+            if(!WatchEntId.IsValid() || WatchEntId.IsClientSide())
+                return;
+
+            string? entStateString = null;
+            string? entDelString = null;
+            var conShell = IoCManager.Resolve<IConsoleHost>().LocalShell;
+
+            var entStates = args.AppliedState.EntityStates;
+            if (entStates is not null)
+            {
+                var sb = new StringBuilder();
+                foreach (var entState in entStates)
+                {
+                    if (entState.Uid == WatchEntId)
+                    {
+                        if(entState.ComponentChanges is not null)
+                        {
+                            sb.Append($"\n  Changes:");
+                            foreach (var compChange in entState.ComponentChanges)
+                            {
+                                var del = compChange.Deleted ? 'D' : 'C';
+                                sb.Append($"\n    [{del}]{compChange.NetID}:{compChange.ComponentName}");
+                            }
+                        }
+
+                        if (entState.ComponentStates is not null)
+                        {
+                            sb.Append($"\n  States:");
+                            foreach (var compState in entState.ComponentStates)
+                            {
+                                sb.Append($"\n    {compState.NetID}:{compState.GetType().Name}");
+                            }
+                        }
+                    }
+                }
+                entStateString = sb.ToString();
+            }
+
+            var entDeletes = args.AppliedState.EntityDeletions;
+            if (entDeletes is not null)
+            {
+                var sb = new StringBuilder();
+                foreach (var entDelete in entDeletes)
+                {
+                    if (entDelete == WatchEntId)
+                    {
+                        entDelString = "\n  Deleted";
+                    }
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(entStateString) || !string.IsNullOrWhiteSpace(entDelString))
+            {
+                var fullString = $"watchEnt: from={args.AppliedState.FromSequence}, to={args.AppliedState.ToSequence}, eid={WatchEntId}";
+                if (!string.IsNullOrWhiteSpace(entStateString))
+                    fullString += entStateString;
+
+                if (!string.IsNullOrWhiteSpace(entDelString))
+                    fullString += entDelString;
+
+                conShell.WriteLine(fullString + "\n");
+            }
+
         }
 
         /// <inheritdoc />
@@ -67,19 +141,27 @@ namespace Robust.Client.GameStates
             base.FrameUpdate(args);
 
             var over = _history.Count - HistorySize;
-            if (over > 0)
+            if (over <= 0)
+                return;
+
+            for (int i = 0; i < over; i++)
             {
-                _history.RemoveRange(0, over);
+                var point = _history[i];
+                _totalHistoryPayload -= point.Payload;
             }
+
+            _history.RemoveRange(0, over);
         }
 
-        protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+        protected internal override void Draw(in OverlayDrawArgs args)
         {
             // remember, 0,0 is top left of ui with +X right and +Y down
 
             var leftMargin = 300;
             var width = HistorySize;
             var height = 500;
+            var drawSizeThreshold = Math.Min(_totalHistoryPayload / HistorySize, 300);
+            var handle = args.ScreenHandle;
 
             // bottom payload line
             handle.DrawLine(new Vector2(leftMargin, height), new Vector2(leftMargin + width, height), Color.DarkGray.WithAlpha(0.8f));
@@ -99,6 +181,12 @@ namespace Robust.Client.GameStates
                 var yoff = height - state.Payload / BytesPerPixel;
                 handle.DrawLine(new Vector2(xOff, height), new Vector2(xOff, yoff), Color.LightGreen.WithAlpha(0.8f));
 
+                // Draw size if above average
+                if (drawSizeThreshold * 1.5 < state.Payload)
+                {
+                    DrawString(handle, _font, new Vector2(xOff, yoff - _font.GetLineHeight(1)), state.Payload.ToString());
+                }
+
                 // second tick marks
                 if (state.Tick.Value % _gameTiming.TickRate == 0)
                 {
@@ -123,6 +211,10 @@ namespace Robust.Client.GameStates
                 handle.DrawLine(new Vector2(xOff, height + LowerGraphOffset), new Vector2(xOff, height + LowerGraphOffset + state.interp * 6), interpColor.WithAlpha(0.8f));
             }
 
+            // average payload line
+            var avgyoff = height - drawSizeThreshold / BytesPerPixel;
+            handle.DrawLine(new Vector2(leftMargin, avgyoff), new Vector2(leftMargin + width, avgyoff), Color.DarkGray.WithAlpha(0.8f));
+
             // top payload warning line
             var warnYoff = height - _warningPayloadSize / BytesPerPixel;
             handle.DrawLine(new Vector2(leftMargin, warnYoff), new Vector2(leftMargin + width, warnYoff), Color.DarkGray.WithAlpha(0.8f));
@@ -132,30 +224,30 @@ namespace Robust.Client.GameStates
             handle.DrawLine(new Vector2(leftMargin, midYoff), new Vector2(leftMargin + width, midYoff), Color.DarkGray.WithAlpha(0.8f));
 
             // payload text
-            DrawString((DrawingHandleScreen)handle, _font, new Vector2(leftMargin + width, warnYoff), "56K");
-            DrawString((DrawingHandleScreen)handle, _font, new Vector2(leftMargin + width, midYoff), "33.6K");
+            DrawString(handle, _font, new Vector2(leftMargin + width, warnYoff), "56K");
+            DrawString(handle, _font, new Vector2(leftMargin + width, midYoff), "33.6K");
 
             // interp text info
             if(lastLagY != -1)
-                DrawString((DrawingHandleScreen)handle, _font, new Vector2(leftMargin + width, lastLagY), $"{lastLagMs.ToString()}ms");
+                DrawString(handle, _font, new Vector2(leftMargin + width, lastLagY), $"{lastLagMs.ToString()}ms");
 
-            DrawString((DrawingHandleScreen)handle, _font, new Vector2(leftMargin, height + LowerGraphOffset), $"{_gameStateManager.CurrentBufferSize.ToString()} states");
+            DrawString(handle, _font, new Vector2(leftMargin, height + LowerGraphOffset), $"{_gameStateManager.CurrentBufferSize.ToString()} states");
         }
 
-        protected override void Dispose(bool disposing)
+        protected override void DisposeBehavior()
         {
             _gameStateManager.GameStateApplied -= HandleGameStateApplied;
 
-            base.Dispose(disposing);
+            base.DisposeBehavior();
         }
 
         private void DrawString(DrawingHandleScreen handle, Font font, Vector2 pos, string str)
         {
             var baseLine = new Vector2(pos.X, font.GetAscent(1) + pos.Y);
 
-            foreach (var chr in str)
+            foreach (var rune in str.EnumerateRunes())
             {
-                var advance = font.DrawChar(handle, chr, baseLine, 1, Color.White);
+                var advance = font.DrawChar(handle, rune, baseLine, 1, Color.White);
                 baseLine += new Vector2(advance, 0);
             }
         }
@@ -183,17 +275,48 @@ namespace Robust.Client.GameStates
                 var bValue = iValue > 0;
                 var overlayMan = IoCManager.Resolve<IOverlayManager>();
 
-                if(bValue && !overlayMan.HasOverlay(nameof(NetGraphOverlay)))
+                if(bValue && !overlayMan.HasOverlay(typeof(NetGraphOverlay)))
                 {
                     overlayMan.AddOverlay(new NetGraphOverlay());
                     shell.WriteLine("Enabled network overlay.");
                 }
-                else if(overlayMan.HasOverlay(nameof(NetGraphOverlay)))
+                else if(overlayMan.HasOverlay(typeof(NetGraphOverlay)))
                 {
-                    overlayMan.RemoveOverlay(nameof(NetGraphOverlay));
+                    overlayMan.RemoveOverlay(typeof(NetGraphOverlay));
                     shell.WriteLine("Disabled network overlay.");
                 }
             }
         }
+
+        private class NetWatchEntCommand : IConsoleCommand
+        {
+            public string Command => "net_watchent";
+            public string Help => "net_watchent <0|EntityUid>";
+            public string Description => "Dumps all network updates for an EntityId to the console.";
+
+            public void Execute(IConsoleShell shell, string argStr, string[] args)
+            {
+                if (args.Length != 1)
+                {
+                    shell.WriteError("Invalid argument amount. Expected 1 argument.");
+                    return;
+                }
+
+                if (!EntityUid.TryParse(args[0], out var eValue))
+                {
+                    shell.WriteError("Invalid argument: Needs to be 0 or an entityId.");
+                    return;
+                }
+
+                var overlayMan = IoCManager.Resolve<IOverlayManager>();
+
+                if (overlayMan.HasOverlay(typeof(NetGraphOverlay)))
+                {
+                    var netOverlay = overlayMan.GetOverlay<NetGraphOverlay>();
+
+                    netOverlay.WatchEntId = eValue;
+                }
+            }
+        }
     }
 }

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -1,3 +1,4 @@
+using Robust.Shared.Enums;
 using Robust.Client.Graphics;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
@@ -5,6 +6,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
+using System;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates
@@ -18,18 +20,19 @@ namespace Robust.Client.GameStates
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
         private readonly ShaderInstance _shader;
 
-        public NetInterpOverlay() : base(nameof(NetInterpOverlay))
+        public NetInterpOverlay()
         {
             IoCManager.InjectDependencies(this);
             _shader = _prototypeManager.Index<ShaderPrototype>("unshaded").Instance();
         }
 
-        protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+        protected internal override void Draw(in OverlayDrawArgs args)
         {
+            var handle = args.DrawingHandle;
             handle.UseShader(_shader);
             var worldHandle = (DrawingHandleWorld) handle;
             var viewport = _eyeManager.GetWorldViewport();
-            foreach (var boundingBox in _componentManager.EntityQuery<IPhysicsComponent>(true))
+            foreach (var boundingBox in _componentManager.EntityQuery<IPhysBody>(true))
             {
                 // all entities have a TransformComponent
                 var transform = ((IComponent)boundingBox).Owner.Transform;
@@ -42,7 +45,7 @@ namespace Robust.Client.GameStates
                 if(transform.LerpDestination == null)
                     continue;
 
-                var aabb = ((IPhysBody)boundingBox).AABB;
+                var aabb = boundingBox.GetWorldAABB();
 
                 // if not on screen, or too small, continue
                 if (!aabb.Translated(transform.WorldPosition).Intersects(viewport) || aabb.IsEmpty())
@@ -85,14 +88,14 @@ namespace Robust.Client.GameStates
                 var bValue = iValue > 0;
                 var overlayMan = IoCManager.Resolve<IOverlayManager>();
 
-                if (bValue && !overlayMan.HasOverlay(nameof(NetInterpOverlay)))
+                if (bValue && !overlayMan.HasOverlay<NetInterpOverlay>())
                 {
                     overlayMan.AddOverlay(new NetInterpOverlay());
                     shell.WriteLine("Enabled network interp overlay.");
                 }
-                else if (overlayMan.HasOverlay(nameof(NetInterpOverlay)))
+                else if (overlayMan.HasOverlay<NetInterpOverlay>())
                 {
-                    overlayMan.RemoveOverlay(nameof(NetInterpOverlay));
+                    overlayMan.RemoveOverlay<NetInterpOverlay>();
                     shell.WriteLine("Disabled network interp overlay.");
                 }
             }

Robust.Client/Graphics/AtlasTexture.cs

@@ -1,4 +1,4 @@
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 

Robust.Client/Graphics/ClientEye/Eye.cs

@@ -50,9 +50,9 @@ namespace Robust.Client.Graphics
         }
 
         /// <inheritdoc />
-        public void GetViewMatrix(out Matrix3 viewMatrix)
+        public void GetViewMatrix(out Matrix3 viewMatrix, Vector2 renderScale)
         {
-            var scaleMat = Matrix3.CreateScale(_scale.X, _scale.Y);
+            var scaleMat = Matrix3.CreateScale(_scale.X * renderScale.X, _scale.Y * renderScale.Y);
             var rotMat = Matrix3.CreateRotation(_rotation);
             var transMat = Matrix3.CreateTranslation(-_coords.Position);
 
@@ -60,9 +60,9 @@ namespace Robust.Client.Graphics
         }
 
         /// <inheritdoc />
-        public void GetViewMatrixInv(out Matrix3 viewMatrixInv)
+        public void GetViewMatrixInv(out Matrix3 viewMatrixInv, Vector2 renderScale)
         {
-            GetViewMatrix(out var viewMatrix);
+            GetViewMatrix(out var viewMatrix, renderScale);
             viewMatrixInv = Matrix3.Invert(viewMatrix);
         }
     }

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -1,4 +1,6 @@
-using Robust.Shared.GameObjects;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
@@ -19,6 +21,7 @@ namespace Robust.Client.Graphics
 
         [Dependency] private readonly IClyde _displayManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
 
         // We default to this when we get set to a null eye.
         private readonly FixedEye _defaultEye = new();
@@ -32,11 +35,18 @@ namespace Robust.Client.Graphics
             set => _currentEye = value;
         }
 
+        public IViewportControl MainViewport { get; set; } = default!;
+
         public void ClearCurrentEye()
         {
             _currentEye = _defaultEye;
         }
 
+        void IEyeManager.Initialize()
+        {
+            MainViewport = _uiManager.MainViewport;
+        }
+
         /// <inheritdoc />
         public MapId CurrentMap => CurrentEye.Position.MapId;
 
@@ -49,7 +59,7 @@ namespace Robust.Client.Graphics
             var topRight = ScreenToMap(new Vector2(vpSize.X, 0));
             var bottomRight = ScreenToMap(vpSize);
             var bottomLeft = ScreenToMap(new Vector2(0, vpSize.Y));
-            
+
             var left = MathHelper.Min(topLeft.X, topRight.X, bottomRight.X, bottomLeft.X);
             var bottom = MathHelper.Min(topLeft.Y, topRight.Y, bottomRight.Y, bottomLeft.Y);
             var right = MathHelper.Max(topLeft.X, topRight.X, bottomRight.X, bottomLeft.X);
@@ -61,16 +71,7 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public Vector2 WorldToScreen(Vector2 point)
         {
-            var newPoint = point;
-
-            CurrentEye.GetViewMatrix(out var viewMatrix);
-            newPoint = viewMatrix * newPoint;
-
-            // (inlined version of UiProjMatrix)
-            newPoint *= new Vector2(1, -1) * PixelsPerMeter;
-            newPoint += _displayManager.ScreenSize / 2f;
-
-            return newPoint;
+            return MainViewport.WorldToScreen(point);
         }
 
         /// <inheritdoc />
@@ -115,17 +116,7 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public MapCoordinates ScreenToMap(Vector2 point)
         {
-            var newPoint = point;
-
-            // (inlined version of UiProjMatrix^-1)
-            newPoint -= _displayManager.ScreenSize / 2f;
-            newPoint *= new Vector2(1, -1) / PixelsPerMeter;
-
-            // view matrix
-            CurrentEye.GetViewMatrixInv(out var viewMatrixInv);
-            newPoint = viewMatrixInv * newPoint;
-
-            return new MapCoordinates(newPoint, CurrentMap);
+            return MainViewport.ScreenToMap(point);
         }
     }
 }

Robust.Client/Graphics/ClientEye/IEye.cs

@@ -41,13 +41,15 @@ namespace Robust.Client.Graphics
         /// world space to camera space.
         /// </summary>
         /// <param name="viewMatrix">View matrix for this camera.</param>
-        void GetViewMatrix(out Matrix3 viewMatrix);
+        /// <param name="renderScale"></param>
+        void GetViewMatrix(out Matrix3 viewMatrix, Vector2 renderScale);
 
         /// <summary>
         /// Returns the inverted view matrix for this eye, used to convert a point from
         /// camera space to world space.
         /// </summary>
         /// <param name="viewMatrixInv">Inverted view matrix for this camera.</param>
-        void GetViewMatrixInv(out Matrix3 viewMatrixInv);
+        /// <param name="renderScale"></param>
+        void GetViewMatrixInv(out Matrix3 viewMatrixInv, Vector2 renderScale);
     }
 }

Robust.Client/Graphics/ClientEye/IEyeManager.cs

@@ -1,4 +1,5 @@
-using Robust.Shared.Map;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
 namespace Robust.Client.Graphics
@@ -17,6 +18,8 @@ namespace Robust.Client.Graphics
         /// </remarks>
         IEye CurrentEye { get; set; }
 
+        IViewportControl MainViewport { get; set; }
+
         /// <summary>
         /// The ID of the map on which the current eye is "placed".
         /// </summary>
@@ -72,5 +75,6 @@ namespace Robust.Client.Graphics
         MapCoordinates ScreenToMap(Vector2 point);
 
         void ClearCurrentEye();
+        void Initialize();
     }
 }

Robust.Client/Graphics/Clyde/Audio/Clyde.Audio.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
@@ -36,6 +36,9 @@ namespace Robust.Client.Graphics.Clyde
         private readonly ConcurrentQueue<(int sourceHandle, int filterHandle)> _bufferedSourceDisposeQueue = new();
         private readonly ConcurrentQueue<int> _bufferDisposeQueue = new();
 
+        // The base gain value for a listener, used to boost the default volume.
+        private const float _baseGain = 2f;
+
         public bool HasAlDeviceExtension(string extension) => _alcDeviceExtensions.Contains(extension);
         public bool HasAlContextExtension(string extension) => _alContextExtensions.Contains(extension);
 
@@ -50,7 +53,7 @@ namespace Robust.Client.Graphics.Clyde
 
             IsEfxSupported = HasAlDeviceExtension("ALC_EXT_EFX");
 
-            _configurationManager.OnValueChanged(CVars.AudioMasterVolume, SetMasterVolume, true);
+            ConfigurationManager.OnValueChanged(CVars.AudioMasterVolume, SetMasterVolume, true);
         }
 
         private void _audioCreateContext()
@@ -78,7 +81,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private void _audioOpenDevice()
         {
-            var preferredDevice = _configurationManager.GetCVar(CVars.AudioDevice);
+            var preferredDevice = ConfigurationManager.GetCVar(CVars.AudioDevice);
 
             // Open device.
             if (!string.IsNullOrEmpty(preferredDevice))
@@ -182,7 +185,7 @@ namespace Robust.Client.Graphics.Clyde
 
         public void SetMasterVolume(float newVolume)
         {
-            AL.Listener(ALListenerf.Gain, newVolume);
+            AL.Listener(ALListenerf.Gain, _baseGain * newVolume);
         }
 
         public IClydeAudioSource CreateAudioSource(AudioStream stream)
@@ -479,7 +482,7 @@ namespace Robust.Client.Graphics.Clyde
 
                 var (x, y) = position;
 
-                if (!ValidatePosition(x, y))
+                if (!AreFinite(x, y))
                 {
                     return false;
                 }
@@ -500,7 +503,7 @@ namespace Robust.Client.Graphics.Clyde
                 return true;
             }
 
-            private static bool ValidatePosition(float x, float y)
+            private static bool AreFinite(float x, float y)
             {
                 if (float.IsFinite(x) && float.IsFinite(y))
                 {
@@ -510,6 +513,22 @@ namespace Robust.Client.Graphics.Clyde
                 return false;
             }
 
+            public void SetVelocity(Vector2 velocity)
+            {
+                _checkDisposed();
+
+                var (x, y) = velocity;
+
+                if (!AreFinite(x, y))
+                {
+                    return;
+                }
+
+                AL.Source(SourceHandle, ALSource3f.Velocity, x, y, 0);
+
+                _checkAlError();
+            }
+
             public void SetPitch(float pitch)
             {
                 _checkDisposed();
@@ -664,7 +683,6 @@ namespace Robust.Client.Graphics.Clyde
                 _checkAlError();
             }
 
-
             private void SetOcclusionEfx(float gain, float cutoff)
             {
                 if (FilterHandle == 0)
@@ -691,7 +709,7 @@ namespace Robust.Client.Graphics.Clyde
 
                 var (x, y) = position;
 
-                if (!ValidatePosition(x, y))
+                if (!AreFinite(x, y))
                 {
                     return false;
                 }
@@ -703,7 +721,7 @@ namespace Robust.Client.Graphics.Clyde
                 return true;
             }
 
-            private static bool ValidatePosition(float x, float y)
+            private static bool AreFinite(float x, float y)
             {
                 if (float.IsFinite(x) && float.IsFinite(y))
                 {
@@ -713,6 +731,22 @@ namespace Robust.Client.Graphics.Clyde
                 return false;
             }
 
+            public void SetVelocity(Vector2 velocity)
+            {
+                _checkDisposed();
+
+                var (x, y) = velocity;
+
+                if (!AreFinite(x, y))
+                {
+                    return;
+                }
+
+                AL.Source(SourceHandle!.Value, ALSource3f.Velocity, x, y, 0);
+
+                _checkAlError();
+            }
+
             public void SetPitch(float pitch)
             {
                 _checkDisposed();

Robust.Client/Graphics/Clyde/Clyde.DllMap.cs

@@ -12,7 +12,8 @@ namespace Robust.Client.Graphics.Clyde
         static Clyde()
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) &&
-                RuntimeInformation.ProcessArchitecture == Architecture.X64)
+                RuntimeInformation.ProcessArchitecture == Architecture.X64 &&
+                Environment.GetEnvironmentVariable("ROBUST_INTEGRATED_GPU") != "1")
             {
                 try
                 {

Robust.Client/Graphics/Clyde/Clyde.GLFeatures.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.Log;
@@ -115,7 +115,7 @@ namespace Robust.Client.Graphics.Clyde
 
                 var prev = cap;
                 var cVarName = $"display.ogl_block_{capName}";
-                var block = _configurationManager.GetCVar<bool>(cVarName);
+                var block = ConfigurationManager.GetCVar<bool>(cVarName);
 
                 if (block)
                 {
@@ -146,7 +146,7 @@ namespace Robust.Client.Graphics.Clyde
 
             foreach (var cvar in cvars)
             {
-                _configurationManager.RegisterCVar($"display.ogl_block_{cvar}", false);
+                ConfigurationManager.RegisterCVar($"display.ogl_block_{cvar}", false);
             }
         }
 

Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs

@@ -208,12 +208,12 @@ namespace Robust.Client.Graphics.Clyde
             _setChunkDirty(grid, chunk);
         }
 
-        private void _updateOnGridCreated(GridId gridId)
+        private void _updateOnGridCreated(MapId mapId, GridId gridId)
         {
             _mapChunkData.Add(gridId, new Dictionary<Vector2i, MapChunkData>());
         }
 
-        private void _updateOnGridRemoved(GridId gridId)
+        private void _updateOnGridRemoved(MapId mapId, GridId gridId)
         {
             var data = _mapChunkData[gridId];
             foreach (var chunkDatum in data.Values)

Robust.Client/Graphics/Clyde/Clyde.HLR.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Buffers;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
@@ -7,6 +7,9 @@ using Robust.Client.ResourceManagement;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
+using OpenToolkit.Graphics.OpenGL4;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Enums;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -65,67 +68,136 @@ namespace Robust.Client.Graphics.Clyde
                 return;
             }
 
-            RenderOverlays(OverlaySpace.ScreenSpaceBelowWorld);
-
-            _mainViewport.Eye = _eyeManager.CurrentEye;
-            RenderViewport(_mainViewport);
-
+            foreach (var weak in _viewports.Values)
             {
-                var handle = _renderHandle.DrawingHandleScreen;
-                var tex = _mainViewport.RenderTarget.Texture;
-
-                handle.DrawTexture(tex, (0, 0));
-                FlushRenderQueue();
+                if (weak.TryGetTarget(out var viewport) && viewport.AutomaticRender)
+                    RenderViewport(viewport);
             }
 
-            TakeScreenshot(ScreenshotType.BeforeUI);
-
-            RenderOverlays(OverlaySpace.ScreenSpace);
-
             using (DebugGroup("UI"))
             {
                 _userInterfaceManager.Render(_renderHandle);
                 FlushRenderQueue();
             }
 
-            TakeScreenshot(ScreenshotType.AfterUI);
+            TakeScreenshot(ScreenshotType.Final);
 
             // And finally, swap those buffers!
             SwapBuffers();
         }
 
-        private void RenderOverlays(OverlaySpace space)
+        private void RenderOverlays(Viewport vp, OverlaySpace space, in Box2 worldBox)
         {
             using (DebugGroup($"Overlays: {space}"))
             {
-                var list = new List<Overlay>();
-
-                foreach (var overlay in _overlayManager.AllOverlays)
-                {
-                    if ((overlay.Space & space) != 0)
-                    {
-                        list.Add(overlay);
-                    }
-                }
-
-                list.Sort(OverlayComparer.Instance);
-
+                var list = GetOverlaysForSpace(space);
                 foreach (var overlay in list)
                 {
-                    overlay.ClydeRender(_renderHandle, space);
-                }
+                    if (overlay.RequestScreenTexture)
+                    {
+                        FlushRenderQueue();
+                        UpdateOverlayScreenTexture(space, vp.RenderTarget);
+                    }
 
-                FlushRenderQueue();
+                    if (overlay.OverwriteTargetFrameBuffer())
+                    {
+                        ClearFramebuffer(default);
+                    }
+
+                    overlay.ClydeRender(_renderHandle, space, null, vp, new UIBox2i((0, 0), vp.Size), worldBox);
+                }
             }
         }
 
-        private void DrawEntitiesAndWorldOverlay(Viewport viewport, Box2 worldBounds)
+        private void RenderOverlaysDirect(
+            Viewport vp,
+            IViewportControl vpControl,
+            DrawingHandleBase handle,
+            OverlaySpace space,
+            in UIBox2i bounds)
+        {
+            var list = GetOverlaysForSpace(space);
+
+            var worldBounds = CalcWorldBounds(vp);
+            var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, worldBounds);
+
+            foreach (var overlay in list)
+            {
+                overlay.Draw(args);
+            }
+        }
+
+        private List<Overlay> GetOverlaysForSpace(OverlaySpace space)
+        {
+            var list = new List<Overlay>();
+
+            foreach (var overlay in _overlayManager.AllOverlays)
+            {
+                if ((overlay.Space & space) != 0)
+                {
+                    list.Add(overlay);
+                }
+            }
+
+            list.Sort(OverlayComparer.Instance);
+
+            return list;
+        }
+
+        private ClydeTexture? ScreenBufferTexture;
+        private GLHandle screenBufferHandle;
+        private Vector2 lastFrameSize;
+
+        /// <summary>
+        ///    Sends SCREEN_TEXTURE to all overlays in the given OverlaySpace that request it.
+        /// </summary>
+        private bool UpdateOverlayScreenTexture(OverlaySpace space, RenderTexture texture)
+        {
+            //This currently does NOT consider viewports and just grabs the current screen framebuffer. This will need to be improved upon in the future.
+            List<Overlay> oTargets = new List<Overlay>();
+            foreach (var overlay in _overlayManager.AllOverlays)
+            {
+                if (overlay.RequestScreenTexture && overlay.Space == space)
+                {
+                    oTargets.Add(overlay);
+                }
+            }
+
+            if (oTargets.Count > 0 && ScreenBufferTexture != null)
+            {
+                if (lastFrameSize != _framebufferSize)
+                {
+                    GL.BindTexture(TextureTarget.Texture2D, screenBufferHandle.Handle);
+                    GL.TexImage2D(TextureTarget.Texture2D, 0,
+                        _hasGLSrgb ? PixelInternalFormat.Srgb8Alpha8 : PixelInternalFormat.Rgba8, _framebufferSize.X,
+                        _framebufferSize.Y, 0,
+                        PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
+                }
+
+                lastFrameSize = _framebufferSize;
+                CopyRenderTextureToTexture(texture, ScreenBufferTexture);
+                foreach (Overlay overlay in oTargets)
+                {
+                    overlay.ScreenTexture = ScreenBufferTexture;
+                }
+
+                oTargets.Clear();
+                return true;
+            }
+
+            return false;
+        }
+
+
+        private void DrawEntities(Viewport viewport, Box2 worldBounds)
         {
             if (_eyeManager.CurrentMap == MapId.Nullspace || !_mapManager.HasMapEntity(_eyeManager.CurrentMap))
             {
                 return;
             }
 
+            RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowEntities, worldBounds);
+
             var screenSize = viewport.Size;
 
             // So we could calculate the correct size of the entities based on the contents of their sprite...
@@ -175,7 +247,13 @@ namespace Robust.Client.Graphics.Clyde
                             flushed = true;
                         }
 
-                        overlay.ClydeRender(_renderHandle, OverlaySpace.WorldSpace);
+                        overlay.ClydeRender(
+                            _renderHandle,
+                            OverlaySpace.WorldSpace,
+                            null,
+                            viewport,
+                            new UIBox2i((0, 0), viewport.Size),
+                            worldBounds);
                         overlayIndex = j;
                         continue;
                     }
@@ -183,25 +261,61 @@ namespace Robust.Client.Graphics.Clyde
                     break;
                 }
 
+
+                RenderTexture? entityPostRenderTarget = null;
                 Vector2i roundedPos = default;
                 if (entry.sprite.PostShader != null)
                 {
-                    _renderHandle.UseRenderTarget(EntityPostRenderTarget);
-                    _renderHandle.Clear(new Color());
-                    // Calculate viewport so that the entity thinks it's drawing to the same position,
-                    // which is necessary for light application,
-                    // but it's ACTUALLY drawing into the center of the render target.
-                    var spritePos = entry.sprite.Owner.Transform.WorldPosition;
-                    var screenPos = _eyeManager.WorldToScreen(spritePos);
-                    var (roundedX, roundedY) = roundedPos = (Vector2i) screenPos;
-                    var flippedPos = new Vector2i(roundedX, screenSize.Y - roundedY);
-                    flippedPos -= EntityPostRenderTarget.Size / 2;
-                    _renderHandle.Viewport(Box2i.FromDimensions(-flippedPos, screenSize));
+                    // calculate world bounding box
+                    var spriteBB = entry.sprite.CalculateBoundingBox();
+                    var spriteLB = spriteBB.BottomLeft;
+                    var spriteRT = spriteBB.TopRight;
+
+                    // finally we can calculate screen bounding in pixels
+                    var screenLB = viewport.WorldToLocal(spriteLB);
+                    var screenRT = viewport.WorldToLocal(spriteRT);
+
+                    // we need to scale RT a for effects like emission or highlight
+                    // scale can be passed with PostShader as variable in future
+                    var postShadeScale = 1.25f;
+                    var screenSpriteSize = (Vector2i) ((screenRT - screenLB) * postShadeScale).Rounded();
+                    screenSpriteSize.Y = -screenSpriteSize.Y;
+
+                    // I'm not 100% sure why it works, but without it post-shader
+                    // can be lower or upper by 1px than original sprite depending on sprite rotation or scale
+                    // probably some rotation rounding error
+                    if (screenSpriteSize.X % 2 != 0)
+                        screenSpriteSize.X++;
+                    if (screenSpriteSize.Y % 2 != 0)
+                        screenSpriteSize.Y++;
+
+                    // check that sprite size is valid
+                    if (screenSpriteSize.X > 0 && screenSpriteSize.Y > 0)
+                    {
+                        // create new render texture with correct sprite size
+                        entityPostRenderTarget = CreateRenderTarget(screenSpriteSize,
+                            new RenderTargetFormatParameters(RenderTargetColorFormat.Rgba8Srgb, true),
+                            name: nameof(entityPostRenderTarget));
+                        _renderHandle.UseRenderTarget(entityPostRenderTarget);
+                        _renderHandle.Clear(new Color());
+
+                        // Calculate viewport so that the entity thinks it's drawing to the same position,
+                        // which is necessary for light application,
+                        // but it's ACTUALLY drawing into the center of the render target.
+                        var spritePos = spriteBB.Center;
+                        var screenPos = viewport.WorldToLocal(spritePos);
+                        var (roundedX, roundedY) = roundedPos = (Vector2i) screenPos;
+                        var flippedPos = new Vector2i(roundedX, screenSize.Y - roundedY);
+                        flippedPos -= entityPostRenderTarget.Size / 2;
+                        _renderHandle.Viewport(Box2i.FromDimensions(-flippedPos, screenSize));
+                    }
                 }
 
-                entry.sprite.Render(_renderHandle.DrawingHandleWorld, entry.worldMatrix, entry.worldRotation);
+                var matrix = entry.worldMatrix;
+                var worldPosition = new Vector2(matrix.R0C2, matrix.R1C2);
+                entry.sprite.Render(_renderHandle.DrawingHandleWorld, in entry.worldRotation, in worldPosition);
 
-                if (entry.sprite.PostShader != null)
+                if (entry.sprite.PostShader != null && entityPostRenderTarget != null)
                 {
                     var oldProj = _currentMatrixProj;
                     var oldView = _currentMatrixView;
@@ -214,11 +328,11 @@ namespace Robust.Client.Graphics.Clyde
                     _renderHandle.SetProjView(proj, view);
                     _renderHandle.SetModelTransform(Matrix3.Identity);
 
-                    var rounded = roundedPos - EntityPostRenderTarget.Size / 2;
+                    var rounded = roundedPos - entityPostRenderTarget.Size / 2;
 
-                    var box = Box2i.FromDimensions(rounded, EntityPostRenderTarget.Size);
+                    var box = Box2i.FromDimensions(rounded, entityPostRenderTarget.Size);
 
-                    _renderHandle.DrawTextureScreen(EntityPostRenderTarget.Texture,
+                    _renderHandle.DrawTextureScreen(entityPostRenderTarget.Texture,
                         box.BottomLeft, box.BottomRight, box.TopLeft, box.TopRight,
                         Color.White, null);
 
@@ -231,14 +345,6 @@ namespace Robust.Client.Graphics.Clyde
 
             _drawingSpriteList.Clear();
             FlushRenderQueue();
-
-            // Cleanup remainders
-            foreach (var overlay in worldOverlays)
-            {
-                overlay.ClydeRender(_renderHandle, OverlaySpace.WorldSpace);
-            }
-
-            FlushRenderQueue();
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
@@ -247,29 +353,44 @@ namespace Robust.Client.Graphics.Clyde
         {
             var spriteSystem = _entitySystemManager.GetEntitySystem<RenderingTreeSystem>();
 
-            var tree = spriteSystem.GetSpriteTreeForMap(map);
-
-            tree.QueryAabb(ref list, ((
-                ref RefList<(SpriteComponent sprite, Matrix3 matrix, Angle worldRot, float yWorldPos)> state,
-                in SpriteComponent value) =>
+            foreach (var gridId in _mapManager.FindGridIdsIntersecting(map, worldBounds, true))
             {
-                if (value.ContainerOccluded || !value.Visible)
+                Box2 gridBounds;
+
+                if (gridId == GridId.Invalid)
                 {
-                    return true;
+                    gridBounds = worldBounds;
+                }
+                else
+                {
+                    gridBounds = worldBounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
                 }
 
-                var entity = value.Owner;
-                var transform = entity.Transform;
+                var tree = spriteSystem.GetSpriteTreeForMap(map, gridId);
 
-                ref var entry = ref state.AllocAdd();
-                entry.sprite = value;
-                entry.worldRot = transform.WorldRotation;
-                entry.matrix = transform.WorldMatrix;
-                var worldPos = entry.matrix.Transform(transform.LocalPosition);
-                entry.yWorldPos = worldPos.Y;
-                return true;
+                tree.QueryAabb(ref list, ((
+                    ref RefList<(SpriteComponent sprite, Matrix3 matrix, Angle worldRot, float yWorldPos)> state,
+                    in SpriteComponent value) =>
+                {
+                    // TODO: Probably value in storing this as its own DynamicTree
+                    if (value.ContainerOccluded || !value.Visible)
+                    {
+                        return true;
+                    }
 
-            }), worldBounds, approx: true);
+                    var entity = value.Owner;
+                    var transform = entity.Transform;
+
+                    ref var entry = ref state.AllocAdd();
+                    entry.sprite = value;
+                    entry.worldRot = transform.WorldRotation;
+                    entry.matrix = transform.WorldMatrix;
+                    var worldPos = entry.matrix.Transform(transform.LocalPosition);
+                    entry.yWorldPos = worldPos.Y;
+                    return true;
+
+                }), gridBounds, approx: true);
+            }
         }
 
         private void DrawSplash(IRenderHandle handle)
@@ -281,11 +402,13 @@ namespace Robust.Client.Graphics.Clyde
 
         private void RenderViewport(Viewport viewport)
         {
-            if (viewport.Eye == null)
+            if (viewport.Eye == null || viewport.Eye.Position.MapId == MapId.Nullspace)
             {
                 return;
             }
 
+            using var _ = DebugGroup($"Viewport: {viewport.Name}");
+
             // TODO: for the love of god all this state pushing/popping needs to be cleaned up.
 
             var oldTransform = _currentMatrixModel;
@@ -310,12 +433,11 @@ namespace Robust.Client.Graphics.Clyde
                 SetViewportImmediate(Box2i.FromDimensions(Vector2i.Zero, rt.Size));
                 _updateUniformConstants(viewport.Size);
 
-                CalcWorldMatrices(rt.Size, eye, out var proj, out var view);
+                CalcWorldMatrices(rt.Size, viewport.RenderScale, eye, out var proj, out var view);
                 SetProjViewFull(proj, view);
 
                 // Calculate world-space AABB for camera, to cull off-screen things.
-                var worldBounds = Box2.CenteredAround(eye.Position.Position,
-                    _framebufferSize / (float) EyeManager.PixelsPerMeter * eye.Zoom);
+                var worldBounds = CalcWorldBounds(viewport);
 
                 if (_eyeManager.CurrentMap != MapId.Nullspace)
                 {
@@ -324,6 +446,9 @@ namespace Robust.Client.Graphics.Clyde
                         DrawLightsAndFov(viewport, worldBounds, eye);
                     }
 
+                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowWorld, worldBounds);
+                    FlushRenderQueue();
+
                     using (DebugGroup("Grids"))
                     {
                         _drawGrids(worldBounds);
@@ -332,9 +457,11 @@ namespace Robust.Client.Graphics.Clyde
                     // We will also render worldspace overlays here so we can do them under / above entities as necessary
                     using (DebugGroup("Entities"))
                     {
-                        DrawEntitiesAndWorldOverlay(viewport, worldBounds);
+                        DrawEntities(viewport, worldBounds);
                     }
 
+                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowFOV, worldBounds);
+
                     if (_lightManager.Enabled && _lightManager.DrawHardFov && eye.DrawFov)
                     {
                         ApplyFovToBuffer(viewport, eye);
@@ -365,6 +492,9 @@ namespace Robust.Client.Graphics.Clyde
                         viewport.WallBleedIntermediateRenderTarget2.Texture,
                         UIBox2.FromDimensions(Vector2.Zero, ScreenSize), new Color(1, 1, 1, 0.5f));
                 }
+
+                RenderOverlays(viewport, OverlaySpace.WorldSpace, worldBounds);
+                FlushRenderQueue();
             }
 
             PopRenderStateFull(state);
@@ -375,6 +505,17 @@ namespace Robust.Client.Graphics.Clyde
             _currentViewport = oldVp;
         }
 
+        private static Box2 CalcWorldBounds(Viewport viewport)
+        {
+            var eye = viewport.Eye;
+            if (eye == null)
+                return default;
+
+            // TODO: This seems completely unfit by lacking things like rotation handling.
+            return Box2.CenteredAround(eye.Position.Position,
+                viewport.Size / viewport.RenderScale / EyeManager.PixelsPerMeter * eye.Zoom);
+        }
+
         private sealed class OverlayComparer : IComparer<Overlay>
         {
             public static readonly OverlayComparer Instance = new();

Robust.Client/Graphics/Clyde/Clyde.Helpers.cs

@@ -5,6 +5,7 @@ using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
+using SixLabors.ImageSharp.PixelFormats;
 using ES20 = OpenToolkit.Graphics.ES20;
 
 namespace Robust.Client.Graphics.Clyde
@@ -31,6 +32,27 @@ namespace Robust.Client.Graphics.Clyde
             CheckGlError();
             GL.BindTexture(TextureTarget.Texture2D, glHandle.Handle);
             CheckGlError();
+            GL.ActiveTexture(TextureUnit.Texture0);
+        }
+
+        private void CopyRenderTextureToTexture(RenderTexture source, ClydeTexture target) {
+            LoadedRenderTarget sourceLoaded = RtToLoaded(source);
+            bool pause = sourceLoaded != _currentBoundRenderTarget;
+            FullStoredRendererState? store = null;
+            if (pause) {
+                store = PushRenderStateFull();
+                BindRenderTargetFull(source);
+                CheckGlError();
+            }
+
+            GL.BindTexture(TextureTarget.Texture2D, _loadedTextures[target.TextureId].OpenGLObject.Handle);
+            CheckGlError();
+            GL.CopyTexSubImage2D(TextureTarget.Texture2D, 0, 0, 0, 0, 0, _framebufferSize.X, _framebufferSize.Y);
+            CheckGlError();
+
+            if (pause && store != null) {
+                PopRenderStateFull((FullStoredRendererState)store);
+            }
         }
 
         private static long EstPixelSize(PixelInternalFormat format)

Robust.Client/Graphics/Clyde/Clyde.LightRendering.cs

@@ -3,13 +3,14 @@ using System.Collections.Generic;
 using System.Buffers;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.GameObjects;
-using Robust.Client.ResourceManagement.ResourceTypes;
+using Robust.Client.ResourceManagement;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using static Robust.Client.GameObjects.ClientOccluderComponent;
 using OGLTextureWrapMode = OpenToolkit.Graphics.OpenGL.TextureWrapMode;
+using TKStencilOp = OpenToolkit.Graphics.OpenGL4.StencilOp;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -195,7 +196,6 @@ namespace Robust.Client.Graphics.Clyde
                 }
             }
 
-
             _lightSoftShaderHandle = LoadShaderHandle("/Shaders/Internal/light-soft.swsl");
             _lightHardShaderHandle = LoadShaderHandle("/Shaders/Internal/light-hard.swsl");
             _fovShaderHandle = LoadShaderHandle("/Shaders/Internal/fov.swsl");
@@ -361,16 +361,23 @@ namespace Robust.Client.Graphics.Clyde
                 FinalizeDepthDraw();
             }
 
-            BindRenderTargetImmediate(RtToLoaded(viewport.LightRenderTarget));
-            CheckGlError();
-            GLClearColor(_lightManager.AmbientLightColor);
-            GL.Clear(ClearBufferMask.ColorBufferBit);
-            CheckGlError();
+            GL.Enable(EnableCap.StencilTest);
+            _isStencilling = true;
 
             var (lightW, lightH) = GetLightMapSize(viewport.Size);
             GL.Viewport(0, 0, lightW, lightH);
             CheckGlError();
 
+            BindRenderTargetImmediate(RtToLoaded(viewport.LightRenderTarget));
+            CheckGlError();
+            GLClearColor(_lightManager.AmbientLightColor);
+            GL.ClearStencil(0xFF);
+            GL.StencilMask(0xFF);
+            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.StencilBufferBit);
+            CheckGlError();
+
+            ApplyLightingFovToBuffer(viewport, eye);
+
             var lightShader = _loadedShaders[_enableSoftShadows ? _lightSoftShaderHandle : _lightHardShaderHandle].Program;
             lightShader.Use();
 
@@ -382,6 +389,11 @@ namespace Robust.Client.Graphics.Clyde
             GL.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.One);
             CheckGlError();
 
+            GL.StencilFunc(StencilFunction.Equal, 0xFF, 0xFF);
+            CheckGlError();
+            GL.StencilOp(TKStencilOp.Keep, TKStencilOp.Keep, TKStencilOp.Keep);
+            CheckGlError();
+
             var lastRange = float.NaN;
             var lastPower = float.NaN;
             var lastColor = new Color(float.NaN, float.NaN, float.NaN, float.NaN);
@@ -463,11 +475,11 @@ namespace Robust.Client.Graphics.Clyde
             }
 
             ResetBlendFunc();
+            GL.Disable(EnableCap.StencilTest);
+            _isStencilling = false;
 
             CheckGlError();
 
-            ApplyLightingFovToBuffer(viewport, eye);
-
             BlurOntoWalls(viewport, eye);
 
             MergeWallLayer(viewport);
@@ -485,40 +497,55 @@ namespace Robust.Client.Graphics.Clyde
             GetLightsToRender(MapId map, in Box2 worldBounds)
         {
             var renderingTreeSystem = _entitySystemManager.GetEntitySystem<RenderingTreeSystem>();
-            var lightTree = renderingTreeSystem.GetLightTreeForMap(map);
-
             var state = (this, worldBounds, count: 0);
 
-            lightTree.QueryAabb(ref state, (ref (Clyde clyde, Box2 worldBounds, int count) state, in PointLightComponent light) =>
+            foreach (var gridId in _mapManager.FindGridIdsIntersecting(map, worldBounds, true))
             {
-                var transform = light.Owner.Transform;
+                Box2 gridBounds;
 
-                if (state.count >= LightsToRenderListSize)
+                if (gridId == GridId.Invalid)
                 {
-                    // There are too many lights to fit in the static memory.
-                    return false;
+                    gridBounds = worldBounds;
+                }
+                else
+                {
+                    gridBounds = worldBounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
                 }
 
-                if (!light.Enabled || light.ContainerOccluded)
+                var lightTree = renderingTreeSystem.GetLightTreeForMap(map, gridId);
+
+                lightTree.QueryAabb(ref state, (ref (Clyde clyde, Box2 worldBounds, int count) state, in PointLightComponent light) =>
                 {
+                    var transform = light.Owner.Transform;
+
+                    if (state.count >= LightsToRenderListSize)
+                    {
+                        // There are too many lights to fit in the static memory.
+                        return false;
+                    }
+
+                    // TODO: Don't insert into trees for these, same as sprites.
+                    if (!light.Enabled || light.ContainerOccluded)
+                    {
+                        return true;
+                    }
+
+                    var lightPos = transform.WorldMatrix.Transform(light.Offset);
+
+                    var circle = new Circle(lightPos, light.Radius);
+
+                    // If the light doesn't touch anywhere the camera can see, it doesn't matter.
+                    if (!circle.Intersects(state.worldBounds))
+                    {
+                        return true;
+                    }
+
+                    float distanceSquared = (state.worldBounds.Center - lightPos).LengthSquared;
+                    state.clyde._lightsToRenderList[state.count++] = (light, lightPos, distanceSquared);
+
                     return true;
-                }
-
-                var lightPos = transform.WorldMatrix.Transform(light.Offset);
-
-                var circle = new Circle(lightPos, light.Radius);
-
-                // If the light doesn't touch anywhere the camera can see, it doesn't matter.
-                if (!circle.Intersects(state.worldBounds))
-                {
-                    return true;
-                }
-
-                float distanceSquared = (state.worldBounds.Center - lightPos).LengthSquared;
-                state.clyde._lightsToRenderList[state.count++] = (light, lightPos, distanceSquared);
-
-                return true;
-            }, worldBounds);
+                }, gridBounds);
+            }
 
             if (state.count > _maxLightsPerScene)
             {
@@ -577,7 +604,7 @@ namespace Robust.Client.Graphics.Clyde
 
             // Have to scale the blurring radius based on viewport size and camera zoom.
             const float refCameraHeight = 14;
-            var cameraSize = eye.Zoom.Y * viewport.Size.Y / EyeManager.PixelsPerMeter;
+            var cameraSize = eye.Zoom.Y * viewport.Size.Y * (1 / viewport.RenderScale.Y) / EyeManager.PixelsPerMeter;
             // 7e-3f is just a magic factor that makes it look ok.
             var factor = 7e-3f * (refCameraHeight / cameraSize);
 
@@ -645,6 +672,12 @@ namespace Robust.Client.Graphics.Clyde
 
         private void ApplyFovToBuffer(Viewport viewport, IEye eye)
         {
+            GL.Clear(ClearBufferMask.StencilBufferBit);
+            GL.Enable(EnableCap.StencilTest);
+            GL.StencilOp(OpenToolkit.Graphics.OpenGL4.StencilOp.Keep, OpenToolkit.Graphics.OpenGL4.StencilOp.Keep, OpenToolkit.Graphics.OpenGL4.StencilOp.Replace);
+            GL.StencilFunc(StencilFunction.Always, 1, 0xFF);
+            GL.StencilMask(0xFF);
+
             // Applies FOV to the final framebuffer.
 
             var fovShader = _loadedShaders[_fovShaderHandle].Program;
@@ -658,6 +691,10 @@ namespace Robust.Client.Graphics.Clyde
             fovShader.SetUniformMaybe("center", eye.Position.Position);
 
             DrawBlit(viewport, fovShader);
+
+            GL.StencilMask(0x00);
+            GL.Disable(EnableCap.StencilTest);
+            _isStencilling = false;
         }
 
         private void ApplyLightingFovToBuffer(Viewport viewport, IEye eye)
@@ -690,6 +727,13 @@ namespace Robust.Client.Graphics.Clyde
             fovShader.SetUniformTextureMaybe(UniIMainTexture, TextureUnit.Texture0);
             fovShader.SetUniformMaybe("center", eye.Position.Position);
 
+            GL.StencilMask(0xFF);
+            CheckGlError();
+            GL.StencilFunc(StencilFunction.Always, 0, 0);
+            CheckGlError();
+            GL.StencilOp(TKStencilOp.Keep, TKStencilOp.Keep, TKStencilOp.Replace);
+            CheckGlError();
+
             DrawBlit(viewport, fovShader);
 
             if (_hasGLSamplerObjects)
@@ -775,12 +819,10 @@ namespace Robust.Client.Graphics.Clyde
                         var worldTransform = transform.WorldMatrix;
                         var box = occluder.BoundingBox;
 
-                        // So uh, angle 0 = east... Apparently...
-                        // We account for that here so I don't go insane.
-                        var (tlX, tlY) = worldTransform.Transform(box.BottomLeft);
-                        var (trX, trY) = worldTransform.Transform(box.TopLeft);
-                        var (brX, brY) = worldTransform.Transform(box.TopRight);
-                        var (blX, blY) = worldTransform.Transform(box.BottomRight);
+                        var (tlX, tlY) = worldTransform.Transform(box.TopLeft);
+                        var (trX, trY) = worldTransform.Transform(box.TopRight);
+                        var (brX, brY) = worldTransform.Transform(box.BottomRight);
+                        var (blX, blY) = worldTransform.Transform(box.BottomLeft);
 
                         // Faces.
                         var faceN = new Vector4(tlX, tlY, trX, trY);
@@ -941,7 +983,8 @@ namespace Robust.Client.Graphics.Clyde
             viewport.WallMaskRenderTarget = CreateRenderTarget(viewport.Size, RenderTargetColorFormat.R8,
                 name: $"{viewport.Name}-{nameof(viewport.WallMaskRenderTarget)}");
 
-            viewport.LightRenderTarget = CreateRenderTarget(lightMapSize, lightMapColorFormat,
+            viewport.LightRenderTarget = CreateRenderTarget(lightMapSize,
+                new RenderTargetFormatParameters(lightMapColorFormat, hasDepthStencil: true),
                 lightMapSampleParameters,
                 $"{viewport.Name}-{nameof(viewport.LightRenderTarget)}");
 

Robust.Client/Graphics/Clyde/Clyde.RenderHandle.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.InteropServices;
 using Robust.Client.GameObjects;
 using Robust.Shared.GameObjects;
@@ -37,28 +37,55 @@ namespace Robust.Client.Graphics.Clyde
                 _clyde.DrawSetProjViewTransform(proj, view);
             }
 
+            /// <summary>
+            /// Draws a sprite to the screen. The coordinate system is left handed.
+            /// Make sure to set <see cref="DrawSetModelTransform"/>
+            /// to set the model matrix if needed.
+            /// </summary>
+            /// <param name="texture">Texture to draw.</param>
+            /// <param name="bl">Bottom left vertex of the quad in object space.</param>
+            /// <param name="br">Bottom right vertex of the quad in object space.</param>
+            /// <param name="tl">Top left vertex of the quad in object space.</param>
+            /// <param name="tr">Top right vertex of the quad in object space.</param>
+            /// <param name="modulate">A color to multiply the texture by when shading.</param
+            /// <param name="subRegion">The four corners of the texture sub region in px.</param>
             public void DrawTextureScreen(Texture texture, Vector2 bl, Vector2 br, Vector2 tl, Vector2 tr,
                 in Color modulate, in UIBox2? subRegion)
             {
-                var clydeTexture = ExtractTexture(texture, subRegion, out var csr);
+                var clydeTexture = ExtractTexture(texture, in subRegion, out var csr);
 
                 var (w, h) = clydeTexture.Size;
                 var sr = new Box2(csr.Left / w, (h - csr.Top) / h, csr.Right / w, (h - csr.Bottom) / h);
 
-                _clyde.DrawTexture(clydeTexture.TextureId, bl, br, tl, tr, modulate, sr);
+                _clyde.DrawTexture(clydeTexture.TextureId, bl, br, tl, tr, in modulate, in sr);
             }
 
+            /// <summary>
+            /// Draws a sprite to the world. The coordinate system is right handed.
+            /// Make sure to set <see cref="DrawSetModelTransform"/>
+            /// to set the model matrix if needed.
+            /// </summary>
+            /// <param name="texture">Texture to draw.</param>
+            /// <param name="bl">Bottom left vertex of the quad in object space.</param>
+            /// <param name="br">Bottom right vertex of the quad in object space.</param>
+            /// <param name="tl">Top left vertex of the quad in object space.</param>
+            /// <param name="tr">Top right vertex of the quad in object space.</param>
+            /// <param name="modulate">A color to multiply the texture by when shading.</param>
+            /// <param name="subRegion">The four corners of the texture sub region in px.</param>
             public void DrawTextureWorld(Texture texture, Vector2 bl, Vector2 br, Vector2 tl, Vector2 tr,
                 Color modulate, in UIBox2? subRegion)
             {
-                var clydeTexture = ExtractTexture(texture, subRegion, out var csr);
+                var clydeTexture = ExtractTexture(texture, in subRegion, out var csr);
 
                 var (w, h) = clydeTexture.Size;
                 var sr = new Box2(csr.Left / w, (h - csr.Bottom) / h, csr.Right / w, (h - csr.Top) / h);
 
-                _clyde.DrawTexture(clydeTexture.TextureId, bl, br, tl, tr, modulate, sr);
+                _clyde.DrawTexture(clydeTexture.TextureId, bl, br, tl, tr, in modulate, in sr);
             }
 
+            /// <summary>
+            /// Converts a subRegion (px) into texture coords (0-1) of a given texture (cells of the textureAtlas).
+            /// </summary>
             private static ClydeTexture ExtractTexture(Texture texture, in UIBox2? subRegion, out UIBox2 sr)
             {
                 if (texture is AtlasTexture atlas)
@@ -383,22 +410,40 @@ namespace Robust.Client.Graphics.Clyde
                     }
                 }
 
-                public override void DrawTextureRectRegion(Texture texture, Box2 rect, UIBox2? subRegion = null,
-                    Color? modulate = null)
+                /// <summary>
+                /// Draws a sprite to the world. The coordinate system is right handed.
+                /// Make sure to set <see cref="DrawSetModelTransform"/>
+                /// to set the model matrix if needed.
+                /// </summary>
+                /// <param name="texture">Texture to draw.</param>
+                /// <param name="quad">The four vertices of the quad in object space (or world if the transform is identity.).</param>
+                /// <param name="modulate">A color to multiply the texture by when shading.</param>
+                /// <param name="subRegion">The four corners of the texture sub region in px.</param>
+                public override void DrawTextureRectRegion(Texture texture, Box2 quad,
+                    Color? modulate = null, UIBox2? subRegion = null)
                 {
                     var color = (modulate ?? Color.White) * Modulate;
 
-                    _renderHandle.DrawTextureWorld(texture, rect.BottomLeft, rect.BottomRight,
-                        rect.TopLeft, rect.TopRight, color, subRegion);
+                    _renderHandle.DrawTextureWorld(texture, quad.BottomLeft, quad.BottomRight,
+                        quad.TopLeft, quad.TopRight, color, in subRegion);
                 }
 
-                public override void DrawTextureRectRegion(Texture texture, in Box2Rotated rect,
-                    UIBox2? subRegion = null, Color? modulate = null)
+                /// <summary>
+                /// Draws a sprite to the world. The coordinate system is right handed.
+                /// Make sure to set <see cref="DrawSetModelTransform"/>
+                /// to set the model matrix if needed.
+                /// </summary>
+                /// <param name="texture">Texture to draw.</param>
+                /// <param name="quad">The four vertices of the quad in object space (or world if the transform is identity.).</param>
+                /// <param name="modulate">A color to multiply the texture by when shading.</param>
+                /// <param name="subRegion">The four corners of the texture sub region in px.</param>
+                public override void DrawTextureRectRegion(Texture texture, in Box2Rotated quad,
+                    Color? modulate = null, UIBox2? subRegion = null)
                 {
                     var color = (modulate ?? Color.White) * Modulate;
 
-                    _renderHandle.DrawTextureWorld(texture, rect.BottomLeft, rect.BottomRight,
-                        rect.TopLeft, rect.TopRight, color, subRegion);
+                    _renderHandle.DrawTextureWorld(texture, quad.BottomLeft, quad.BottomRight,
+                        quad.TopLeft, quad.TopRight, color, in subRegion);
                 }
 
                 public override void DrawPrimitives(DrawPrimitiveTopology primitiveTopology,

Robust.Client/Graphics/Clyde/Clyde.RenderTargets.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
@@ -6,6 +6,7 @@ using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Robust.Shared.Log;
+using SixLabors.ImageSharp.PixelFormats;
 
 // ReSharper disable once IdentifierTypo
 using RTCF = Robust.Client.Graphics.RenderTargetColorFormat;
@@ -191,7 +192,8 @@ namespace Robust.Client.Graphics.Clyde
                 FramebufferHandle = fbo,
                 Size = size,
                 TextureHandle = textureObject.TextureId,
-                MemoryPressure = pressure
+                MemoryPressure = pressure,
+                ColorFormat = format.ColorFormat
             };
 
             //GC.AddMemoryPressure(pressure);
@@ -278,6 +280,8 @@ namespace Robust.Client.Graphics.Clyde
             public Vector2i Size;
             public bool IsSrgb;
 
+            public RTCF ColorFormat;
+
             // Remaining properties only apply if the render target is NOT a window.
             // Handle to the framebuffer object.
             public GLHandle FramebufferHandle;
@@ -302,6 +306,12 @@ namespace Robust.Client.Graphics.Clyde
             }
 
             public abstract Vector2i Size { get; }
+
+            public void CopyPixelsToMemory<T>(CopyPixelsDelegate<T> callback, UIBox2i? subRegion = null) where T : unmanaged, IPixel<T>
+            {
+                Clyde.CopyRenderTargetPixels(Handle, subRegion, callback);
+            }
+
             public ClydeHandle Handle { get; }
 
             protected virtual void Dispose(bool disposing)

Robust.Client/Graphics/Clyde/Clyde.Rendering.cs

@@ -1,17 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.GameObjects;
 using Robust.Client.Utility;
-using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
 using Color = Robust.Shared.Maths.Color;
 using TKStencilOp = OpenToolkit.Graphics.OpenGL4.StencilOp;
 
@@ -120,9 +116,9 @@ namespace Robust.Client.Graphics.Clyde
             view = Matrix3.Identity;
         }
 
-        private static void CalcWorldMatrices(in Vector2i screenSize, IEye eye, out Matrix3 proj, out Matrix3 view)
+        private static void CalcWorldMatrices(in Vector2i screenSize, in Vector2 renderScale, IEye eye, out Matrix3 proj, out Matrix3 view)
         {
-            eye.GetViewMatrix(out view);
+            eye.GetViewMatrix(out view, renderScale);
 
             CalcWorldProjMatrix(screenSize, out proj);
         }
@@ -280,9 +276,19 @@ namespace Robust.Client.Graphics.Clyde
         }
 
         /// <summary>
-        ///     Flush the render handle, processing and re-pooling all the command lists.
+        ///     Flushes the render handle, processing and re-pooling all the command lists.
         /// </summary>
         private void FlushRenderQueue()
+        {
+            FlushBatchQueue();
+
+            // Reset renderer state.
+            _currentMatrixModel = Matrix3.Identity;
+            _queuedShader = _defaultShader.Handle;
+            SetScissorFull(null);
+        }
+
+        private void FlushBatchQueue()
         {
             // Finish any batches that may have been WiP.
             BreakBatch();
@@ -308,11 +314,6 @@ namespace Robust.Client.Graphics.Clyde
 
             ProcessRenderCommands();
             _queuedRenderCommands.Clear();
-
-            // Reset renderer state.
-            _currentMatrixModel = Matrix3.Identity;
-            _queuedShader = _defaultShader.Handle;
-            SetScissorFull(null);
         }
 
         private void SetScissorFull(UIBox2i? state)
@@ -371,6 +372,7 @@ namespace Robust.Client.Graphics.Clyde
 
             program.Use();
 
+            int textureUnitVal = 0;
             // Assign shader parameters to uniform since they may be dirty.
             foreach (var (name, value) in instance.Parameters)
             {
@@ -413,6 +415,15 @@ namespace Robust.Client.Graphics.Clyde
                     case Matrix4 matrix4:
                         program.SetUniform(name, matrix4);
                         break;
+                    case ClydeTexture clydeTexture:
+                        //It's important to start at Texture6 here since DrawCommandBatch uses Texture0 and Texture1 immediately after calling this
+                        //function! If passing in textures as uniforms ever stops working it might be since someone made it use all the way up to Texture6 too.
+                        //Might change this in the future?
+                        TextureUnit cTarget = TextureUnit.Texture6+textureUnitVal;
+                        SetTexture(cTarget, ((ClydeTexture)clydeTexture).TextureId);
+                        program.SetUniformTexture(name, cTarget);
+                        textureUnitVal++;
+                        break;
                     default:
                         throw new InvalidOperationException($"Unable to handle shader parameter {name}: {value}");
                 }
@@ -477,10 +488,21 @@ namespace Robust.Client.Graphics.Clyde
             _currentMatrixView = view;
         }
 
+        /// <summary>
+        /// Draws a texture quad to the screen.
+        /// </summary>
+        /// <param name="texture">Texture to draw.</param>
+        /// <param name="bl">Bottom left vertex of the quad in object space.</param>
+        /// <param name="br">Bottom right vertex of the quad in object space.</param>
+        /// <param name="tl">Top left vertex of the quad in object space.</param>
+        /// <param name="tr">Top right vertex of the quad in object space.</param>
+        /// <param name="modulate">A color to multiply the texture by when shading.</param>
+        /// <param name="texCoords">The four corners of the texture coordinates, matching the four vertices.</param>
         private void DrawTexture(ClydeHandle texture, Vector2 bl, Vector2 br, Vector2 tl, Vector2 tr, in Color modulate,
-            in Box2 sr)
+            in Box2 texCoords)
         {
-            EnsureBatchState(texture, modulate, true, GetQuadBatchPrimitiveType(), _queuedShader);
+            EnsureBatchSpaceAvailable(4, GetQuadBatchIndexCount());
+            EnsureBatchState(texture, in modulate, true, GetQuadBatchPrimitiveType(), _queuedShader);
 
             bl = _currentMatrixModel.Transform(bl);
             br = _currentMatrixModel.Transform(br);
@@ -489,10 +511,10 @@ namespace Robust.Client.Graphics.Clyde
 
             // TODO: split batch if necessary.
             var vIdx = BatchVertexIndex;
-            BatchVertexData[vIdx + 0] = new Vertex2D(bl, sr.BottomLeft);
-            BatchVertexData[vIdx + 1] = new Vertex2D(br, sr.BottomRight);
-            BatchVertexData[vIdx + 2] = new Vertex2D(tr, sr.TopRight);
-            BatchVertexData[vIdx + 3] = new Vertex2D(tl, sr.TopLeft);
+            BatchVertexData[vIdx + 0] = new Vertex2D(bl, texCoords.BottomLeft);
+            BatchVertexData[vIdx + 1] = new Vertex2D(br, texCoords.BottomRight);
+            BatchVertexData[vIdx + 2] = new Vertex2D(tr, texCoords.TopRight);
+            BatchVertexData[vIdx + 3] = new Vertex2D(tl, texCoords.TopLeft);
             BatchVertexIndex += 4;
             QuadBatchIndexWrite(BatchIndexData, ref BatchIndexIndex, (ushort) vIdx);
 
@@ -505,6 +527,8 @@ namespace Robust.Client.Graphics.Clyde
             FinishBatch();
             _batchMetaData = null;
 
+            EnsureBatchSpaceAvailable(vertices.Length, indices.Length);
+
             vertices.CopyTo(BatchVertexData.AsSpan(BatchVertexIndex));
 
             // We are weaving this into the batch buffers for performance (and simplicity).
@@ -546,6 +570,8 @@ namespace Robust.Client.Graphics.Clyde
             FinishBatch();
             _batchMetaData = null;
 
+            EnsureBatchSpaceAvailable(vertices.Length, 0);
+
             vertices.CopyTo(BatchVertexData.AsSpan(BatchVertexIndex));
 
             ref var command = ref AllocRenderCommand(RenderCommandType.DrawBatch);
@@ -581,6 +607,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private void DrawLine(Vector2 a, Vector2 b, Color color)
         {
+            EnsureBatchSpaceAvailable(2, 0);
             EnsureBatchState(_stockTextureWhite.TextureId, color, false, BatchPrimitiveType.LineList, _queuedShader);
 
             a = _currentMatrixModel.Transform(a);
@@ -595,6 +622,14 @@ namespace Robust.Client.Graphics.Clyde
             _debugStats.LastClydeDrawCalls += 1;
         }
 
+        private void EnsureBatchSpaceAvailable(int vtx, int idx)
+        {
+            if (BatchVertexIndex + vtx >= BatchVertexData.Length || BatchIndexIndex + idx > BatchIndexData.Length)
+            {
+                FlushBatchQueue();
+            }
+        }
+
         private void DrawSetScissor(UIBox2i? scissorBox)
         {
             BreakBatch();
@@ -753,116 +788,6 @@ namespace Robust.Client.Graphics.Clyde
             _batchMetaData = null;
         }
 
-        private unsafe void TakeScreenshot(ScreenshotType type)
-        {
-            if (_queuedScreenshots.Count == 0 || _queuedScreenshots.All(p => p.type != type))
-            {
-                return;
-            }
-
-            var delegates = _queuedScreenshots.Where(p => p.type == type).ToList();
-
-            _queuedScreenshots.RemoveAll(p => p.type == type);
-
-            GL.PixelStore(PixelStoreParameter.PackAlignment, 1);
-            CheckGlError();
-
-            var bufferLength = ScreenSize.X * ScreenSize.Y;
-            if (!(_hasGLFenceSync && HasGLAnyMapBuffer && _hasGLPixelBufferObjects))
-            {
-                Logger.DebugS("clyde.ogl", "Necessary features for async screenshots not available, falling back to blocking path.");
-
-                // We need these 3 features to be able to do asynchronous screenshots, if we don't have them,
-                // we'll have to fall back to a crappy synchronous stalling method of glReadPixels().
-
-                var buffer = new Rgba32[bufferLength];
-                fixed (Rgba32* ptr = buffer)
-                {
-                    var bufSize = sizeof(Rgba32) * bufferLength;
-                    GL.ReadnPixels(0, 0, ScreenSize.X, ScreenSize.Y, PixelFormat.Rgba, PixelType.UnsignedByte, bufSize,
-                        (IntPtr) ptr);
-                    CheckGlError();
-                }
-
-                var (w, h) = ScreenSize;
-
-                var image = new Image<Rgb24>(w, h);
-                var imageSpan = image.GetPixelSpan();
-
-                FlipCopyScreenshot(buffer, imageSpan, w, h);
-
-                RunCallback(image);
-                return;
-            }
-
-            GL.GenBuffers(1, out uint pbo);
-            CheckGlError();
-            GL.BindBuffer(BufferTarget.PixelPackBuffer, pbo);
-            CheckGlError();
-            GL.BufferData(BufferTarget.PixelPackBuffer, bufferLength * sizeof(Rgba32), IntPtr.Zero,
-                BufferUsageHint.StreamRead);
-            CheckGlError();
-            GL.ReadPixels(0, 0, ScreenSize.X, ScreenSize.Y, PixelFormat.Rgba, PixelType.UnsignedByte, IntPtr.Zero);
-            CheckGlError();
-            var fence = GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None);
-            CheckGlError();
-
-            GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
-            CheckGlError();
-
-            _transferringScreenshots.Add((pbo, fence, ScreenSize, RunCallback));
-
-            void RunCallback(Image<Rgb24> image) => delegates.ForEach(p => p.callback(image));
-        }
-
-        private unsafe void CheckTransferringScreenshots()
-        {
-            if (_transferringScreenshots.Count == 0)
-            {
-                return;
-            }
-
-            foreach (var screenshot in _transferringScreenshots.ToList())
-            {
-                var (pbo, fence, (width, height), callback) = screenshot;
-
-                int status;
-                GL.GetSync(fence, SyncParameterName.SyncStatus, sizeof(int), null, &status);
-                CheckGlError();
-
-                if (status == (int) All.Signaled)
-                {
-                    var bufLen = width * height;
-                    var bufSize = sizeof(Rgba32) * bufLen;
-
-                    GL.BindBuffer(BufferTarget.PixelPackBuffer, pbo);
-                    CheckGlError();
-                    var ptr = MapFullBuffer(BufferTarget.PixelPackBuffer, bufSize, BufferAccess.ReadOnly,
-                        BufferAccessMask.MapReadBit);
-
-                    var packSpan = new ReadOnlySpan<Rgba32>((void*) ptr, width * height);
-
-                    var image = new Image<Rgb24>(width, height);
-                    var imageSpan = image.GetPixelSpan();
-
-                    FlipCopyScreenshot(packSpan, imageSpan, width, height);
-
-                    UnmapBuffer(BufferTarget.PixelPackBuffer);
-                    GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
-                    CheckGlError();
-                    GL.DeleteBuffer(pbo);
-                    CheckGlError();
-                    GL.DeleteSync(fence);
-                    CheckGlError();
-
-                    _transferringScreenshots.Remove(screenshot);
-
-                    // TODO: Don't do unnecessary copy here.
-                    callback(image);
-                }
-            }
-        }
-
         private FullStoredRendererState PushRenderStateFull()
         {
             return new FullStoredRendererState(_currentMatrixProj, _currentMatrixView, _currentRenderTarget);

Robust.Client/Graphics/Clyde/Clyde.Screenshots.cs

@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using OpenToolkit.Graphics.OpenGL4;
+using Robust.Client.Utility;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using PF = OpenToolkit.Graphics.OpenGL4.PixelFormat;
+using PT = OpenToolkit.Graphics.OpenGL4.PixelType;
+
+namespace Robust.Client.Graphics.Clyde
+{
+    // Contains primary screenshot and pixel-copying logic.
+
+    internal sealed partial class Clyde
+    {
+        // Full-framebuffer screenshots undergo the following sequence of events:
+        // 1. Screenshots are queued by content or whatever.
+        // 2. When the rendering code reaches the screenshot type,
+        //    we instruct the GPU driver to copy the framebuffer and asynchronously transfer it to host memory.
+        // 3. Transfer finished asynchronously, we invoke the callback.
+        //
+        // On RAW GLES2, we cannot do this asynchronously due to lacking GL features,
+        // and the game will stutter as a result. This is sadly unavoidable.
+        //
+        // For CopyPixels on render targets, the copy and transfer is started immediately when the function is called.
+
+        private readonly List<QueuedScreenshot> _queuedScreenshots = new();
+        private readonly List<TransferringPixelCopy> _transferringPixelCopies = new();
+
+        public void Screenshot(ScreenshotType type, CopyPixelsDelegate<Rgb24> callback, UIBox2i? subRegion = null)
+        {
+            _queuedScreenshots.Add(new QueuedScreenshot(type, callback, subRegion));
+        }
+
+        private void TakeScreenshot(ScreenshotType type)
+        {
+            if (_queuedScreenshots.Count == 0)
+            {
+                return;
+            }
+
+            GL.PixelStore(PixelStoreParameter.PackAlignment, 1);
+            CheckGlError();
+
+            for (var i = 0; i < _queuedScreenshots.Count; i++)
+            {
+                var (qType, callback, subRegion) = _queuedScreenshots[i];
+                if (qType != type)
+                    continue;
+
+                DoCopyPixels(ScreenSize, subRegion, callback);
+                _queuedScreenshots.RemoveSwap(i--);
+            }
+        }
+
+        private void CopyRenderTargetPixels<T>(
+            ClydeHandle renderTarget,
+            UIBox2i? subRegion,
+            CopyPixelsDelegate<T> callback)
+            where T : unmanaged, IPixel<T>
+        {
+            var loaded = _renderTargets[renderTarget];
+
+            var original = GL.GetInteger(GetPName.ReadFramebufferBinding);
+
+            GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, loaded.FramebufferHandle.Handle);
+
+            DoCopyPixels(loaded.Size, subRegion, callback);
+
+            GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, original);
+        }
+
+        private unsafe void DoCopyPixels<T>(
+            Vector2i fbSize,
+            UIBox2i? subRegion,
+            CopyPixelsDelegate<T> callback)
+            where T : unmanaged, IPixel<T>
+        {
+            var (pf, pt) = default(T) switch
+            {
+                Rgba32 => (PF.Rgba, PT.UnsignedByte),
+                Rgb24 => (PF.Rgb, PT.UnsignedByte),
+                _ => throw new ArgumentException("Unsupported pixel type.")
+            };
+
+            var size = ClampSubRegion(fbSize, subRegion);
+
+            var bufferLength = size.X * size.Y;
+            if (!(_hasGLFenceSync && HasGLAnyMapBuffer && _hasGLPixelBufferObjects))
+            {
+                Logger.DebugS("clyde.ogl",
+                    "Necessary features for async screenshots not available, falling back to blocking path.");
+
+                // We need these 3 features to be able to do asynchronous screenshots, if we don't have them,
+                // we'll have to fall back to a crappy synchronous stalling method of glReadnPixels().
+
+                var buffer = new T[bufferLength];
+                fixed (T* ptr = buffer)
+                {
+                    var bufSize = sizeof(T) * bufferLength;
+                    GL.ReadnPixels(
+                        0, 0,
+                        size.X, size.Y,
+                        pf, pt,
+                        bufSize,
+                        (nint) ptr);
+
+                    CheckGlError();
+                }
+
+                var image = new Image<T>(size.X, size.Y);
+                var imageSpan = image.GetPixelSpan();
+
+                FlipCopy(buffer, imageSpan, size.X, size.Y);
+
+                callback(image);
+                return;
+            }
+
+            GL.GenBuffers(1, out uint pbo);
+            CheckGlError();
+
+            GL.BindBuffer(BufferTarget.PixelPackBuffer, pbo);
+            CheckGlError();
+
+            GL.BufferData(
+                BufferTarget.PixelPackBuffer,
+                bufferLength * sizeof(Rgba32), IntPtr.Zero,
+                BufferUsageHint.StreamRead);
+            CheckGlError();
+
+            GL.ReadPixels(0, 0, size.X, size.Y, pf, pt, IntPtr.Zero);
+            CheckGlError();
+
+            var fence = GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None);
+            CheckGlError();
+
+            GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
+            CheckGlError();
+
+            var transferring = new TransferringPixelCopy(pbo, fence, size, FinishPixelTransfer<T>, callback);
+            _transferringPixelCopies.Add(transferring);
+        }
+
+        private unsafe void CheckTransferringScreenshots()
+        {
+            if (_transferringPixelCopies.Count == 0)
+            {
+                return;
+            }
+
+            for (var i = 0; i < _transferringPixelCopies.Count; i++)
+            {
+                var transferring = _transferringPixelCopies[i];
+
+                // Check if transfer done (sync signalled)
+                int status;
+                GL.GetSync(transferring.Sync, SyncParameterName.SyncStatus, sizeof(int), null, &status);
+                CheckGlError();
+
+                if (status != (int) All.Signaled)
+                    continue;
+
+                transferring.TransferContinue(transferring);
+                _transferringPixelCopies.RemoveSwap(i--);
+            }
+        }
+
+        private unsafe void FinishPixelTransfer<T>(TransferringPixelCopy transferring) where T : unmanaged, IPixel<T>
+        {
+            var (pbo, fence, (width, height), _, callback) = transferring;
+
+            var bufLen = width * height;
+            var bufSize = sizeof(T) * bufLen;
+
+            GL.BindBuffer(BufferTarget.PixelPackBuffer, pbo);
+            CheckGlError();
+
+            var ptr = MapFullBuffer(
+                BufferTarget.PixelPackBuffer,
+                bufSize,
+                BufferAccess.ReadOnly,
+                BufferAccessMask.MapReadBit);
+
+            var packSpan = new ReadOnlySpan<T>(ptr, width * height);
+
+            var image = new Image<T>(width, height);
+            var imageSpan = image.GetPixelSpan();
+
+            FlipCopy(packSpan, imageSpan, width, height);
+
+            UnmapBuffer(BufferTarget.PixelPackBuffer);
+
+            GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);
+            CheckGlError();
+
+            GL.DeleteBuffer(pbo);
+            CheckGlError();
+
+            GL.DeleteSync(fence);
+            CheckGlError();
+
+            var castCallback = (CopyPixelsDelegate<T>) callback;
+            castCallback(image);
+        }
+
+        private sealed record QueuedScreenshot(
+            ScreenshotType Type,
+            CopyPixelsDelegate<Rgb24> Callback,
+            UIBox2i? SubRegion);
+
+        private sealed record TransferringPixelCopy(
+            uint Pbo,
+            nint Sync,
+            Vector2i Size,
+            // Funny callback dance to handle the generics.
+            Action<TransferringPixelCopy> TransferContinue,
+            Delegate Callback);
+    }
+}

Robust.Client/Graphics/Clyde/Clyde.Shaders.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Text;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Client.ResourceManagement.ResourceTypes;
+using Robust.Client.ResourceManagement;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using StencilOp = Robust.Client.Graphics.StencilOp;
@@ -428,7 +428,8 @@ namespace Robust.Client.Graphics.Clyde
 
             private protected override void SetParameterImpl(string name, Texture value)
             {
-                throw new NotImplementedException();
+                var data = Parent._shaderInstances[Handle];
+                data.Parameters[name] = value;
             }
 
             private protected override void SetStencilOpImpl(StencilOp op)

Robust.Client/Graphics/Clyde/Clyde.Textures.cs

@@ -26,7 +26,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private readonly ConcurrentQueue<ClydeHandle> _textureDisposeQueue = new();
 
-        public Texture LoadTextureFromPNGStream(Stream stream, string? name = null,
+        public OwnedTexture LoadTextureFromPNGStream(Stream stream, string? name = null,
             TextureLoadParameters? loadParams = null)
         {
             DebugTools.Assert(_mainThread == Thread.CurrentThread);
@@ -37,7 +37,7 @@ namespace Robust.Client.Graphics.Clyde
             return LoadTextureFromImage(image, name, loadParams);
         }
 
-        public Texture LoadTextureFromImage<T>(Image<T> image, string? name = null,
+        public OwnedTexture LoadTextureFromImage<T>(Image<T> image, string? name = null,
             TextureLoadParameters? loadParams = null) where T : unmanaged, IPixel<T>
         {
             DebugTools.Assert(_mainThread == Thread.CurrentThread);
@@ -56,19 +56,19 @@ namespace Robust.Client.Graphics.Clyde
                 {
                     // Disable sRGB so stuff doesn't get interpreter wrong.
                     actualParams.Srgb = false;
-                    var img = ApplyA8Swizzle((Image<A8>) (object) image);
+                    using var img = ApplyA8Swizzle((Image<A8>) (object) image);
                     return LoadTextureFromImage(img, name, loadParams);
                 }
 
                 if (pixelType == typeof(L8) && !actualParams.Srgb)
                 {
-                    var img = ApplyL8Swizzle((Image<L8>) (object) image);
+                    using var img = ApplyL8Swizzle((Image<L8>) (object) image);
                     return LoadTextureFromImage(img, name, loadParams);
                 }
             }
 
             // Flip image because OpenGL reads images upside down.
-            var copy = FlipClone(image);
+            using var copy = FlipClone(image);
 
             var texture = CreateBaseTextureInternal<T>(image.Width, image.Height, actualParams, name);
 
@@ -324,11 +324,13 @@ namespace Robust.Client.Graphics.Clyde
                 if (typeof(T) == typeof(A8))
                 {
                     SetSubImage(texture, dstTl, ApplyA8Swizzle((Image<A8>) (object) srcImage), srcBox);
+                    return;
                 }
 
                 if (typeof(T) == typeof(L8))
                 {
                     SetSubImage(texture, dstTl, ApplyL8Swizzle((Image<L8>) (object) srcImage), srcBox);
+                    return;
                 }
             }
 
@@ -450,24 +452,6 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private static void FlipCopyScreenshot(ReadOnlySpan<Rgba32> srcSpan, Span<Rgb24> dstSpan, int w, int h)
-        {
-            var dr = h - 1;
-            for (var r = 0; r < h; r++, dr--)
-            {
-                var si = r * w;
-                var di = dr * w;
-                var srcRow = srcSpan[si..(si + w)];
-                var dstRow = dstSpan[di..(di + w)];
-
-                for (var x = 0; x < w; x++)
-                {
-                    var src = srcRow[x];
-                    dstRow[x] = new Rgb24(src.R, src.G, src.B);
-                }
-            }
-        }
-
         private static Image<Rgba32> ApplyA8Swizzle(Image<A8> source)
         {
             var newImage = new Image<Rgba32>(source.Width, source.Height);