Debugdraw enhancements (#2080)

* Debugdraw enhancements

* Fix up the overlays

* Changes

* Box2D licence

* Update Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

Co-authored-by: Paul Ritter <ritter.paul1@googlemail.com>

* Fix dependency

Co-authored-by: Paul Ritter <ritter.paul1@googlemail.com>

.gitmodules

@@ -16,3 +16,6 @@
 [submodule "Linguini"]
 	path = Linguini
 	url = https://github.com/space-wizards/Linguini
+[submodule "cefglue"]
+	path = cefglue
+	url = https://gitlab.com/xiliumhq/chromiumembedded/cefglue/

OpenToolkit.GraphicsLibraryFramework/Enums/WindowHintBool.cs

@@ -129,5 +129,7 @@ namespace OpenToolkit.GraphicsLibraryFramework
         /// for controlling sRGB rendering and a created OpenGL ES context will always have sRGB rendering enabled.
         /// </summary>
         SrgbCapable = 0x0002100E,
+
+        ScaleToMonitor = 0x0002200C,
     }
 }

OpenToolkit.GraphicsLibraryFramework/GLFW.cs

@@ -5551,5 +5551,15 @@ namespace OpenToolkit.GraphicsLibraryFramework
         {
             return glfwGetX11Window(window);
         }
+
+        public static unsafe IntPtr GetX11Display(Window* window)
+        {
+            return glfwGetX11Display(window);
+        }
+
+        public static unsafe IntPtr GetWin32Window(Window* window)
+        {
+            return glfwGetWin32Window(window);
+        }
     }
 }

OpenToolkit.GraphicsLibraryFramework/GLFWNative.cs

@@ -406,5 +406,11 @@ namespace OpenToolkit.GraphicsLibraryFramework
 
         [DllImport(LibraryName)]
         public static extern uint glfwGetX11Window(Window* window);
+
+        [DllImport(LibraryName)]
+        public static extern IntPtr glfwGetX11Display(Window* window);
+
+        [DllImport(LibraryName)]
+        public static extern IntPtr glfwGetWin32Window(Window* window);
     }
 }

Resources/EngineCredits/Libraries.yml

@@ -24,7 +24,7 @@
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 - name: Box2D
-  license:
+  license: |
     MIT License
 
     Copyright (c) 2019 Erin Catto
@@ -33,7 +33,7 @@
     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 
+    copies of the Software, and to permit persons to whom the Software is
     furnished to do so, subject to the following conditions:
 
     The above copyright notice and this permission notice shall be included in all
@@ -48,7 +48,7 @@
     SOFTWARE.
 
 - name: Bullet Physics SDK
-  license:
+  license: |
     The files in this repository are licensed under the zlib license, except for the files under 'Extras' and examples/ThirdPartyLibs.
 
     Bullet Continuous Collision Detection and Physics Library
@@ -60,10 +60,10 @@
     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. 
+    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. 
+    3. This notice may not be removed or altered from any source distribution.
 
 - name: Castle Core
   license: |
@@ -360,7 +360,7 @@
     limitations under the License.
 
 - name: Farseer Physics Engine
-  license:
+  license: |
     Microsoft Permissive License (Ms-PL)
 
     This license governs use of the accompanying software.
@@ -374,26 +374,26 @@
     "Licensed patents" are a contributor's patent claims that read directly on its contribution.
 
     2. Grant of Rights
-    (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
-    each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, 
+    (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
+    each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution,
     prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
-    (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, 
-    each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to 
-    make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or 
+    (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
+    each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to
+    make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or
     derivative works of the contribution in the software.
 
     3. Conditions and Limitations
     (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
-    (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, 
+    (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software,
     your patent license from such contributor to the software ends automatically.
-    (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, 
+    (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark,
     and attribution notices that are present in the software.
-    (D) If you distribute any portion of the software in source code form, you may do so only under this license by 
-    including a complete copy of this license with your distribution. If you distribute any portion of the software in 
+    (D) If you distribute any portion of the software in source code form, you may do so only under this license by
+    including a complete copy of this license with your distribution. If you distribute any portion of the software in
     compiled or object code form, you may only do so under a license that complies with this license.
-    (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, 
-    guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. 
-    To the extent permitted under your local laws, the contributors exclude the implied warranties of 
+    (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties,
+    guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change.
+    To the extent permitted under your local laws, the contributors exclude the implied warranties of
     merchantability, fitness for a particular purpose and non-infringement.
 
 - name: Mono.Cecil

Resources/Shaders/Internal/light-blur.swsl

@@ -0,0 +1,41 @@
+preset raw;
+
+uniform highp vec2 direction;
+uniform highp vec2 size;
+uniform highp float radius;
+
+varying highp vec2 pos;
+varying highp vec4 blurPos1;
+varying highp vec4 blurPos2;
+
+
+void vertex()
+{
+    highp float aspect = size.y / size.x;
+    highp float horRadius = aspect * radius;
+
+    highp vec2 offset = vec2(horRadius, radius) * direction;
+
+    VERTEX = apply_mvp(VERTEX);
+
+    pos = (VERTEX + vec2(1.0)) / 2.0;
+
+    blurPos1.xy = pos + offset;
+    blurPos1.zw = pos - offset;
+    blurPos2.xy = pos + offset * 2.0;
+    blurPos2.zw = pos - offset * 2.0;
+}
+
+
+void fragment()
+{
+    // Very simple gaussian blur.
+    highp vec4 sum = zTexture(pos) * 0.375;
+
+    sum += zTexture(blurPos1.xy) * 0.25;
+    sum += zTexture(blurPos1.zw) * 0.25;
+    sum += zTexture(blurPos2.xy) * 0.0625;
+    sum += zTexture(blurPos2.zw) * 0.0625;
+
+    COLOR = sum;
+}

Robust.Analyzers/FriendAnalyzer.cs

@@ -0,0 +1,107 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class FriendAnalyzer : DiagnosticAnalyzer
+    {
+        const string FriendAttribute = "Robust.Shared.Analyzers.FriendAttribute";
+
+        public const string DiagnosticId = "RA0002";
+
+        private const string Title = "Tried to access friend-only member";
+        private const string MessageFormat = "Tried to access member \"{0}\" in class \"{1}\" which can only be accessed by friend classes";
+        private const string Description = "Make sure to specify the accessing class in the friends attribute.";
+        private const string Category = "Usage";
+
+        [SuppressMessage("ReSharper", "RS2008")]
+        private static readonly DiagnosticDescriptor Rule = new (DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Error, true, Description);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+            context.EnableConcurrentExecution();
+            context.RegisterSyntaxNodeAction(CheckFriendship, SyntaxKind.SimpleMemberAccessExpression);
+        }
+
+        private void CheckFriendship(SyntaxNodeAnalysisContext context)
+        {
+            if (context.Node is not MemberAccessExpressionSyntax memberAccess)
+                return;
+
+            // We only do something if our parent is one of a few types.
+            switch (context.Node.Parent)
+            {
+                // If we're being assigned...
+                case AssignmentExpressionSyntax assignParent:
+                {
+                    if (assignParent.Left != memberAccess)
+                        return;
+                    break;
+                }
+
+                // If we're being invoked...
+                case InvocationExpressionSyntax:
+                    break;
+
+                // Otherwise, do nothing.
+                default:
+                    return;
+            }
+
+            // Get the friend attribute
+            var friendAttr = context.Compilation.GetTypeByMetadataName(FriendAttribute);
+
+            // Get the type that is containing this expression, or, the class where this is happening.
+            if (context.ContainingSymbol?.ContainingType is not { } containingType)
+                return;
+
+            // We check all of our children and get only the identifiers.
+            foreach (var identifier in memberAccess.ChildNodes().Select(node => node as IdentifierNameSyntax))
+            {
+                if (identifier == null) continue;
+
+                // Get the type info of the identifier, so we can check the attributes...
+                if (context.SemanticModel.GetTypeInfo(identifier).ConvertedType is not { } type)
+                    continue;
+
+                // Same-type access is always fine.
+                if (SymbolEqualityComparer.Default.Equals(type, containingType))
+                    continue;
+
+                // Finally, get all attributes of the type, to check if we have any friend classes.
+                foreach (var attribute in type.GetAttributes())
+                {
+                    // If the attribute isn't the friend attribute, continue.
+                    if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, friendAttr))
+                        continue;
+
+                    // Check all types allowed in the friend attribute. (We assume there's only one constructor arg.)
+                    foreach (var constant in attribute.ConstructorArguments[0].Values)
+                    {
+                        // Check if the value is a type...
+                        if (constant.Value is not INamedTypeSymbol t)
+                            continue;
+
+                        // If we find that the containing class is specified in the attribute, return! All is good.
+                        if (SymbolEqualityComparer.Default.Equals(containingType, t))
+                            return;
+                    }
+
+                    // Not in a friend class! Report an error.
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(Rule, context.Node.GetLocation(),
+                            $"{context.Node.ToString().Split('.').LastOrDefault()}", $"{type.Name}"));
+                }
+            }
+        }
+    }
+}

Robust.Analyzers/Robust.Analyzers.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>9</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

Robust.Benchmarks/NumericsHelpers/AddBenchmark.cs

@@ -0,0 +1,28 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Robust.Benchmarks.NumericsHelpers
+{
+    public class AddBenchmark
+    {
+        [Params(32, 128)]
+        public int N { get; set; }
+
+        private float[] _inputA = default!;
+        private float[] _inputB = default!;
+        private float[] _output = default!;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _inputA = new float[N];
+            _inputB = new float[N];
+            _output = new float[N];
+        }
+
+        [Benchmark]
+        public void Bench()
+        {
+            Shared.Maths.NumericsHelpers.Add(_inputA, _inputB, _output);
+        }
+    }
+}

Robust.Benchmarks/Program.cs

@@ -4,9 +4,11 @@ namespace Robust.Benchmarks
 {
     internal class Program
     {
+        // --allCategories=ctg1,ctg2
+        // --anyCategories=ctg1,ctg2
         public static void Main(string[] args)
         {
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run();
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
         }
     }
 }

Robust.Benchmarks/Serialization/BenchmarkIntSerializer.cs

@@ -0,0 +1,40 @@
+using System.Globalization;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Manager.Result;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Interfaces;
+
+namespace Robust.Benchmarks.Serialization
+{
+    public class BenchmarkIntSerializer : ITypeSerializer<int, ValueDataNode>
+    {
+        public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
+            IDependencyCollection dependencies, ISerializationContext? context = null)
+        {
+            return int.TryParse(node.Value, out _)
+                ? new ValidatedValueNode(node)
+                : new ErrorNode(node, $"Failed parsing int value: {node.Value}");
+        }
+
+        public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
+            IDependencyCollection dependencies, bool skipHook, ISerializationContext? context = null)
+        {
+            return new DeserializedValue<int>(int.Parse(node.Value, CultureInfo.InvariantCulture));
+        }
+
+        public DataNode Write(ISerializationManager serializationManager, int value, bool alwaysWrite = false,
+            ISerializationContext? context = null)
+        {
+            return new ValueDataNode(value.ToString(CultureInfo.InvariantCulture));
+        }
+
+        public int Copy(ISerializationManager serializationManager, int source, int target, bool skipHook,
+            ISerializationContext? context = null)
+        {
+            return source;
+        }
+    }
+}

Robust.Benchmarks/Serialization/Copy/SerializationCopyBenchmark.cs

@@ -6,11 +6,13 @@ using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Copy
 {
+    [MemoryDiagnoser]
     public class SerializationCopyBenchmark : SerializationBenchmark
     {
         public SerializationCopyBenchmark()
@@ -35,6 +37,10 @@ namespace Robust.Benchmarks.Serialization.Copy
 
         private SeedDataDefinition Seed { get; }
 
+        private BenchmarkFlagsEnum FlagZero = BenchmarkFlagsEnum.Zero;
+
+        private BenchmarkFlagsEnum FlagThirtyOne = BenchmarkFlagsEnum.ThirtyOne;
+
         [Benchmark]
         public string? CreateCopyString()
         {
@@ -111,5 +117,35 @@ namespace Robust.Benchmarks.Serialization.Copy
 
             return copy;
         }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public object? CopyFlagZero()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(FlagSerializer<BenchmarkFlags>),
+                (int) FlagZero,
+                (int) FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public object? CopyFlagThirtyOne()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(FlagSerializer<BenchmarkFlags>),
+                (int) FlagThirtyOne,
+                (int) FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public object? CopyIntegerCustomSerializer()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(BenchmarkIntSerializer),
+                Integer,
+                Integer);
+        }
     }
 }

Robust.Benchmarks/Serialization/Definitions/BenchmarkFlags.cs

@@ -0,0 +1,19 @@
+using System;
+using Robust.Shared.Serialization;
+
+namespace Robust.Benchmarks.Serialization.Definitions
+{
+    public class BenchmarkFlags
+    {
+        public const int Zero = 1 << 0;
+        public const int ThirtyOne = 1 << 31;
+    }
+
+    [Flags]
+    [FlagsFor(typeof(BenchmarkFlags))]
+    public enum BenchmarkFlagsEnum
+    {
+        Zero = BenchmarkFlags.Zero,
+        ThirtyOne = BenchmarkFlags.ThirtyOne
+    }
+}

Robust.Benchmarks/Serialization/Definitions/DataDefinitionWithString.cs

@@ -5,7 +5,7 @@ namespace Robust.Benchmarks.Serialization.Definitions
     [DataDefinition]
     public class DataDefinitionWithString
     {
-        [field: DataField("string")]
+        [DataField("string")]
         public string StringField { get; init; } = default!;
     }
 }

Robust.Benchmarks/Serialization/Definitions/SealedDataDefinitionWithString.cs

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

Robust.Benchmarks/Serialization/Initialize/SerializationInitializeBenchmark.cs

@@ -3,6 +3,7 @@ using Robust.Shared.Serialization.Manager;
 
 namespace Robust.Benchmarks.Serialization.Initialize
 {
+    [MemoryDiagnoser]
     public class SerializationInitializeBenchmark : SerializationBenchmark
     {
         [IterationCleanup]

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -1,14 +1,17 @@
 using System.IO;
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Manager.Result;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Read
 {
+    [MemoryDiagnoser]
     public class SerializationReadBenchmark : SerializationBenchmark
     {
         public SerializationReadBenchmark()
@@ -32,6 +35,10 @@ namespace Robust.Benchmarks.Serialization.Read
 
         private MappingDataNode SeedNode { get; }
 
+        private ValueDataNode FlagZero { get; } = new("Zero");
+
+        private ValueDataNode FlagThirtyOne { get; } = new("ThirtyOne");
+
         [Benchmark]
         public string? ReadString()
         {
@@ -55,5 +62,35 @@ namespace Robust.Benchmarks.Serialization.Read
         {
             return SerializationManager.ReadValue<SeedDataDefinition>(SeedNode);
         }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DeserializationResult ReadFlagZero()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DeserializationResult ReadThirtyOne()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public DeserializationResult ReadIntegerCustomSerializer()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(BenchmarkIntSerializer),
+                IntNode);
+        }
     }
 }

Robust.Benchmarks/Serialization/SerializationArrayBenchmark.cs

@@ -0,0 +1,127 @@
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+
+namespace Robust.Benchmarks.Serialization
+{
+    [MemoryDiagnoser]
+    public class SerializationArrayBenchmark : SerializationBenchmark
+    {
+        public SerializationArrayBenchmark()
+        {
+            InitializeSerialization();
+
+            OneStringDefNode = new SequenceDataNode();
+            OneStringDefNode.Add(new MappingDataNode
+            {
+                ["string"] = new ValueDataNode("ABC")
+            });
+
+            TenStringDefsNode = new SequenceDataNode();
+
+            for (var i = 0; i < 10; i++)
+            {
+                TenStringDefsNode.Add(new MappingDataNode
+                {
+                    ["string"] = new ValueDataNode("ABC")
+                });
+            }
+        }
+
+        private SequenceDataNode EmptyNode { get; } = new();
+
+        private SequenceDataNode OneIntNode { get; } = new("1");
+
+        private SequenceDataNode TenIntsNode { get; } = new("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
+
+        private SequenceDataNode OneStringDefNode { get; }
+
+        private SequenceDataNode TenStringDefsNode { get; }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadEmptyString()
+        {
+            return SerializationManager.ReadValue<string[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadOneString()
+        {
+            return SerializationManager.ReadValue<string[]>(OneIntNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadTenStrings()
+        {
+            return SerializationManager.ReadValue<string[]>(TenIntsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadEmptyInt()
+        {
+            return SerializationManager.ReadValue<int[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadOneInt()
+        {
+            return SerializationManager.ReadValue<int[]>(OneIntNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadTenInts()
+        {
+            return SerializationManager.ReadValue<int[]>(TenIntsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadEmptyStringDataDef()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadOneStringDataDef()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(OneStringDefNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadTenStringDataDefs()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(TenStringDefsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadEmptySealedStringDataDef()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadOneSealedStringDataDef()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(OneStringDefNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadTenSealedStringDataDefs()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(TenStringDefsNode);
+        }
+    }
+}

Robust.Benchmarks/Serialization/Write/SerializationWriteBenchmark.cs

@@ -7,10 +7,12 @@ using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Write
 {
+    [MemoryDiagnoser]
     public class SerializationWriteBenchmark : SerializationBenchmark
     {
         public SerializationWriteBenchmark()
@@ -35,6 +37,10 @@ namespace Robust.Benchmarks.Serialization.Write
 
         private SeedDataDefinition Seed { get; }
 
+        private BenchmarkFlagsEnum FlagZero = BenchmarkFlagsEnum.Zero;
+
+        private BenchmarkFlagsEnum FlagThirtyOne = BenchmarkFlagsEnum.ThirtyOne;
+
         [Benchmark]
         public DataNode WriteString()
         {
@@ -94,5 +100,35 @@ namespace Robust.Benchmarks.Serialization.Write
 
             return mapping;
         }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DataNode WriteFlagZero()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DataNode WriteThirtyOne()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public DataNode WriteIntegerCustomSerializer()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(BenchmarkIntSerializer),
+                Integer);
+        }
     }
 }

Robust.Client.CEF/BeforeBrowseContext.cs

@@ -0,0 +1,32 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class BeforeBrowseContext
+    {
+        internal readonly CefRequest CefRequest;
+
+        public string Url => CefRequest.Url;
+        public string Method => CefRequest.Method;
+
+        public bool IsRedirect { get; }
+        public bool UserGesture { get; }
+
+        public bool IsCancelled { get; private set; }
+
+        internal BeforeBrowseContext(
+            bool isRedirect,
+            bool userGesture,
+            CefRequest cefRequest)
+        {
+            CefRequest = cefRequest;
+            IsRedirect = isRedirect;
+            UserGesture = userGesture;
+        }
+
+        public void DoCancel()
+        {
+            IsCancelled = true;
+        }
+    }
+}

Robust.Client.CEF/BrowserControl.cs

@@ -0,0 +1,593 @@
+using System;
+using System.Collections.Generic;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.UserInterface;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
+using SixLabors.ImageSharp.PixelFormats;
+using Xilium.CefGlue;
+using static Robust.Client.CEF.CefKeyCodes;
+using static Robust.Client.CEF.CefKeyCodes.ChromiumKeyboardCode;
+using static Robust.Client.Input.Keyboard;
+
+namespace Robust.Client.CEF
+{
+    // Funny browser control to integrate in UI.
+    public class BrowserControl : Control, IBrowserControl, IRawInputControl
+    {
+        private const int ScrollSpeed = 50;
+
+        [Dependency] private readonly IClyde _clyde = default!;
+        [Dependency] private readonly IInputManager _inputMgr = default!;
+        [Dependency] private readonly CefManager _cef = default!;
+
+        private RobustRequestHandler _requestHandler = new RobustRequestHandler(Logger.GetSawmill("root"));
+        private LiveData? _data;
+        private string _startUrl = "about:blank";
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public string Url
+        {
+            get => _data == null ? _startUrl : _data.Browser.GetMainFrame().Url;
+            set
+            {
+                if (_data == null)
+                    _startUrl = value;
+                else
+                    _data.Browser.GetMainFrame().LoadUrl(value);
+            }
+        }
+
+        [ViewVariables] public bool IsLoading => _data?.Browser.IsLoading ?? false;
+
+        private readonly Dictionary<Key, ChromiumKeyboardCode> _keyMap = new()
+        {
+            [Key.A] = VKEY_A,
+            [Key.B] = VKEY_B,
+            [Key.C] = VKEY_C,
+            [Key.D] = VKEY_D,
+            [Key.E] = VKEY_E,
+            [Key.F] = VKEY_F,
+            [Key.G] = VKEY_G,
+            [Key.H] = VKEY_H,
+            [Key.I] = VKEY_I,
+            [Key.J] = VKEY_J,
+            [Key.K] = VKEY_K,
+            [Key.L] = VKEY_L,
+            [Key.M] = VKEY_M,
+            [Key.N] = VKEY_N,
+            [Key.O] = VKEY_O,
+            [Key.P] = VKEY_P,
+            [Key.Q] = VKEY_Q,
+            [Key.R] = VKEY_R,
+            [Key.S] = VKEY_S,
+            [Key.T] = VKEY_T,
+            [Key.U] = VKEY_U,
+            [Key.V] = VKEY_V,
+            [Key.W] = VKEY_W,
+            [Key.X] = VKEY_X,
+            [Key.Y] = VKEY_Y,
+            [Key.Z] = VKEY_Z,
+            [Key.Num0] = VKEY_0,
+            [Key.Num1] = VKEY_1,
+            [Key.Num2] = VKEY_2,
+            [Key.Num3] = VKEY_3,
+            [Key.Num4] = VKEY_4,
+            [Key.Num5] = VKEY_5,
+            [Key.Num6] = VKEY_6,
+            [Key.Num7] = VKEY_7,
+            [Key.Num8] = VKEY_8,
+            [Key.Num9] = VKEY_9,
+            [Key.NumpadNum0] = VKEY_NUMPAD0,
+            [Key.NumpadNum1] = VKEY_NUMPAD1,
+            [Key.NumpadNum2] = VKEY_NUMPAD2,
+            [Key.NumpadNum3] = VKEY_NUMPAD3,
+            [Key.NumpadNum4] = VKEY_NUMPAD4,
+            [Key.NumpadNum5] = VKEY_NUMPAD5,
+            [Key.NumpadNum6] = VKEY_NUMPAD6,
+            [Key.NumpadNum7] = VKEY_NUMPAD7,
+            [Key.NumpadNum8] = VKEY_NUMPAD8,
+            [Key.NumpadNum9] = VKEY_NUMPAD9,
+            [Key.Escape] = VKEY_ESCAPE,
+            [Key.Control] = VKEY_CONTROL,
+            [Key.Shift] = VKEY_SHIFT,
+            [Key.Alt] = VKEY_MENU,
+            [Key.LSystem] = VKEY_LWIN,
+            [Key.RSystem] = VKEY_RWIN,
+            [Key.LBracket] = VKEY_OEM_4,
+            [Key.RBracket] = VKEY_OEM_6,
+            [Key.SemiColon] = VKEY_OEM_1,
+            [Key.Comma] = VKEY_OEM_COMMA,
+            [Key.Period] = VKEY_OEM_PERIOD,
+            [Key.Apostrophe] = VKEY_OEM_7,
+            [Key.Slash] = VKEY_OEM_2,
+            [Key.BackSlash] = VKEY_OEM_5,
+            [Key.Tilde] = VKEY_OEM_3,
+            [Key.Equal] = VKEY_OEM_PLUS,
+            [Key.Space] = VKEY_SPACE,
+            [Key.Return] = VKEY_RETURN,
+            [Key.BackSpace] = VKEY_BACK,
+            [Key.Tab] = VKEY_TAB,
+            [Key.PageUp] = VKEY_PRIOR,
+            [Key.PageDown] = VKEY_NEXT,
+            [Key.End] = VKEY_END,
+            [Key.Home] = VKEY_HOME,
+            [Key.Insert] = VKEY_INSERT,
+            [Key.Delete] = VKEY_DELETE,
+            [Key.Minus] = VKEY_OEM_MINUS,
+            [Key.NumpadAdd] = VKEY_ADD,
+            [Key.NumpadSubtract] = VKEY_SUBTRACT,
+            [Key.NumpadDivide] = VKEY_DIVIDE,
+            [Key.NumpadMultiply] = VKEY_MULTIPLY,
+            [Key.NumpadDecimal] = VKEY_DECIMAL,
+            [Key.Left] = VKEY_LEFT,
+            [Key.Right] = VKEY_RIGHT,
+            [Key.Up] = VKEY_UP,
+            [Key.Down] = VKEY_DOWN,
+            [Key.F1] = VKEY_F1,
+            [Key.F2] = VKEY_F2,
+            [Key.F3] = VKEY_F3,
+            [Key.F4] = VKEY_F4,
+            [Key.F5] = VKEY_F5,
+            [Key.F6] = VKEY_F6,
+            [Key.F7] = VKEY_F7,
+            [Key.F8] = VKEY_F8,
+            [Key.F9] = VKEY_F9,
+            [Key.F10] = VKEY_F10,
+            [Key.F11] = VKEY_F11,
+            [Key.F12] = VKEY_F12,
+            [Key.F13] = VKEY_F13,
+            [Key.F14] = VKEY_F14,
+            [Key.F15] = VKEY_F15,
+            [Key.Pause] = VKEY_PAUSE,
+        };
+
+        public BrowserControl()
+        {
+            CanKeyboardFocus = true;
+            KeyboardFocusOnClick = true;
+            MouseFilter = MouseFilterMode.Stop;
+
+            IoCManager.InjectDependencies(this);
+        }
+
+        protected override void EnteredTree()
+        {
+            base.EnteredTree();
+
+            _cef.CheckInitialized();
+
+            DebugTools.AssertNull(_data);
+
+            // A funny render handler that will allow us to render to the control.
+            var renderer = new ControlRenderHandler(this);
+
+            // A funny web cef client. This can actually be shared by multiple browsers, but I'm not sure how the
+            // rendering would work in that case? TODO CEF: Investigate a way to share the web client?
+            var client = new RobustCefClient(renderer, _requestHandler, new RobustLoadHandler());
+
+            var info = CefWindowInfo.Create();
+
+            // FUNFACT: If you DO NOT set these below and set info.Width/info.Height instead, you get an external window
+            // Good to know, huh? Setup is the same, except you can pass a dummy render handler to the CEF client.
+            info.SetAsWindowless(IntPtr.Zero, false); // TODO CEF: Pass parent handle?
+            info.WindowlessRenderingEnabled = true;
+
+            var settings = new CefBrowserSettings()
+            {
+                WindowlessFrameRate = 60
+            };
+
+            // Create the web browser! And by default, we go to about:blank.
+            var browser = CefBrowserHost.CreateBrowserSync(info, client, settings, _startUrl);
+
+            var texture = _clyde.CreateBlankTexture<Bgra32>(Vector2i.One);
+
+            _data = new LiveData(texture, client, browser, renderer);
+        }
+
+        protected override void ExitedTree()
+        {
+            base.ExitedTree();
+
+            DebugTools.AssertNotNull(_data);
+
+            _data!.Texture.Dispose();
+            _data.Browser.GetHost().CloseBrowser(true);
+            _data = null;
+        }
+
+        protected internal override void MouseMove(GUIMouseMoveEventArgs args)
+        {
+            base.MouseMove(args);
+
+            if (_data == null)
+                return;
+
+            // Logger.Debug();
+            var modifiers = CalcMouseModifiers();
+            var mouseEvent = new CefMouseEvent(
+                (int) args.RelativePosition.X, (int) args.RelativePosition.Y,
+                modifiers);
+
+            _data.Browser.GetHost().SendMouseMoveEvent(mouseEvent, false);
+        }
+
+        protected internal override void MouseExited()
+        {
+            base.MouseExited();
+
+            if (_data == null)
+                return;
+
+            var modifiers = CalcMouseModifiers();
+
+            _data.Browser.GetHost().SendMouseMoveEvent(new CefMouseEvent(0, 0, modifiers), true);
+        }
+
+        protected internal override void MouseWheel(GUIMouseWheelEventArgs args)
+        {
+            base.MouseWheel(args);
+
+            if (_data == null)
+                return;
+
+            var modifiers = CalcMouseModifiers();
+            var mouseEvent = new CefMouseEvent(
+                (int) args.RelativePosition.X, (int) args.RelativePosition.Y,
+                modifiers);
+
+            _data.Browser.GetHost().SendMouseWheelEvent(
+                mouseEvent,
+                (int) args.Delta.X * ScrollSpeed,
+                (int) args.Delta.Y * ScrollSpeed);
+        }
+
+        bool IRawInputControl.RawKeyEvent(in GuiRawKeyEvent guiRawEvent)
+        {
+            if (_data == null)
+                return false;
+
+            var host = _data.Browser.GetHost();
+
+            if (guiRawEvent.Key is Key.MouseLeft or Key.MouseMiddle or Key.MouseRight)
+            {
+                var key = guiRawEvent.Key switch
+                {
+                    Key.MouseLeft => CefMouseButtonType.Left,
+                    Key.MouseMiddle => CefMouseButtonType.Middle,
+                    Key.MouseRight => CefMouseButtonType.Right,
+                    _ => default // not possible
+                };
+
+                var mouseEvent = new CefMouseEvent(
+                    guiRawEvent.MouseRelative.X, guiRawEvent.MouseRelative.Y,
+                    CefEventFlags.None);
+
+                // Logger.Debug($"MOUSE: {guiRawEvent.Action} {guiRawEvent.Key} {guiRawEvent.ScanCode} {key}");
+
+                // TODO: double click support?
+                host.SendMouseClickEvent(mouseEvent, key, guiRawEvent.Action == RawKeyAction.Up, 1);
+            }
+            else
+            {
+                // TODO: Handle left/right modifier keys??
+                if (!_keyMap.TryGetValue(guiRawEvent.Key, out var vkKey))
+                    vkKey = default;
+
+                // Logger.Debug($"{guiRawEvent.Action} {guiRawEvent.Key} {guiRawEvent.ScanCode} {vkKey}");
+
+                var lParam = 0;
+                lParam |= (guiRawEvent.ScanCode & 0xFF) << 16;
+                if (guiRawEvent.Action != RawKeyAction.Down)
+                    lParam |= 1 << 30;
+
+                if (guiRawEvent.Action == RawKeyAction.Up)
+                    lParam |= 1 << 31;
+
+                var modifiers = CalcModifiers(guiRawEvent.Key);
+
+                host.SendKeyEvent(new CefKeyEvent
+                {
+                    // Repeats are sent as key downs, I guess?
+                    EventType = guiRawEvent.Action == RawKeyAction.Up
+                        ? CefKeyEventType.KeyUp
+                        : CefKeyEventType.RawKeyDown,
+                    NativeKeyCode = lParam,
+                    // NativeKeyCode = guiRawEvent.ScanCode,
+                    WindowsKeyCode = (int) vkKey,
+                    IsSystemKey = false, // TODO
+                    Modifiers = modifiers
+                });
+
+                if (guiRawEvent.Action != RawKeyAction.Up && guiRawEvent.Key == Key.Return)
+                {
+                    host.SendKeyEvent(new CefKeyEvent
+                    {
+                        EventType = CefKeyEventType.Char,
+                        WindowsKeyCode = '\r',
+                        NativeKeyCode = lParam,
+                        Modifiers = modifiers
+                    });
+                }
+            }
+
+            return true;
+        }
+
+        private CefEventFlags CalcModifiers(Key key)
+        {
+            CefEventFlags modifiers = default;
+
+            if (_inputMgr.IsKeyDown(Key.Control))
+                modifiers |= CefEventFlags.ControlDown;
+
+            if (_inputMgr.IsKeyDown(Key.Alt))
+                modifiers |= CefEventFlags.AltDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            return modifiers;
+        }
+
+        private CefEventFlags CalcMouseModifiers()
+        {
+            CefEventFlags modifiers = default;
+
+            if (_inputMgr.IsKeyDown(Key.Control))
+                modifiers |= CefEventFlags.ControlDown;
+
+            if (_inputMgr.IsKeyDown(Key.Alt))
+                modifiers |= CefEventFlags.AltDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.MouseLeft))
+                modifiers |= CefEventFlags.LeftMouseButton;
+
+            if (_inputMgr.IsKeyDown(Key.MouseMiddle))
+                modifiers |= CefEventFlags.MiddleMouseButton;
+
+            if (_inputMgr.IsKeyDown(Key.MouseRight))
+                modifiers |= CefEventFlags.RightMouseButton;
+
+            return modifiers;
+        }
+
+        protected internal override void TextEntered(GUITextEventArgs args)
+        {
+            base.TextEntered(args);
+
+            if (_data == null)
+                return;
+
+            var host = _data.Browser.GetHost();
+
+            Span<char> buf = stackalloc char[2];
+            var written = args.AsRune.EncodeToUtf16(buf);
+
+            for (var i = 0; i < written; i++)
+            {
+                host.SendKeyEvent(new CefKeyEvent
+                {
+                    EventType = CefKeyEventType.Char,
+                    WindowsKeyCode = buf[i],
+                    Character = buf[i],
+                    UnmodifiedCharacter = buf[i]
+                });
+            }
+        }
+
+        protected override void Resized()
+        {
+            base.Resized();
+
+            if (_data == null)
+                return;
+
+            _data.Browser.GetHost().NotifyMoveOrResizeStarted();
+            _data.Browser.GetHost().WasResized();
+            _data.Texture.Dispose();
+            _data.Texture = _clyde.CreateBlankTexture<Bgra32>((PixelWidth, PixelHeight));
+        }
+
+        protected internal override void Draw(DrawingHandleScreen handle)
+        {
+            base.Draw(handle);
+
+            if (_data == null)
+                return;
+
+            var bufImg = _data.Renderer.Buffer.Buffer;
+
+            _data.Texture.SetSubImage(
+                Vector2i.Zero,
+                bufImg,
+                new UIBox2i(
+                    0, 0,
+                    Math.Min(PixelWidth, bufImg.Width),
+                    Math.Min(PixelHeight, bufImg.Height)));
+
+            handle.DrawTexture(_data.Texture, Vector2.Zero);
+        }
+
+        public void StopLoad()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            _data.Browser.StopLoad();
+        }
+
+        public void Reload()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            _data.Browser.Reload();
+        }
+
+        public bool GoBack()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            if (!_data.Browser.CanGoBack)
+                return false;
+
+            _data.Browser.GoBack();
+            return true;
+        }
+
+        public bool GoForward()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            if (!_data.Browser.CanGoForward)
+                return false;
+
+            _data.Browser.GoForward();
+            return true;
+        }
+
+        public void ExecuteJavaScript(string code)
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            // TODO: this should not run until the browser is done loading seriously does this even work?
+            _data.Browser.GetMainFrame().ExecuteJavaScript(code, string.Empty, 1);
+        }
+
+        public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            _requestHandler.AddResourceRequestHandler(handler);
+        }
+
+        public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            _requestHandler.RemoveResourceRequestHandler(handler);
+        }
+
+        public void AddBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            _requestHandler.AddBeforeBrowseHandler(handler);
+        }
+
+        public void RemoveBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            _requestHandler.RemoveBeforeBrowseHandler(handler);
+        }
+
+        private sealed class LiveData
+        {
+            public OwnedTexture Texture;
+            public readonly RobustCefClient Client;
+            public readonly CefBrowser Browser;
+            public readonly ControlRenderHandler Renderer;
+
+            public LiveData(
+                OwnedTexture texture,
+                RobustCefClient client,
+                CefBrowser browser,
+                ControlRenderHandler renderer)
+            {
+                Texture = texture;
+                Client = client;
+                Browser = browser;
+                Renderer = renderer;
+            }
+        }
+    }
+
+    internal class ControlRenderHandler : CefRenderHandler
+    {
+        public ImageBuffer Buffer { get; }
+        private Control _control;
+
+        internal ControlRenderHandler(Control control)
+        {
+            Buffer = new ImageBuffer(control);
+            _control = control;
+        }
+
+        protected override CefAccessibilityHandler? GetAccessibilityHandler() => null;
+
+        protected override void GetViewRect(CefBrowser browser, out CefRectangle rect)
+        {
+            if (_control.Disposed)
+            {
+                rect = new CefRectangle();
+                return;
+            }
+
+            // TODO CEF: Do we need to pass real screen coords? Cause what we do already works...
+            //var screenCoords = _control.ScreenCoordinates;
+            //rect = new CefRectangle((int) screenCoords.X, (int) screenCoords.Y, (int)Math.Max(_control.Size.X, 1), (int)Math.Max(_control.Size.Y, 1));
+
+            // We do the max between size and 1 because it will LITERALLY CRASH WITHOUT AN ERROR otherwise.
+            rect = new CefRectangle(0, 0, (int) Math.Max(_control.Size.X, 1), (int) Math.Max(_control.Size.Y, 1));
+        }
+
+        protected override bool GetScreenInfo(CefBrowser browser, CefScreenInfo screenInfo)
+        {
+            if (_control.Disposed)
+                return false;
+
+            // TODO CEF: Get actual scale factor?
+            screenInfo.DeviceScaleFactor = 1.0f;
+
+            return true;
+        }
+
+        protected override void OnPopupSize(CefBrowser browser, CefRectangle rect)
+        {
+            if (_control.Disposed)
+                return;
+        }
+
+        protected override void OnPaint(CefBrowser browser, CefPaintElementType type, CefRectangle[] dirtyRects,
+            IntPtr buffer, int width, int height)
+        {
+            if (_control.Disposed)
+                return;
+
+            foreach (var dirtyRect in dirtyRects)
+            {
+                Buffer.UpdateBuffer(width, height, buffer, dirtyRect);
+            }
+        }
+
+        protected override void OnAcceleratedPaint(CefBrowser browser, CefPaintElementType type,
+            CefRectangle[] dirtyRects, IntPtr sharedHandle)
+        {
+            // Unused, but we're forced to implement it so.. NOOP.
+        }
+
+        protected override void OnScrollOffsetChanged(CefBrowser browser, double x, double y)
+        {
+            if (_control.Disposed)
+                return;
+        }
+
+        protected override void OnImeCompositionRangeChanged(CefBrowser browser, CefRange selectedRange,
+            CefRectangle[] characterBounds)
+        {
+            if (_control.Disposed)
+                return;
+        }
+    }
+}

Robust.Client.CEF/BrowserWindowCreateParameters.cs

@@ -0,0 +1,16 @@
+namespace Robust.Client.CEF
+{
+    public sealed class BrowserWindowCreateParameters
+    {
+        public int Width { get; set; }
+        public int Height { get; set; }
+
+        public string Url { get; set; } = "about:blank";
+
+        public BrowserWindowCreateParameters(int width, int height)
+        {
+            Width = width;
+            Height = height;
+        }
+    }
+}

Robust.Client.CEF/CefKeyCodes.cs

@@ -0,0 +1,225 @@
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Robust.Client.CEF
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    [SuppressMessage("ReSharper", "UnusedMember.Global")]
+    [SuppressMessage("ReSharper", "IdentifierTypo")]
+    [SuppressMessage("ReSharper", "CA1069")]
+    [SuppressMessage("ReSharper", "CommentTypo")]
+    internal static class CefKeyCodes
+    {
+        // Taken from https://chromium.googlesource.com/chromium/src/+/refs/heads/main/ui/events/keycodes/keyboard_codes_posix.h
+        // See also https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+        public enum ChromiumKeyboardCode
+        {
+            VKEY_CANCEL = 0x03,
+            VKEY_BACK = 0x08,
+            VKEY_TAB = 0x09,
+            VKEY_BACKTAB = 0x0A,
+            VKEY_CLEAR = 0x0C,
+            VKEY_RETURN = 0x0D,
+            VKEY_SHIFT = 0x10,
+            VKEY_CONTROL = 0x11,
+            VKEY_MENU = 0x12,
+            VKEY_PAUSE = 0x13,
+            VKEY_CAPITAL = 0x14,
+            VKEY_KANA = 0x15,
+            VKEY_HANGUL = 0x15,
+            VKEY_PASTE = 0x16,
+            VKEY_JUNJA = 0x17,
+            VKEY_FINAL = 0x18,
+            VKEY_HANJA = 0x19,
+            VKEY_KANJI = 0x19,
+            VKEY_ESCAPE = 0x1B,
+            VKEY_CONVERT = 0x1C,
+            VKEY_NONCONVERT = 0x1D,
+            VKEY_ACCEPT = 0x1E,
+            VKEY_MODECHANGE = 0x1F,
+            VKEY_SPACE = 0x20,
+            VKEY_PRIOR = 0x21,
+            VKEY_NEXT = 0x22,
+            VKEY_END = 0x23,
+            VKEY_HOME = 0x24,
+            VKEY_LEFT = 0x25,
+            VKEY_UP = 0x26,
+            VKEY_RIGHT = 0x27,
+            VKEY_DOWN = 0x28,
+            VKEY_SELECT = 0x29,
+            VKEY_PRINT = 0x2A,
+            VKEY_EXECUTE = 0x2B,
+            VKEY_SNAPSHOT = 0x2C, // Print Screen / SysRq
+            VKEY_INSERT = 0x2D,
+            VKEY_DELETE = 0x2E,
+            VKEY_HELP = 0x2F,
+            VKEY_0 = 0x30,
+            VKEY_1 = 0x31,
+            VKEY_2 = 0x32,
+            VKEY_3 = 0x33,
+            VKEY_4 = 0x34,
+            VKEY_5 = 0x35,
+            VKEY_6 = 0x36,
+            VKEY_7 = 0x37,
+            VKEY_8 = 0x38,
+            VKEY_9 = 0x39,
+            VKEY_A = 0x41,
+            VKEY_B = 0x42,
+            VKEY_C = 0x43,
+            VKEY_D = 0x44,
+            VKEY_E = 0x45,
+            VKEY_F = 0x46,
+            VKEY_G = 0x47,
+            VKEY_H = 0x48,
+            VKEY_I = 0x49,
+            VKEY_J = 0x4A,
+            VKEY_K = 0x4B,
+            VKEY_L = 0x4C,
+            VKEY_M = 0x4D,
+            VKEY_N = 0x4E,
+            VKEY_O = 0x4F,
+            VKEY_P = 0x50,
+            VKEY_Q = 0x51,
+            VKEY_R = 0x52,
+            VKEY_S = 0x53,
+            VKEY_T = 0x54,
+            VKEY_U = 0x55,
+            VKEY_V = 0x56,
+            VKEY_W = 0x57,
+            VKEY_X = 0x58,
+            VKEY_Y = 0x59,
+            VKEY_Z = 0x5A,
+            VKEY_LWIN = 0x5B,
+            VKEY_COMMAND = VKEY_LWIN, // Provide the Mac name for convenience.
+            VKEY_RWIN = 0x5C,
+            VKEY_APPS = 0x5D,
+            VKEY_SLEEP = 0x5F,
+            VKEY_NUMPAD0 = 0x60,
+            VKEY_NUMPAD1 = 0x61,
+            VKEY_NUMPAD2 = 0x62,
+            VKEY_NUMPAD3 = 0x63,
+            VKEY_NUMPAD4 = 0x64,
+            VKEY_NUMPAD5 = 0x65,
+            VKEY_NUMPAD6 = 0x66,
+            VKEY_NUMPAD7 = 0x67,
+            VKEY_NUMPAD8 = 0x68,
+            VKEY_NUMPAD9 = 0x69,
+            VKEY_MULTIPLY = 0x6A,
+            VKEY_ADD = 0x6B,
+            VKEY_SEPARATOR = 0x6C,
+            VKEY_SUBTRACT = 0x6D,
+            VKEY_DECIMAL = 0x6E,
+            VKEY_DIVIDE = 0x6F,
+            VKEY_F1 = 0x70,
+            VKEY_F2 = 0x71,
+            VKEY_F3 = 0x72,
+            VKEY_F4 = 0x73,
+            VKEY_F5 = 0x74,
+            VKEY_F6 = 0x75,
+            VKEY_F7 = 0x76,
+            VKEY_F8 = 0x77,
+            VKEY_F9 = 0x78,
+            VKEY_F10 = 0x79,
+            VKEY_F11 = 0x7A,
+            VKEY_F12 = 0x7B,
+            VKEY_F13 = 0x7C,
+            VKEY_F14 = 0x7D,
+            VKEY_F15 = 0x7E,
+            VKEY_F16 = 0x7F,
+            VKEY_F17 = 0x80,
+            VKEY_F18 = 0x81,
+            VKEY_F19 = 0x82,
+            VKEY_F20 = 0x83,
+            VKEY_F21 = 0x84,
+            VKEY_F22 = 0x85,
+            VKEY_F23 = 0x86,
+            VKEY_F24 = 0x87,
+            VKEY_NUMLOCK = 0x90,
+            VKEY_SCROLL = 0x91,
+            VKEY_LSHIFT = 0xA0,
+            VKEY_RSHIFT = 0xA1,
+            VKEY_LCONTROL = 0xA2,
+            VKEY_RCONTROL = 0xA3,
+            VKEY_LMENU = 0xA4,
+            VKEY_RMENU = 0xA5,
+            VKEY_BROWSER_BACK = 0xA6,
+            VKEY_BROWSER_FORWARD = 0xA7,
+            VKEY_BROWSER_REFRESH = 0xA8,
+            VKEY_BROWSER_STOP = 0xA9,
+            VKEY_BROWSER_SEARCH = 0xAA,
+            VKEY_BROWSER_FAVORITES = 0xAB,
+            VKEY_BROWSER_HOME = 0xAC,
+            VKEY_VOLUME_MUTE = 0xAD,
+            VKEY_VOLUME_DOWN = 0xAE,
+            VKEY_VOLUME_UP = 0xAF,
+            VKEY_MEDIA_NEXT_TRACK = 0xB0,
+            VKEY_MEDIA_PREV_TRACK = 0xB1,
+            VKEY_MEDIA_STOP = 0xB2,
+            VKEY_MEDIA_PLAY_PAUSE = 0xB3,
+            VKEY_MEDIA_LAUNCH_MAIL = 0xB4,
+            VKEY_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5,
+            VKEY_MEDIA_LAUNCH_APP1 = 0xB6,
+            VKEY_MEDIA_LAUNCH_APP2 = 0xB7,
+            VKEY_OEM_1 = 0xBA,
+            VKEY_OEM_PLUS = 0xBB,
+            VKEY_OEM_COMMA = 0xBC,
+            VKEY_OEM_MINUS = 0xBD,
+            VKEY_OEM_PERIOD = 0xBE,
+            VKEY_OEM_2 = 0xBF,
+            VKEY_OEM_3 = 0xC0,
+            VKEY_OEM_4 = 0xDB,
+            VKEY_OEM_5 = 0xDC,
+            VKEY_OEM_6 = 0xDD,
+            VKEY_OEM_7 = 0xDE,
+            VKEY_OEM_8 = 0xDF,
+            VKEY_OEM_102 = 0xE2,
+            VKEY_OEM_103 = 0xE3, // GTV KEYCODE_MEDIA_REWIND
+            VKEY_OEM_104 = 0xE4, // GTV KEYCODE_MEDIA_FAST_FORWARD
+            VKEY_PROCESSKEY = 0xE5,
+            VKEY_PACKET = 0xE7,
+            VKEY_OEM_ATTN = 0xF0, // JIS DomKey::ALPHANUMERIC
+            VKEY_OEM_FINISH = 0xF1, // JIS DomKey::KATAKANA
+            VKEY_OEM_COPY = 0xF2, // JIS DomKey::HIRAGANA
+            VKEY_DBE_SBCSCHAR = 0xF3, // JIS DomKey::HANKAKU
+            VKEY_DBE_DBCSCHAR = 0xF4, // JIS DomKey::ZENKAKU
+            VKEY_OEM_BACKTAB = 0xF5, // JIS DomKey::ROMAJI
+            VKEY_ATTN = 0xF6, // DomKey::ATTN or JIS DomKey::KANA_MODE
+            VKEY_CRSEL = 0xF7,
+            VKEY_EXSEL = 0xF8,
+            VKEY_EREOF = 0xF9,
+            VKEY_PLAY = 0xFA,
+            VKEY_ZOOM = 0xFB,
+            VKEY_NONAME = 0xFC,
+            VKEY_PA1 = 0xFD,
+            VKEY_OEM_CLEAR = 0xFE,
+            VKEY_UNKNOWN = 0,
+
+            // POSIX specific VKEYs. Note that as of Windows SDK 7.1, 0x97-9F, 0xD8-DA,
+            // and 0xE8 are unassigned.
+            VKEY_WLAN = 0x97,
+            VKEY_POWER = 0x98,
+            VKEY_ASSISTANT = 0x99,
+            VKEY_SETTINGS = 0x9A,
+            VKEY_PRIVACY_SCREEN_TOGGLE = 0x9B,
+            VKEY_BRIGHTNESS_DOWN = 0xD8,
+            VKEY_BRIGHTNESS_UP = 0xD9,
+            VKEY_KBD_BRIGHTNESS_DOWN = 0xDA,
+            VKEY_KBD_BRIGHTNESS_UP = 0xE8,
+
+            // Windows does not have a specific key code for AltGr. We use the unused 0xE1
+            // (VK_OEM_AX) code to represent AltGr, matching the behaviour of Firefox on
+            // Linux.
+            VKEY_ALTGR = 0xE1,
+
+            // Windows does not have a specific key code for Compose. We use the unused
+            // 0xE6 (VK_ICO_CLEAR) code to represent Compose.
+            VKEY_COMPOSE = 0xE6,
+
+            // Windows does not have specific key codes for Media Play and Media Pause. We
+            // use the unused 0xE9 (VK_OEM_RESET) and 0xEA (VK_OEM_JUMP) codes to
+            // represent them.
+            VKEY_MEDIA_PLAY = 0xE9,
+            VKEY_MEDIA_PAUSE = 0xEA,
+        };
+    }
+}

Robust.Client.CEF/CefManager.BrowserWindow.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using Robust.Client.Graphics;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.ViewVariables;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public partial class CefManager
+    {
+        [Dependency] private readonly IClydeInternal _clyde = default!;
+
+        private readonly List<BrowserWindowImpl> _browserWindows = new();
+
+        public IEnumerable<IBrowserWindow> AllBrowserWindows => _browserWindows;
+
+        public IBrowserWindow CreateBrowserWindow(BrowserWindowCreateParameters createParams)
+        {
+            var mainHWnd = (_clyde.MainWindow as IClydeWindowInternal)?.WindowsHWnd ?? 0;
+
+            var info = CefWindowInfo.Create();
+            info.Width = createParams.Width;
+            info.Height = createParams.Height;
+            info.SetAsPopup(mainHWnd, "ss14cef");
+
+            var impl = new BrowserWindowImpl(this);
+
+            var lifeSpanHandler = new WindowLifeSpanHandler(impl);
+            var reqHandler = new RobustRequestHandler(Logger.GetSawmill("root"));
+            var client = new WindowCefClient(lifeSpanHandler, reqHandler);
+            var settings = new CefBrowserSettings();
+
+            impl.Browser = CefBrowserHost.CreateBrowserSync(info, client, settings, createParams.Url);
+            impl.RequestHandler = reqHandler;
+
+            _browserWindows.Add(impl);
+
+            return impl;
+        }
+
+        private sealed class BrowserWindowImpl : IBrowserWindow
+        {
+            private readonly CefManager _manager;
+            internal CefBrowser Browser = default!;
+            internal RobustRequestHandler RequestHandler = default!;
+
+            public Action<RequestHandlerContext>? OnResourceRequest { get; set; }
+
+            [ViewVariables(VVAccess.ReadWrite)]
+            public string Url
+            {
+                get
+                {
+                    CheckClosed();
+                    return Browser.GetMainFrame().Url;
+                }
+                set
+                {
+                    CheckClosed();
+                    Browser.GetMainFrame().LoadUrl(value);
+                }
+            }
+
+            [ViewVariables]
+            public bool IsLoading
+            {
+                get
+                {
+                    CheckClosed();
+                    return Browser.IsLoading;
+                }
+            }
+
+            public BrowserWindowImpl(CefManager manager)
+            {
+                _manager = manager;
+            }
+
+            public void StopLoad()
+            {
+                CheckClosed();
+                Browser.StopLoad();
+            }
+
+            public void Reload()
+            {
+                CheckClosed();
+                Browser.Reload();
+            }
+
+            public bool GoBack()
+            {
+                CheckClosed();
+                if (!Browser.CanGoBack)
+                    return false;
+
+                Browser.GoBack();
+                return true;
+            }
+
+            public bool GoForward()
+            {
+                CheckClosed();
+                if (!Browser.CanGoForward)
+                    return false;
+
+                Browser.GoForward();
+                return true;
+            }
+
+            public void ExecuteJavaScript(string code)
+            {
+                CheckClosed();
+                Browser.GetMainFrame().ExecuteJavaScript(code, string.Empty, 1);
+            }
+
+            public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+            {
+                RequestHandler.AddResourceRequestHandler(handler);
+            }
+
+            public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+            {
+                RequestHandler.RemoveResourceRequestHandler(handler);
+            }
+
+            public void Dispose()
+            {
+                if (Closed)
+                    return;
+
+                Browser.GetHost().CloseBrowser(true);
+                Closed = true;
+            }
+
+            public bool Closed { get; private set; }
+
+            public void OnClose()
+            {
+                Closed = true;
+                _manager._browserWindows.Remove(this);
+                Logger.Debug("Removing window");
+            }
+
+            private void CheckClosed()
+            {
+                if (Closed)
+                    throw new ObjectDisposedException("BrowserWindow");
+            }
+        }
+
+        private sealed class WindowCefClient : CefClient
+        {
+            private readonly CefLifeSpanHandler _lifeSpanHandler;
+            private readonly CefRequestHandler _requestHandler;
+
+            public WindowCefClient(CefLifeSpanHandler lifeSpanHandler, CefRequestHandler requestHandler)
+            {
+                _lifeSpanHandler = lifeSpanHandler;
+                _requestHandler = requestHandler;
+            }
+
+            protected override CefLifeSpanHandler GetLifeSpanHandler() => _lifeSpanHandler;
+            protected override CefRequestHandler GetRequestHandler() => _requestHandler;
+        }
+
+        private sealed class WindowLifeSpanHandler : CefLifeSpanHandler
+        {
+            private readonly BrowserWindowImpl _windowImpl;
+
+            public WindowLifeSpanHandler(BrowserWindowImpl windowImpl)
+            {
+                _windowImpl = windowImpl;
+            }
+
+            protected override void OnBeforeClose(CefBrowser browser)
+            {
+                base.OnBeforeClose(browser);
+
+                _windowImpl.OnClose();
+            }
+        }
+    }
+}

Robust.Client.CEF/CefManager.cs

@@ -0,0 +1,104 @@
+using System;
+using System.IO;
+using JetBrains.Annotations;
+using Robust.Shared.ContentPack;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+// The library we're using right now. TODO CEF: Do we want to use something else? We will need to ship it ourselves if so.
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    // Register this with IoC.
+    // TODO CEF: think if making this inherit CefApp is a good idea...
+    // TODO CEF: A way to handle external window browsers...
+    [UsedImplicitly]
+    public partial class CefManager
+    {
+        private CefApp _app = default!;
+        private bool _initialized = false;
+
+        /// <summary>
+        ///     Call this to initialize CEF.
+        /// </summary>
+        public void Initialize()
+        {
+            DebugTools.Assert(!_initialized);
+
+            string subProcessName;
+            if (OperatingSystem.IsWindows())
+                subProcessName = "Robust.Client.CEF.exe";
+            else if (OperatingSystem.IsLinux())
+                subProcessName = "Robust.Client.CEF";
+            else
+                throw new NotSupportedException("Unsupported platform for CEF!");
+
+            var subProcessPath = PathHelpers.ExecutableRelativeFile(subProcessName);
+
+            var settings = new CefSettings()
+            {
+                WindowlessRenderingEnabled = true, // So we can render to our UI controls.
+                ExternalMessagePump = false, // Unsure, honestly. TODO CEF: Research this?
+                NoSandbox = true, // Not disabling the sandbox crashes CEF.
+                BrowserSubprocessPath = subProcessPath,
+                LocalesDirPath = Path.Combine(PathHelpers.GetExecutableDirectory(), "locales"),
+                ResourcesDirPath = PathHelpers.GetExecutableDirectory(),
+                RemoteDebuggingPort = 9222
+            };
+
+            Logger.Info($"CEF Version: {CefRuntime.ChromeVersion}");
+
+            // --------------------------- README --------------------------------------------------
+            // By the way! You're gonna need the CEF binaries in your client's bin folder.
+            // More specifically, version cef_binary_91.1.21+g9dd45fe+chromium-91.0.4472.114
+            // https://cef-builds.spotifycdn.com/cef_binary_91.1.21%2Bg9dd45fe%2Bchromium-91.0.4472.114_windows64_minimal.tar.bz2
+            // https://cef-builds.spotifycdn.com/cef_binary_91.1.21%2Bg9dd45fe%2Bchromium-91.0.4472.114_linux64_minimal.tar.bz2
+            // Here's how to get it to work:
+            // 1. Copy all the contents of "Release" to the bin folder.
+            // 2. Copy all the contents of "Resources" to the bin folder.
+            // Supposedly, you should just need libcef.so in Release and icudtl.dat in Resources...
+            // The rest might be optional.
+            // Maybe. Good luck! If you get odd crashes with no info and a weird exit code, use GDB!
+            // -------------------------------------------------------------------------------------
+
+            _app = new RobustCefApp();
+
+            // We pass no main arguments...
+            CefRuntime.Initialize(new CefMainArgs(null), settings, _app, IntPtr.Zero);
+
+            // TODO CEF: After this point, debugging breaks. No, literally. My client crashes but ONLY with the debugger.
+            // I have tried using the DEBUG and RELEASE versions of libcef.so, stripped or non-stripped...
+            // And nothing seemed to work. Odd.
+
+            _initialized = true;
+        }
+
+        public void CheckInitialized()
+        {
+            if (!_initialized)
+                throw new InvalidOperationException("CefManager has not been initialized!");
+        }
+
+        /// <summary>
+        ///     Needs to be called regularly for CEF to keep working.
+        /// </summary>
+        public void Update()
+        {
+            DebugTools.Assert(_initialized);
+
+            // Calling this makes CEF do its work, without using its own update loop.
+            CefRuntime.DoMessageLoopWork();
+        }
+
+        /// <summary>
+        ///     Call before program shutdown.
+        /// </summary>
+        public void Shutdown()
+        {
+            DebugTools.Assert(_initialized);
+
+            CefRuntime.Shutdown();
+        }
+    }
+}

Robust.Client.CEF/IBrowserControl.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Robust.Client.CEF
+{
+    public interface IBrowserControl
+    {
+        /// <summary>
+        ///     Current URL of the browser. Set to load a new page.
+        /// </summary>
+        string Url { get; set; }
+
+        /// <summary>
+        ///     Whether the browser is currently loading a page.
+        /// </summary>
+        bool IsLoading { get; }
+
+        /// <summary>
+        ///     Stops loading the current page.
+        /// </summary>
+        void StopLoad();
+
+        /// <summary>
+        ///     Reload the current page.
+        /// </summary>
+        void Reload();
+
+        /// <summary>
+        ///     Navigate back.
+        /// </summary>
+        /// <returns>Whether the browser could navigate back.</returns>
+        bool GoBack();
+
+        /// <summary>
+        ///     Navigate forward.
+        /// </summary>
+        /// <returns>Whether the browser could navigate forward.</returns>
+        bool GoForward();
+
+        /// <summary>
+        ///     Execute arbitrary JavaScript on the current page.
+        /// </summary>
+        /// <param name="code">JavaScript code.</param>
+        void ExecuteJavaScript(string code);
+
+        void AddResourceRequestHandler(Action<RequestHandlerContext> handler);
+        void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler);
+    }
+}

Robust.Client.CEF/IBrowserWindow.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Robust.Client.CEF
+{
+    public interface IBrowserWindow : IBrowserControl, IDisposable
+    {
+        bool Closed { get; }
+    }
+}

Robust.Client.CEF/ImageBuffer.cs

@@ -0,0 +1,42 @@
+using System;
+using Robust.Client.UserInterface;
+using Robust.Client.Utility;
+using Robust.Shared.Maths;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal sealed class ImageBuffer
+    {
+        private readonly Control _control;
+
+        public ImageBuffer(Control control)
+        {
+            _control = control;
+        }
+
+        public Image<Bgra32> Buffer { get; private set; } = new(1, 1);
+
+        public unsafe void UpdateBuffer(int width, int height, IntPtr buffer, CefRectangle dirtyRect)
+        {
+            if (width != Buffer.Width || height != Buffer.Height)
+                UpdateSize(width, height);
+
+            var span = new ReadOnlySpan<Bgra32>((void*) buffer, width * height);
+
+            ImageSharpExt.Blit(
+                span,
+                width,
+                UIBox2i.FromDimensions(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height),
+                Buffer,
+                (dirtyRect.X, dirtyRect.Y));
+        }
+
+        private void UpdateSize(int width, int height)
+        {
+            Buffer = new Image<Bgra32>(width, height);
+        }
+    }
+}

Robust.Client.CEF/Program.cs

@@ -0,0 +1,33 @@
+using System;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public static class Program
+    {
+        // This was supposed to be the main entry for the subprocess program... It doesn't work.
+        public static int Main(string[] args)
+        {
+            // This is a workaround for this to work on UNIX.
+            var argv = args;
+            if (CefRuntime.Platform != CefRuntimePlatform.Windows)
+            {
+                argv = new string[args.Length + 1];
+                Array.Copy(args, 0, argv, 1, args.Length);
+                argv[0] = "-";
+            }
+
+            var mainArgs = new CefMainArgs(argv);
+
+            // This will block executing until the subprocess is shut down.
+            var code = CefRuntime.ExecuteProcess(mainArgs, null, IntPtr.Zero);
+
+            if (code != 0)
+            {
+                System.Console.WriteLine($"CEF Subprocess exited unsuccessfully with exit code {code}! Arguments: {string.Join(' ', argv)}");
+            }
+
+            return code;
+        }
+    }
+}

Robust.Client.CEF/RequestHandlerContext.cs

@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class RequestHandlerContext
+    {
+        internal readonly CefRequest CefRequest;
+
+        public bool IsNavigation { get; }
+        public bool IsDownload { get; }
+        public string RequestInitiator { get; }
+
+        public string Url => CefRequest.Url;
+        public string Method => CefRequest.Method;
+
+        public bool IsHandled { get; private set; }
+
+        public bool IsCancelled { get; private set; }
+
+        internal IRequestResult? Result { get; private set; }
+
+        internal RequestHandlerContext(
+            bool isNavigation,
+            bool isDownload,
+            string requestInitiator,
+            CefRequest cefRequest)
+        {
+            CefRequest = cefRequest;
+            IsNavigation = isNavigation;
+            IsDownload = isDownload;
+            RequestInitiator = requestInitiator;
+        }
+
+        public void DoCancel()
+        {
+            CheckNotHandled();
+
+            IsHandled = true;
+            IsCancelled = true;
+        }
+
+        public void DoRespondStream(Stream stream, string contentType, HttpStatusCode code = HttpStatusCode.OK)
+        {
+            Result = new RequestResultStream(stream, contentType, code);
+        }
+
+        private void CheckNotHandled()
+        {
+            if (IsHandled)
+                throw new InvalidOperationException("Request has already been handled");
+        }
+    }
+}

Robust.Client.CEF/RequestResults.cs

@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal interface IRequestResult
+    {
+        CefResourceHandler MakeHandler();
+    }
+
+    internal sealed class RequestResultStream : IRequestResult
+    {
+        private readonly Stream _stream;
+        private readonly HttpStatusCode _code;
+        private readonly string _contentType;
+
+        public RequestResultStream(Stream stream, string contentType, HttpStatusCode code)
+        {
+            _stream = stream;
+            _code = code;
+            _contentType = contentType;
+        }
+
+        public CefResourceHandler MakeHandler()
+        {
+            return new Handler(_stream, _contentType, _code);
+        }
+
+        private sealed class Handler : CefResourceHandler
+        {
+            // TODO: async
+            // TODO: exception handling
+
+            private readonly Stream _stream;
+            private readonly HttpStatusCode _code;
+            private readonly string _contentType;
+
+            public Handler(Stream stream, string contentType, HttpStatusCode code)
+            {
+                _stream = stream;
+                _code = code;
+                _contentType = contentType;
+            }
+
+            protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
+            {
+                handleRequest = true;
+                return true;
+            }
+
+            protected override void GetResponseHeaders(CefResponse response, out long responseLength, out string? redirectUrl)
+            {
+                response.Status = (int) _code;
+                response.StatusText = _code.ToString();
+                response.MimeType = _contentType;
+
+                if (_stream.CanSeek)
+                    responseLength = _stream.Length;
+                else
+                    responseLength = -1;
+
+                redirectUrl = default;
+            }
+
+            protected override bool Skip(long bytesToSkip, out long bytesSkipped, CefResourceSkipCallback callback)
+            {
+                if (!_stream.CanSeek)
+                {
+                    bytesSkipped = -2;
+                    return false;
+                }
+
+                bytesSkipped = _stream.Seek(bytesToSkip, SeekOrigin.Begin);
+                return true;
+            }
+
+            protected override unsafe bool Read(IntPtr dataOut, int bytesToRead, out int bytesRead, CefResourceReadCallback callback)
+            {
+                var byteSpan = new Span<byte>((void*) dataOut, bytesToRead);
+
+                bytesRead = _stream.Read(byteSpan);
+
+                return bytesRead != 0;
+            }
+
+            protected override void Cancel()
+            {
+            }
+        }
+    }
+}

Robust.Client.CEF/Robust.Client.CEF.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <Import Project="..\MSBuild\Robust.Properties.targets" />
+    <Import Project="..\MSBuild\Robust.Engine.props" />
+    <PropertyGroup>
+        <TargetFramework>net5.0</TargetFramework>
+        <PlatformTarget>x64</PlatformTarget>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <OutputType>WinExe</OutputType>
+    </PropertyGroup>
+
+    <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
+    <Target Name="RobustAfterBuild" AfterTargets="Build" />
+    <Import Project="..\MSBuild\Robust.Engine.targets" />
+
+    <ItemGroup>
+      <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" />
+      <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\cefglue\CefGlue\CefGlue.csproj" />
+      <ProjectReference Include="..\Robust.Client\Robust.Client.csproj" />
+    </ItemGroup>
+
+</Project>

Robust.Client.CEF/RobustCefApp.cs

@@ -0,0 +1,48 @@
+using System;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal class RobustCefApp : CefApp
+    {
+        private readonly BrowserProcessHandler _browserProcessHandler = new();
+        private readonly RenderProcessHandler _renderProcessHandler = new();
+
+        protected override CefBrowserProcessHandler GetBrowserProcessHandler()
+        {
+            return _browserProcessHandler;
+        }
+
+        protected override CefRenderProcessHandler GetRenderProcessHandler()
+        {
+            return _renderProcessHandler;
+        }
+
+        protected override void OnBeforeCommandLineProcessing(string processType, CefCommandLine commandLine)
+        {
+            // Disable zygote on Linux.
+            commandLine.AppendSwitch("--no-zygote");
+
+            //commandLine.AppendSwitch("--disable-gpu");
+            //commandLine.AppendSwitch("--disable-gpu-compositing");
+            //commandLine.AppendSwitch("--in-process-gpu");
+
+            commandLine.AppendSwitch("disable-threaded-scrolling", "1");
+            commandLine.AppendSwitch("disable-features", "TouchpadAndWheelScrollLatching,AsyncWheelEvents");
+
+            if(IoCManager.Instance != null)
+                Logger.Debug($"{commandLine}");
+        }
+
+        private class BrowserProcessHandler : CefBrowserProcessHandler
+        {
+        }
+
+        // TODO CEF: Research - Is this even needed?
+        private class RenderProcessHandler : CefRenderProcessHandler
+        {
+        }
+    }
+}

Robust.Client.CEF/RobustCefClient.cs

@@ -0,0 +1,23 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    // Simple CEF client.
+    internal class RobustCefClient : CefClient
+    {
+        private readonly CefRenderHandler _renderHandler;
+        private readonly CefRequestHandler _requestHandler;
+        private readonly CefLoadHandler _loadHandler;
+
+        internal RobustCefClient(CefRenderHandler handler, CefRequestHandler requestHandler, CefLoadHandler loadHandler)
+        {
+            _renderHandler = handler;
+            _requestHandler = requestHandler;
+            _loadHandler = loadHandler;
+        }
+
+        protected override CefRenderHandler GetRenderHandler() => _renderHandler;
+        protected override CefRequestHandler GetRequestHandler() => _requestHandler;
+        protected override CefLoadHandler GetLoadHandler() => _loadHandler;
+    }
+}

Robust.Client.CEF/RobustLoadHandler.cs

@@ -0,0 +1,17 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class RobustLoadHandler : CefLoadHandler
+    {
+        protected override void OnLoadStart(CefBrowser browser, CefFrame frame, CefTransitionType transitionType)
+        {
+            base.OnLoadStart(browser, frame, transitionType);
+        }
+
+        protected override void OnLoadEnd(CefBrowser browser, CefFrame frame, int httpStatusCode)
+        {
+            base.OnLoadEnd(browser, frame, httpStatusCode);
+        }
+    }
+}

Robust.Client.CEF/RobustRequestHandler.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal sealed class RobustRequestHandler : CefRequestHandler
+    {
+        private readonly ISawmill _sawmill;
+        private readonly List<Action<RequestHandlerContext>> _resourceRequestHandlers = new();
+        private readonly List<Action<BeforeBrowseContext>> _beforeBrowseHandlers = new();
+
+        public RobustRequestHandler(ISawmill sawmill)
+        {
+            _sawmill = sawmill;
+        }
+
+        public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _resourceRequestHandlers.Add(handler);
+            }
+        }
+
+        public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _resourceRequestHandlers.Remove(handler);
+            }
+        }
+
+        public void AddBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                _beforeBrowseHandlers.Add(handler);
+            }
+        }
+
+        public void RemoveBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                _beforeBrowseHandlers.Remove(handler);
+            }
+        }
+
+        protected override CefResourceRequestHandler? GetResourceRequestHandler(
+            CefBrowser browser,
+            CefFrame frame,
+            CefRequest request,
+            bool isNavigation,
+            bool isDownload,
+            string requestInitiator,
+            ref bool disableDefaultHandling)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _sawmill.Debug($"HANDLING REQUEST: {request.Url}");
+
+                var context = new RequestHandlerContext(isNavigation, isDownload, requestInitiator, request);
+
+                foreach (var handler in _resourceRequestHandlers)
+                {
+                    handler(context);
+
+                    if (context.IsHandled)
+                        disableDefaultHandling = true;
+
+                    if (context.IsCancelled)
+                        return null;
+
+                    if (context.Result != null)
+                        return new WrapReaderResourceHandler(context.Result.MakeHandler());
+                }
+            }
+
+            return null;
+        }
+
+        protected override bool OnBeforeBrowse(CefBrowser browser, CefFrame frame, CefRequest request, bool userGesture, bool isRedirect)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                var context = new BeforeBrowseContext(isRedirect, userGesture, request);
+
+                foreach (var handler in _beforeBrowseHandlers)
+                {
+                    handler(context);
+
+                    if (context.IsCancelled)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private sealed class WrapReaderResourceHandler : CefResourceRequestHandler
+        {
+            private readonly CefResourceHandler _handler;
+
+            public WrapReaderResourceHandler(CefResourceHandler handler)
+            {
+                _handler = handler;
+            }
+
+            protected override CefCookieAccessFilter? GetCookieAccessFilter(
+                CefBrowser browser,
+                CefFrame frame,
+                CefRequest request)
+            {
+                return null;
+            }
+
+            protected override CefResourceHandler GetResourceHandler(
+                CefBrowser browser,
+                CefFrame frame,
+                CefRequest request)
+            {
+                return _handler;
+            }
+        }
+    }
+}

Robust.Client.Injectors/Program.cs

@@ -29,26 +29,27 @@ namespace Robust.Build.Tasks
         }
     }
 
+    //formatted according to https://github.com/dotnet/msbuild/blob/main/src/Shared/CanonicalError.cs#L57
     class ConsoleBuildEngine : IBuildEngine
     {
         public void LogErrorEvent(BuildErrorEventArgs e)
         {
-            Console.WriteLine($"ERROR: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL ERROR {e.Code}: {e.Message}");
         }
 
         public void LogWarningEvent(BuildWarningEventArgs e)
         {
-            Console.WriteLine($"WARNING: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL WARNING {e.Code}: {e.Message}");
         }
 
         public void LogMessageEvent(BuildMessageEventArgs e)
         {
-            Console.WriteLine($"MESSAGE: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL MESSAGE {e.Code}: {e.Message}");
         }
 
         public void LogCustomEvent(CustomBuildEventArgs e)
         {
-            Console.WriteLine($"CUSTOM: {e.Message}");
+            Console.WriteLine(e.Message);
         }
 
         public bool BuildProjectFile(string projectFileName, string[] targetNames, IDictionary globalProperties,

Robust.Client.Injectors/RobustXamlILCompiler.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System.Diagnostics;
+using System.Linq;
+using XamlX;
 using XamlX.Ast;
 using XamlX.Emit;
 using XamlX.IL;
@@ -11,11 +13,14 @@ namespace Robust.Build.Tasks
     /// Emitters & Transformers based on:
     /// - https://github.com/AvaloniaUI/Avalonia/blob/c85fa2b9977d251a31886c2534613b4730fbaeaf/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs
     /// - https://github.com/AvaloniaUI/Avalonia/blob/c85fa2b9977d251a31886c2534613b4730fbaeaf/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AddNameScopeRegistration.cs
+    /// - https://github.com/AvaloniaUI/Avalonia/blob/afb8ae6f3c517dae912729511483995b16cb31af/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs
     /// </summary>
     public class RobustXamlILCompiler : XamlILCompiler
     {
         public RobustXamlILCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings, bool fillWithDefaults) : base(configuration, emitMappings, fillWithDefaults)
         {
+            Transformers.Insert(0, new IgnoredDirectivesTransformer());
+
             Transformers.Add(new AddNameScopeRegistration());
             Transformers.Add(new RobustMarkRootObjectScopeNode());
 
@@ -197,5 +202,24 @@ namespace Robust.Build.Tasks
                 }
             }
         }
+
+        class IgnoredDirectivesTransformer : IXamlAstTransformer
+        {
+            public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
+            {
+                if (node is XamlAstObjectNode astNode)
+                {
+                    astNode.Children.RemoveAll(n =>
+                        n is XamlAstXmlDirective dir &&
+                        dir.Namespace == XamlNamespaces.Xaml2006 &&
+                        (dir.Name == "Class" ||
+                         dir.Name == "Precompile" ||
+                         dir.Name == "FieldModifier" ||
+                         dir.Name == "ClassModifier"));
+                }
+
+                return node;
+            }
+        }
     }
 }

Robust.Client.Injectors/XamlCompiler.cs

@@ -280,8 +280,8 @@ namespace Robust.Build.Tasks
                     }
                     catch (Exception e)
                     {
-                        engine.LogWarningEvent(new BuildWarningEventArgs("XAMLIL", "", res.Uri, 0, 0, 0, 0,
-                            e.ToString(), "", "CompileRobustXaml"));
+                        engine.LogErrorEvent(new BuildErrorEventArgs("XAMLIL", "", res.FilePath, 0, 0, 0, 0,
+                            $"{res.FilePath}: {e.Message}", "", "CompileRobustXaml"));
                     }
                 }
                 return true;

Robust.Client.NameGenerator/InvalidXamlRootTypeException.cs

@@ -0,0 +1,19 @@
+using System;
+using Microsoft.CodeAnalysis;
+
+namespace Robust.Client.NameGenerator
+{
+    public class InvalidXamlRootTypeException : Exception
+    {
+        public readonly INamedTypeSymbol ExpectedType;
+        public readonly INamedTypeSymbol ExpectedBaseType;
+        public readonly INamedTypeSymbol Actual;
+
+        public InvalidXamlRootTypeException(INamedTypeSymbol actual, INamedTypeSymbol expectedType, INamedTypeSymbol expectedBaseType)
+        {
+            Actual = actual;
+            ExpectedType = expectedType;
+            ExpectedBaseType = expectedBaseType;
+        }
+    }
+}

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -112,6 +112,12 @@ namespace Robust.Client.AutoGenerated
             compiler.Transform(parsed);
             var initialRoot = (XamlAstObjectNode) parsed.Root;
             var names = NameVisitor.GetNames(initialRoot);
+
+            var rootType = (INamedTypeSymbol)initialRoot.Type.GetClrType().Id;
+            var rootTypeString = rootType.ToString();
+            if (classSymbol.ToString() != rootTypeString && classSymbol.BaseType?.ToString() != rootTypeString)
+                throw new InvalidXamlRootTypeException(rootType, classSymbol, classSymbol.BaseType);
+
             var fieldAccess = classSymbol.IsSealed ? "private" : "protected";
             //var names = NameVisitor.GetNames((XamlAstObjectNode)XDocumentXamlParser.Parse(xamlFile).Root);
             var namedControls = names.Select(info => "        " +
@@ -204,6 +210,21 @@ namespace {nameSpace}
                     var sourceCode = GenerateSourceCode(typeSymbol, txt, comp);
                     context.AddSource($"{typeSymbol.Name}.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
                 }
+                catch (InvalidXamlRootTypeException invRootType)
+                {
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(
+                            new DiagnosticDescriptor(
+                                "RXN0005",
+                                $"XAML-File {xamlFileName} has the wrong root type!",
+                                $"{xamlFileName}: Expected root type '{invRootType.ExpectedType}' or '{invRootType.ExpectedBaseType}', but got '{invRootType.Actual}'.",
+                                "Usage",
+                                DiagnosticSeverity.Error,
+                                true),
+                            Location.Create(xamlFileName, new TextSpan(0, 0),
+                                new LinePositionSpan(new LinePosition(0, 0), new LinePosition(0, 0)))));
+                    continue;
+                }
                 catch (Exception e)
                 {
                     context.ReportDiagnostic(
@@ -257,7 +278,7 @@ namespace {nameSpace}
                     context.ReportDiagnostic(
                         Diagnostic.Create(
                             new DiagnosticDescriptor(
-                                "RXN0004",
+                                "RXN0006",
                                 missingPartialKeywordMessage,
                                 missingPartialKeywordMessage,
                                 "Usage",

Robust.Client/Audio/Midi/MidiManager.cs

@@ -65,7 +65,7 @@ namespace Robust.Client.Audio.Midi
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IConfigurationManager _cfgMan = default!;
 
-        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+        private SharedBroadphaseSystem _broadPhaseSystem = default!;
 
         [ViewVariables]
         public bool IsAvailable
@@ -94,7 +94,7 @@ namespace Robust.Client.Audio.Midi
             get => _volume;
             set
             {
-                if (MathHelper.CloseTo(_volume, value))
+                if (MathHelper.CloseToPercent(_volume, value))
                     return;
 
                 _cfgMan.SetCVar(CVars.MidiVolume, value);
@@ -175,7 +175,7 @@ namespace Robust.Client.Audio.Midi
             _midiThread = new Thread(ThreadUpdate);
             _midiThread.Start();
 
-            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
+            _broadPhaseSystem = EntitySystem.Get<SharedBroadphaseSystem>();
             FluidsynthInitialized = true;
         }
 

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.Intrinsics.X86;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
@@ -8,7 +7,6 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 using MidiEvent = NFluidsynth.MidiEvent;
 
@@ -220,7 +218,7 @@ namespace Robust.Client.Audio.Midi
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.ProgramChange(i, value);
 
                 _midiProgram = value;
@@ -234,7 +232,7 @@ namespace Robust.Client.Audio.Midi
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.BankSelect(i, value);
 
                 _midiBank = value;
@@ -248,7 +246,7 @@ namespace Robust.Client.Audio.Midi
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.SoundFontSelect(i, value);
 
                 _midiSoundfont = value;
@@ -575,16 +573,20 @@ namespace Robust.Client.Audio.Midi
                         // Sometimes MIDI files spam these for no good reason and I can't find any info on what they are.
                         case 1:
                         case 5:
+                        // MetaEvent -- SetTempo - 0x51
                         case 81:
+                            // Already handled by the player.
+                            return;
                         // System Messages - 0xF0
                         case 240:
-                            switch (midiEvent.Control)
+                            switch ((byte)midiEvent.Control)
                             {
                                 case 11:
                                     _synth.AllNotesOff(midiEvent.Channel);
                                     break;
                             }
-                            return;
+
+                            break;
 
                         default:
                             _midiSawmill.Warning("Unhandled midi event of type {0}", midiEvent.Type, midiEvent);
@@ -634,7 +636,7 @@ namespace Robust.Client.Audio.Midi
             _sequencer?.UnregisterClient(_debugRegister);
             _sequencer?.UnregisterClient(_synthRegister);
             _sequencer?.Dispose();
-            
+
             _synth?.Dispose();
             _player?.Dispose();
         }

Robust.Client/ClientIoC.cs

@@ -25,6 +25,7 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Physics;
 using Robust.Shared.Players;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
@@ -76,6 +77,7 @@ namespace Robust.Client
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IMidiManager, MidiManager>();
             IoCManager.Register<IAuthManager, AuthManager>();
+            IoCManager.Register<IPhysicsManager, PhysicsManager>();
             switch (mode)
             {
                 case GameController.DisplayMode.Headless:

Robust.Client/Console/ClientConsoleHost.cs

@@ -83,6 +83,8 @@ namespace Robust.Client.Console
             OutputText(text, true, true);
         }
 
+        public override event ConAnyCommandCallback? AnyCommandExecuted;
+
         /// <inheritdoc />
         public override void ExecuteCommand(ICommonSession? session, string command)
         {
@@ -103,7 +105,11 @@ namespace Robust.Client.Console
             {
                 var command1 = AvailableCommands[commandName];
                 args.RemoveAt(0);
-                command1.Execute(new ConsoleShell(this, null), command, args.ToArray());
+                var shell = new ConsoleShell(this, null);
+                var cmdArgs = args.ToArray();
+
+                AnyCommandExecuted?.Invoke(shell, commandName, command, cmdArgs);
+                command1.Execute(shell, command, cmdArgs);
             }
             else
                 WriteError(null, "Unknown command: " + commandName);

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -24,7 +24,6 @@ namespace Robust.Client.Console.Commands
             var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var compManager = IoCManager.Resolve<IComponentManager>();
             var compFactory = IoCManager.Resolve<IComponentFactory>();
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
@@ -33,7 +32,7 @@ namespace Robust.Client.Console.Commands
 
             component.Owner = entity;
 
-            compManager.AddComponent(entity, component);
+            entityManager.AddComponent(entity, component);
         }
     }
 
@@ -55,12 +54,12 @@ namespace Robust.Client.Console.Commands
             var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var compManager = IoCManager.Resolve<IComponentManager>();
+            var entManager = IoCManager.Resolve<IEntityManager>();
             var compFactory = IoCManager.Resolve<IComponentFactory>();
 
             var registration = compFactory.GetRegistration(componentName);
 
-            compManager.RemoveComponent(entityUid, registration.Type);
+            entManager.RemoveComponent(entityUid, registration.Type);
         }
     }
 }

Robust.Client/Console/Commands/Debug.cs

@@ -27,6 +27,7 @@ using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console.Commands
 {
@@ -160,19 +161,6 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ShowBoundingBoxesCommand : IConsoleCommand
-    {
-        public string Command => "showbb";
-        public string Help => "";
-        public string Description => "Enables debug drawing over all bounding boxes in the game, showing their size.";
-
-        public void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            var mgr = IoCManager.Resolve<IDebugDrawing>();
-            mgr.DebugColliders = !mgr.DebugColliders;
-        }
-    }
-
     internal class ShowPositionsCommand : IConsoleCommand
     {
         public string Command => "showpos";
@@ -459,13 +447,18 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var root = IoCManager.Resolve<IUserInterfaceManager>().RootControl;
+            var uiMgr = IoCManager.Resolve<IUserInterfaceManager>();
             var res = IoCManager.Resolve<IResourceManager>();
 
             using (var stream = res.UserData.Create(new ResourcePath("/guidump.txt")))
             using (var writer = new StreamWriter(stream, EncodingHelpers.UTF8))
             {
-                _writeNode(root, 0, writer);
+                foreach (var root in uiMgr.AllRoots)
+                {
+                    writer.WriteLine($"ROOT: {root}");
+                    _writeNode(root, 0, writer);
+                    writer.WriteLine("---------------");
+                }
             }
 
             shell.WriteLine("Saved guidump");
@@ -475,7 +468,7 @@ namespace Robust.Client.Console.Commands
         {
             var indentation = new string(' ', indents * 2);
             writer.WriteLine("{0}{1}", indentation, control);
-            foreach (var (key, value) in _propertyValuesFor(control))
+            foreach (var (key, value) in PropertyValuesFor(control))
             {
                 writer.WriteLine("{2} * {0}: {1}", key, value, indentation);
             }
@@ -486,14 +479,14 @@ namespace Robust.Client.Console.Commands
             }
         }
 
-        private static List<(string, string)> _propertyValuesFor(Control control)
+        internal static List<(string, string)> PropertyValuesFor(Control control)
         {
             var members = new List<(string, string)>();
             var type = control.GetType();
 
             foreach (var fieldInfo in type.GetAllFields())
             {
-                if (fieldInfo.GetCustomAttribute<ViewVariablesAttribute>() == null)
+                if (!ViewVariablesUtility.TryGetViewVariablesAccess(fieldInfo, out _))
                 {
                     continue;
                 }
@@ -503,7 +496,7 @@ namespace Robust.Client.Console.Commands
 
             foreach (var propertyInfo in type.GetAllProperties())
             {
-                if (propertyInfo.GetCustomAttribute<ViewVariablesAttribute>() == null)
+                if (!ViewVariablesUtility.TryGetViewVariablesAccess(propertyInfo, out _))
                 {
                     continue;
                 }
@@ -536,7 +529,10 @@ namespace Robust.Client.Console.Commands
             var scroll = new ScrollContainer();
             tabContainer.AddChild(scroll);
             //scroll.SetAnchorAndMarginPreset(Control.LayoutPreset.Wide);
-            var vBox = new VBoxContainer();
+            var vBox = new BoxContainer
+            {
+                Orientation = LayoutOrientation.Vertical
+            };
             scroll.AddChild(vBox);
 
             var progressBar = new ProgressBar { MaxValue = 10, Value = 5 };
@@ -594,7 +590,10 @@ namespace Robust.Client.Console.Commands
             }
 
             var group = new ButtonGroup();
-            var vBoxRadioButtons = new VBoxContainer();
+            var vBoxRadioButtons = new BoxContainer
+            {
+                Orientation = LayoutOrientation.Vertical
+            };
             for (var i = 0; i < 10; i++)
             {
                 vBoxRadioButtons.AddChild(new Button
@@ -610,8 +609,9 @@ namespace Robust.Client.Console.Commands
 
             TabContainer.SetTabTitle(vBoxRadioButtons, "Radio buttons!!");
 
-            tabContainer.AddChild(new VBoxContainer
+            tabContainer.AddChild(new BoxContainer
             {
+                Orientation = LayoutOrientation.Vertical,
                 Name = "Slider",
                 Children =
                 {
@@ -619,8 +619,9 @@ namespace Robust.Client.Console.Commands
                 }
             });
 
-            tabContainer.AddChild(new HSplitContainer
+            tabContainer.AddChild(new SplitContainer
             {
+                Orientation = SplitContainer.SplitOrientation.Horizontal,
                 Children =
                 {
                     new PanelContainer
@@ -863,7 +864,7 @@ namespace Robust.Client.Console.Commands
             var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
             var chunk = internalGrid.GetChunk(chunkIndex);
 
-            shell.WriteLine($"worldBounds: {chunk.CalcWorldBounds()} localBounds: {chunk.CalcLocalBounds()}");
+            shell.WriteLine($"worldBounds: {chunk.CalcWorldAABB()} localBounds: {chunk.CalcLocalBounds()}");
         }
     }
 

Robust.Client/Console/Commands/DebugAnchoredCommand.cs

@@ -0,0 +1,19 @@
+#if DEBUG
+using Robust.Client.Debugging;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public sealed class DebugAnchoredCommand : IConsoleCommand
+    {
+        public string Command => "showanchored";
+        public string Description => $"Shows anchored entities on a particular tile";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<DebugAnchoringSystem>().Enabled ^= true;
+        }
+    }
+}
+#endif

Robust.Client/Console/Commands/GridChunkBBCommand.cs

@@ -0,0 +1,17 @@
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public class GridChunkBBCommand : IConsoleCommand
+    {
+        public string Command => "showchunkbb";
+        public string Description => "Displays chunk bounds for the purposes of rendering";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<GridChunkBoundsDebugSystem>().Enabled ^= true;
+        }
+    }
+}

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -7,8 +7,8 @@ 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 string Description => $"Shows a debug physics overlay. The arg supplied specifies the overlay.";
+        public string Help => $"{Command} <contactnormals / contactpoints / shapes / shapeinfo>";
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             if (args.Length != 1)
@@ -30,6 +30,9 @@ namespace Robust.Client.Console.Commands
                 case "shapes":
                     system.Flags ^= PhysicsDebugFlags.Shapes;
                     break;
+                case "shapeinfo":
+                    system.Flags ^= PhysicsDebugFlags.ShapeInfo;
+                    break;
                 default:
                     shell.WriteLine($"{args[0]} is not a recognised overlay");
                     return;

Robust.Client/Console/WatchWindow.cs

@@ -11,6 +11,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Timing;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console
 {
@@ -18,7 +19,7 @@ namespace Robust.Client.Console
     {
         private readonly IReflectionManager _reflectionManager;
 
-        private readonly VBoxContainer _watchesVBox;
+        private readonly BoxContainer _watchesVBox;
         private readonly LineEdit _addWatchEdit;
         private readonly Button _addWatchButton;
 
@@ -31,17 +32,20 @@ namespace Robust.Client.Console
 
             Title = "Watch Window";
 
-            var mainVBox = new VBoxContainer
+            var mainVBox = new BoxContainer
             {
+                Orientation = LayoutOrientation.Vertical,
                 MinSize = (500, 300),
                 Children =
                 {
-                    (_watchesVBox = new VBoxContainer
+                    (_watchesVBox = new BoxContainer
                     {
+                        Orientation = LayoutOrientation.Vertical,
                         VerticalExpand = true
                     }),
-                    new HBoxContainer
+                    new BoxContainer
                     {
+                        Orientation = LayoutOrientation.Horizontal,
                         Children =
                         {
                             (_addWatchEdit = new HistoryLineEdit
@@ -105,8 +109,9 @@ namespace Robust.Client.Console
                 Button delButton;
                 _runner = runner;
 
-                AddChild(new HBoxContainer
+                AddChild(new BoxContainer
                 {
+                    Orientation = LayoutOrientation.Horizontal,
                     Children =
                     {
                         (_outputLabel = new Label
@@ -166,8 +171,9 @@ namespace Robust.Client.Console
             public CompilationErrorControl(string message)
             {
                 Button delButton;
-                AddChild(new HBoxContainer
+                AddChild(new BoxContainer
                 {
+                    Orientation = LayoutOrientation.Horizontal,
                     Children =
                     {
                         new Label

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -0,0 +1,96 @@
+#if DEBUG
+using System.Text;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Debugging
+{
+    public sealed class DebugAnchoringSystem : EntitySystem
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IInputManager _inputManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
+
+        private Label? _label;
+
+        private (GridId GridId, TileRef Tile)? _hovered;
+
+        public bool Enabled
+        {
+            get => _enabled;
+            set
+            {
+                if (_enabled == value) return;
+
+                _enabled = value;
+
+                if (_enabled)
+                {
+                    _label = new Label();
+                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+                }
+                else
+                {
+                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.RemoveChild(_label!);
+                    _label = null;
+                    _hovered = null;
+                }
+            }
+        }
+
+        private bool _enabled;
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+            if (!Enabled) return;
+
+            if (_label == null)
+            {
+                DebugTools.Assert($"Debug Label for {nameof(DebugAnchoringSystem)} is null!");
+                return;
+            }
+
+            var mouseSpot = _inputManager.MouseScreenPosition;
+            var spot = _eyeManager.ScreenToMap(mouseSpot);
+
+            if (!_mapManager.TryFindGridAt(spot, out var grid))
+            {
+                _label.Text = string.Empty;
+                _hovered = null;
+                return;
+            }
+
+            var tile = grid.GetTileRef(spot);
+            _label.Position = mouseSpot.Position + new Vector2(32, 0);
+
+            if (_hovered?.GridId == grid.Index && _hovered?.Tile == tile) return;
+
+            _hovered = (grid.Index, tile);
+
+            var text = new StringBuilder();
+
+            foreach (var ent in grid.GetAnchoredEntities(spot))
+            {
+                if (!EntityManager.TryGetEntity(ent, out var entity))
+                {
+                    text.AppendLine($"uid: {ent}, invalid");
+                }
+                else
+                {
+                    text.AppendLine($"uid: {ent}, {entity.Name}");
+                }
+            }
+
+            _label.Text = text.ToString();
+        }
+    }
+}
+#endif

Robust.Client/Debugging/DebugDrawing.cs

@@ -1,19 +1,8 @@
-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
 {
@@ -22,39 +11,10 @@ namespace Robust.Client.Debugging
     {
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IEntityLookup _lookup = default!;
-        [Dependency] private readonly IMapManager _mapManager = default!;
-        [Dependency] private readonly IInputManager _inputManager = default!;
 
-        private bool _debugColliders;
         private bool _debugPositions;
 
-        /// <inheritdoc />
-        public bool DebugColliders
-        {
-            get => _debugColliders;
-            set
-            {
-                if (value == DebugColliders)
-                {
-                    return;
-                }
-
-                _debugColliders = value;
-
-                if (value && !_overlayManager.HasOverlay<PhysicsOverlay>())
-                {
-                    _overlayManager.AddOverlay(new PhysicsOverlay(_eyeManager,
-                        _prototypeManager, _inputManager, _mapManager));
-                }
-                else
-                {
-                    _overlayManager.RemoveOverlay<PhysicsOverlay>();
-                }
-            }
-        }
-
         /// <inheritdoc />
         public bool DebugPositions
         {
@@ -79,186 +39,6 @@ namespace Robust.Client.Debugging
             }
         }
 
-        private class PhysicsOverlay : Overlay
-        {
-            private readonly IEyeManager _eyeManager;
-            private readonly IMapManager _mapManager;
-            private readonly IInputManager _inputManager;
-
-            public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
-            private readonly ShaderInstance _shader;
-            private readonly Font _font;
-
-            private Vector2 _hoverStartScreen = Vector2.Zero;
-            private List<IPhysBody> _hoverBodies = new();
-
-
-            public PhysicsOverlay(IEyeManager eyeMan, IPrototypeManager protoMan, IInputManager inputManager, IMapManager mapManager)
-            {
-                _eyeManager = eyeMan;
-                _inputManager = inputManager;
-                _mapManager = mapManager;
-
-                _shader = protoMan.Index<ShaderPrototype>("unshaded").Instance();
-                var cache = IoCManager.Resolve<IResourceCache>();
-                _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
-            }
-
-            /// <inheritdoc />
-            protected internal override void Draw(in OverlayDrawArgs args)
-            {
-                switch (args.Space)
-                {
-                    case OverlaySpace.ScreenSpace:
-                        DrawScreen(args);
-                        break;
-                    case OverlaySpace.WorldSpace:
-                        DrawWorld(args);
-                        break;
-                }
-
-            }
-
-            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;
-
-                foreach (var body in _hoverBodies)
-                {
-                    if (body != _hoverBodies[0])
-                    {
-                        screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), "------");
-                        row++;
-                    }
-
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Owner}");
-                    row++;
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
-                    row++;
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
-                    row++;
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
-                    row++;
-                }
-
-            }
-
-            private void DrawWorld(in OverlayDrawArgs args)
-            {
-                var worldHandle = args.WorldHandle;
-                worldHandle.UseShader(_shader);
-                var drawing = new PhysDrawingAdapter(worldHandle);
-
-                _hoverBodies.Clear();
-                var mouseScreenPos = _inputManager.MouseScreenPosition;
-                var mouseWorldPos = _eyeManager.ScreenToMap(mouseScreenPos).Position;
-                _hoverStartScreen = mouseScreenPos.Position;
-
-                var viewport = _eyeManager.GetWorldViewport();
-
-                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 EntitySystem.Get<SharedBroadPhaseSystem>().GetCollidingEntities(mapId, viewport))
-                {
-                    // all entities have a TransformComponent
-                    var transform = physBody.Owner.Transform;
-
-                    var worldBox = physBody.GetWorldAABB();
-                    if (worldBox.IsEmpty()) continue;
-
-                    foreach (var fixture in physBody.Fixtures)
-                    {
-                        var shape = fixture.Shape;
-                        var sleepPercent = physBody.Awake ? 0.0f : 1.0f;
-                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport, sleepPercent);
-                        drawing.SetTransform(in Matrix3.Identity);
-                    }
-
-                    foreach (var joint in physBody.Joints)
-                    {
-                        if (drawnJoints.Contains(joint)) continue;
-                        drawnJoints.Add(joint);
-
-                        joint.DebugDraw(drawing, in viewport);
-                        drawing.SetTransform(in Matrix3.Identity);
-                    }
-
-                    if (worldBox.Contains(mouseWorldPos))
-                    {
-                        _hoverBodies.Add(physBody);
-                    }
-
-                    // draw AABB
-                    worldHandle.DrawRect(worldBox, colorEdge, false);
-                }
-            }
-
-            private class PhysDrawingAdapter : DebugDrawingHandle
-            {
-                private readonly DrawingHandleWorld _handle;
-
-                public PhysDrawingAdapter(DrawingHandleWorld worldHandle)
-                {
-                    _handle = worldHandle;
-                }
-
-                public override Color WakeMixColor => Color.White;
-                public override Color GridFillColor => Color.Blue.WithAlpha(0.05f);
-                public override Color RectFillColor => Color.Green.WithAlpha(0.25f);
-
-                public override Color CalcWakeColor(Color color, float wakePercent)
-                {
-                    var percent = MathHelper.Clamp(wakePercent, 0, 1);
-
-                    var r = 1 - (percent * (1 - color.R));
-                    var g = 1 - (percent * (1 - color.G));
-                    var b = 1 - (percent * (1 - color.B));
-
-                    return new Color(r, g, b, color.A);
-                }
-
-                public override void DrawRect(in Box2 box, in Color color)
-                {
-                    _handle.DrawRect(box, color);
-                }
-
-                public override void DrawRect(in Box2Rotated box, in Color color)
-                {
-                    _handle.DrawRect(box, color);
-                }
-
-                public override void DrawCircle(Vector2 origin, float radius, in Color color)
-                {
-                    _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);
-                }
-
-
-            }
-        }
-
         private sealed class EntityPositionOverlay : Overlay
         {
             private readonly IEntityLookup _lookup;

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -20,30 +20,59 @@
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// 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:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// 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.
+
 /* Heavily inspired by Farseer */
 
 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.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Physics;
 using Robust.Shared.Physics.Collision;
+using Robust.Shared.Physics.Collision.Shapes;
 using Robust.Shared.Physics.Dynamics;
 using Robust.Shared.Physics.Dynamics.Contacts;
 
 namespace Robust.Client.Debugging
 {
-    internal sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
+    public sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
     {
         /*
          * Used for debugging shapes, controllers, joints, contacts
          */
 
+        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
+
         private const int MaxContactPoints = 2048;
         internal int PointCount;
 
-        internal ContactPoint[] _points = new ContactPoint[MaxContactPoints];
+        internal ContactPoint[] Points = new ContactPoint[MaxContactPoints];
 
         public PhysicsDebugFlags Flags
         {
@@ -53,7 +82,13 @@ namespace Robust.Client.Debugging
                 if (value == _flags) return;
 
                 if (_flags == PhysicsDebugFlags.None)
-                    IoCManager.Resolve<IOverlayManager>().AddOverlay(new PhysicsDebugOverlay(this));
+                    IoCManager.Resolve<IOverlayManager>().AddOverlay(
+                        new PhysicsDebugOverlay(
+                            IoCManager.Resolve<IEyeManager>(),
+                            IoCManager.Resolve<IInputManager>(),
+                            IoCManager.Resolve<IResourceCache>(),
+                            this,
+                            Get<SharedBroadphaseSystem>()));
 
                 if (value == PhysicsDebugFlags.None)
                     IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
@@ -66,7 +101,7 @@ namespace Robust.Client.Debugging
 
         public override void HandlePreSolve(Contact contact, in Manifold oldManifold)
         {
-            if ((Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            if ((Flags & (PhysicsDebugFlags.ContactPoints | PhysicsDebugFlags.ContactNormals)) != 0)
             {
                 Manifold manifold = contact.Manifold;
 
@@ -75,23 +110,24 @@ namespace Robust.Client.Debugging
 
                 Fixture fixtureA = contact.FixtureA!;
 
-                PointState[] state1, state2;
-                CollisionManager.GetPointStates(out state1, out state2, oldManifold, manifold);
+                var state1 = new PointState[2];
+                var state2 = new PointState[2];
+
+                CollisionManager.GetPointStates(ref state1, ref state2, oldManifold, manifold);
 
                 Span<Vector2> points = stackalloc Vector2[2];
-                Vector2 normal;
-                contact.GetWorldManifold(out normal, points);
+                contact.GetWorldManifold(_physicsManager, out var normal, points);
 
-                for (int i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
+                ContactPoint cp = Points[PointCount];
+                for (var i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
                 {
                     if (fixtureA == null)
-                        _points[i] = new ContactPoint();
+                        Points[i] = new ContactPoint();
 
-                    ContactPoint cp = _points[PointCount];
                     cp.Position = points[i];
                     cp.Normal = normal;
                     cp.State = state2[i];
-                    _points[PointCount] = cp;
+                    Points[PointCount] = cp;
                     ++PointCount;
                 }
             }
@@ -106,59 +142,209 @@ namespace Robust.Client.Debugging
     }
 
     [Flags]
-    internal enum PhysicsDebugFlags : byte
+    public enum PhysicsDebugFlags : byte
     {
         None = 0,
+        /// <summary>
+        /// Shows the world point for each contact in the viewport.
+        /// </summary>
         ContactPoints = 1 << 0,
+        /// <summary>
+        /// Shows the world normal for each contact in the viewport.
+        /// </summary>
         ContactNormals = 1 << 1,
+        /// <summary>
+        /// Shows all physics shapes in the viewport.
+        /// </summary>
         Shapes = 1 << 2,
+        ShapeInfo = 1 << 3,
     }
 
     internal sealed class PhysicsDebugOverlay : Overlay
     {
+        private IEyeManager _eyeManager = default!;
+        private IInputManager _inputManager = default!;
         private DebugPhysicsSystem _physics = default!;
+        private SharedBroadphaseSystem _broadphaseSystem = default!;
 
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+        public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
 
-        public PhysicsDebugOverlay(DebugPhysicsSystem system)
+        private readonly Font _font;
+
+        public PhysicsDebugOverlay(IEyeManager eyeManager, IInputManager inputManager, IResourceCache cache, DebugPhysicsSystem system, SharedBroadphaseSystem broadphaseSystem)
         {
+            _eyeManager = eyeManager;
+            _inputManager = inputManager;
             _physics = system;
+            _broadphaseSystem = broadphaseSystem;
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
-        protected internal override void Draw(in OverlayDrawArgs args)
+        private void DrawWorld(DrawingHandleWorld worldHandle)
         {
-            if (_physics.Flags == PhysicsDebugFlags.None) return;
+            var viewport = _eyeManager.GetWorldViewport();
+            var viewBounds = _eyeManager.GetWorldViewbounds();
+            var mapId = _eyeManager.CurrentMap;
 
-            var worldHandle = args.WorldHandle;
-
-            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0)
+            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0 && !viewport.IsEmpty())
             {
-                // Port DebugDrawing over.
+                foreach (var physBody in _broadphaseSystem.GetCollidingEntities(mapId, viewBounds))
+                {
+                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+
+                    var xform = physBody.GetTransform();
+
+                    const float AlphaModifier = 0.2f;
+
+                    foreach (var fixture in physBody.Fixtures)
+                    {
+                        // Invalid shape - Box2D doesn't check for IsSensor
+                        if (physBody.BodyType == BodyType.Dynamic && fixture.Mass == 0f)
+                        {
+                            DrawShape(worldHandle, fixture, xform, Color.Red.WithAlpha(AlphaModifier));
+                        }
+                        else if (!physBody.CanCollide)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.3f).WithAlpha(AlphaModifier));
+                        }
+                        else if (physBody.BodyType == BodyType.Static)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.9f, 0.5f).WithAlpha(AlphaModifier));
+                        }
+                        else if ((physBody.BodyType & (BodyType.Kinematic | BodyType.KinematicController)) != 0x0)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.9f).WithAlpha(AlphaModifier));
+                        }
+                        else if (!physBody.Awake)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.6f, 0.6f, 0.6f).WithAlpha(AlphaModifier));
+                        }
+                        else
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.9f, 0.7f, 0.7f).WithAlpha(AlphaModifier));
+                        }
+                    }
+                }
             }
 
-            if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            if ((_physics.Flags & (PhysicsDebugFlags.ContactPoints | PhysicsDebugFlags.ContactNormals)) != 0)
             {
                 const float axisScale = 0.3f;
 
-                for (int i = 0; i < _physics.PointCount; ++i)
+                for (var i = 0; i < _physics.PointCount; ++i)
                 {
-                    DebugPhysicsSystem.ContactPoint point = _physics._points[i];
+                    var 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));
+                    const float radius = 0.1f;
+
+                    if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+                    {
+                        if (point.State == PointState.Add)
+                            worldHandle.DrawCircle(point.Position, radius, new Color(255, 77, 243, 255));
+                        else if (point.State == PointState.Persist)
+                            worldHandle.DrawCircle(point.Position, radius, new Color(255, 77, 77, 255));
+                    }
 
                     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));
+                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 255));
                     }
                 }
 
                 _physics.PointCount = 0;
             }
         }
+
+        private void DrawScreen(DrawingHandleScreen screenHandle)
+        {
+            var mapId = _eyeManager.CurrentMap;
+            var mousePos = _inputManager.MouseScreenPosition;
+
+            if ((_physics.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
+            {
+                var hoverBodies = new List<PhysicsComponent>();
+                var bounds = Box2.UnitCentered.Translated(_eyeManager.ScreenToMap(mousePos.Position).Position);
+
+                foreach (var physBody in _broadphaseSystem.GetCollidingEntities(mapId, bounds))
+                {
+                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+                    hoverBodies.Add(physBody);
+                }
+
+                var lineHeight = _font.GetLineHeight(1f);
+                var drawPos = mousePos.Position + new Vector2(20, 0) + new Vector2(0, -(hoverBodies.Count * 4 * lineHeight / 2f));
+                int row = 0;
+
+                foreach (var body in hoverBodies)
+                {
+                    if (body != hoverBodies[0])
+                    {
+                        screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), "------");
+                        row++;
+                    }
+
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Owner}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
+                    row++;
+                }
+            }
+        }
+
+        protected internal override void Draw(in OverlayDrawArgs args)
+        {
+            if (_physics.Flags == PhysicsDebugFlags.None) return;
+
+            switch (args.Space)
+            {
+                case OverlaySpace.ScreenSpace:
+                    DrawScreen((DrawingHandleScreen) args.DrawingHandle);
+                    break;
+                case OverlaySpace.WorldSpace:
+                    DrawWorld((DrawingHandleWorld) args.DrawingHandle);
+                    break;
+            }
+        }
+
+        private void DrawShape(DrawingHandleWorld worldHandle, Fixture fixture, Transform xform, Color color)
+        {
+            switch (fixture.Shape)
+            {
+                case PhysShapeCircle circle:
+                    var center = Transform.Mul(xform, circle.Position);
+                    worldHandle.DrawCircle(center, circle.Radius, color);
+                    break;
+                case EdgeShape edge:
+                    var v1 = Transform.Mul(xform, edge.Vertex1);
+                    var v2 = Transform.Mul(xform, edge.Vertex2);
+                    worldHandle.DrawLine(v1, v2, color);
+
+                    if (edge.OneSided)
+                    {
+                        worldHandle.DrawCircle(v1, 0.5f, color);
+                        worldHandle.DrawCircle(v2, 0.5f, color);
+                    }
+
+                    break;
+                case PolygonShape poly:
+                    Span<Vector2> verts = stackalloc Vector2[poly.Vertices.Length];
+
+                    for (var i = 0; i < verts.Length; i++)
+                    {
+                        verts[i] = Transform.Mul(xform, poly.Vertices[i]);
+                    }
+
+                    worldHandle.DrawPrimitives(DrawPrimitiveTopology.TriangleFan, verts, color);
+                    break;
+                default:
+                    return;
+            }
+        }
     }
 }

Robust.Client/Debugging/IDebugDrawing.cs

@@ -5,11 +5,6 @@
     /// </summary>
     public interface IDebugDrawing
     {
-        /// <summary>
-        /// Toggles the visual overlay of physics bodies for each entity on screen.
-        /// </summary>
-        bool DebugColliders { get; set; }
-
         /// <summary>
         /// Toggles the visual overlay of the local origin for each entity on screen.
         /// </summary>

Robust.Client/GameController/GameController.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
+using System.Runtime;
 using System.Threading.Tasks;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
@@ -139,6 +140,7 @@ namespace Robust.Client
 
             _authManager.LoadFromEnv();
 
+            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
             GC.Collect();
 
             // Setup main loop
@@ -255,6 +257,15 @@ namespace Robust.Client
                 _configurationManager.OverrideConVars(_commandLineArgs.CVars);
             }
 
+            {
+                // Handle GameControllerOptions implicit CVar overrides.
+                _configurationManager.OverrideConVars(new []
+                {
+                    (CVars.DisplayWindowIconSet.Name, options.WindowIconSet.ToString()),
+                    (CVars.DisplaySplashLogo.Name, options.SplashLogo.ToString())
+                });
+            }
+
             ProfileOptSetup.Setup(_configurationManager);
 
             _resourceCache.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
@@ -472,6 +483,8 @@ namespace Robust.Client
 
         internal void Cleanup()
         {
+            _modLoader.Shutdown();
+
             _networkManager.Shutdown("Client shutting down");
             _midiManager.Shutdown();
             IoCManager.Resolve<IEntityLookup>().Shutdown();

Robust.Client/GameControllerOptions.cs

@@ -52,6 +52,16 @@ namespace Robust.Client
         /// </summary>
         public ResourcePath PrototypeDirectory { get; init; } = new(@"/Prototypes/");
 
+        /// <summary>
+        /// Directory resource path containing window icons to load.
+        /// </summary>
+        public ResourcePath WindowIconSet { get; init; } = new("/Textures/Logo/icon");
+
+        /// <summary>
+        /// Resource path for splash image to show when the game starts up.
+        /// </summary>
+        public ResourcePath SplashLogo { get; init; } = new("/Textures/Logo/logo.png");
+
         /// <summary>
         ///     Whether to disable mounting the "Resources/" folder on FULL_RELEASE.
         /// </summary>

Robust.Client/GameObjects/ClientComponentFactory.cs

@@ -25,10 +25,9 @@ namespace Robust.Client.GameObjects
             RegisterClass<InputComponent>();
             RegisterClass<SpriteComponent>();
             RegisterClass<ClientOccluderComponent>();
+            RegisterClass<OccluderTreeComponent>();
             RegisterClass<EyeComponent>();
             RegisterClass<AppearanceComponent>();
-            RegisterClass<AppearanceTestComponent>();
-            RegisterClass<SnapGridComponent>();
             RegisterClass<AnimationPlayerComponent>();
             RegisterClass<TimerComponent>();
 

Robust.Client/GameObjects/Components/Animations/AnimationPlayerComponent.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
 using static Robust.Client.Animations.AnimationPlaybackShared;
@@ -12,11 +11,17 @@ namespace Robust.Client.GameObjects
     /// </summary>
     public sealed class AnimationPlayerComponent : Component
     {
+        // TODO: Give this component a friend someday. Way too much content shit to change atm ._.
+
         public override string Name => "AnimationPlayer";
 
-        private readonly Dictionary<string, AnimationPlayback> _playingAnimations
+        public int PlayingAnimationCount => PlayingAnimations.Count;
+
+        internal readonly Dictionary<string, AnimationPlayback> PlayingAnimations
             = new();
 
+        internal bool HasPlayingAnimation = false;
+
         /// <summary>
         ///     Start playing an animation.
         /// </summary>
@@ -26,50 +31,31 @@ namespace Robust.Client.GameObjects
         /// </param>
         public void Play(Animation animation, string key)
         {
+            EntitySystem.Get<AnimationPlayerSystem>().AddComponent(this);
             var playback = new AnimationPlayback(animation);
 
-            _playingAnimations.Add(key, playback);
+            PlayingAnimations.Add(key, playback);
         }
 
         public bool HasRunningAnimation(string key)
         {
-            return _playingAnimations.ContainsKey(key);
+            return PlayingAnimations.ContainsKey(key);
         }
 
         public void Stop(string key)
         {
-            _playingAnimations.Remove(key);
+            PlayingAnimations.Remove(key);
         }
 
-        internal void Update(float frameTime)
+        /// <summary>
+        /// Temporary method until the event is replaced with eventbus.
+        /// </summary>
+        internal void AnimationComplete(string key)
         {
-            if (_playingAnimations.Count == 0)
-            {
-                return;
-            }
-
-            List<string>? toRemove = null;
-            // TODO: Get rid of this ToArray() allocation.
-            foreach (var (key, playback) in _playingAnimations.ToArray())
-            {
-                var keep = UpdatePlayback(Owner, playback, frameTime);
-                if (!keep)
-                {
-                    toRemove ??= new List<string>();
-                    toRemove.Add(key);
-                }
-            }
-
-            if (toRemove != null)
-            {
-                foreach (var key in toRemove)
-                {
-                    _playingAnimations.Remove(key);
-                    AnimationCompleted?.Invoke(key);
-                }
-            }
+            AnimationCompleted?.Invoke(key);
         }
 
+        [Obsolete("Use AnimationCompletedEvent instead")]
         public event Action<string>? AnimationCompleted;
     }
 }

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

@@ -84,6 +84,23 @@ namespace Robust.Client.GameObjects
             if (curState is not AppearanceComponentState actualState)
                 return;
 
+            var stateDiff = data.Count != actualState.Data.Count;
+
+            if (!stateDiff)
+            {
+                foreach (var (key, value) in data)
+                {
+                    if (!actualState.Data.TryGetValue(key, out var stateValue) ||
+                        !value.Equals(stateValue))
+                    {
+                        stateDiff = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!stateDiff) return;
+
             data = actualState.Data;
             MarkDirty();
         }
@@ -141,22 +158,4 @@ namespace Robust.Client.GameObjects
         {
         }
     }
-
-    sealed class AppearanceTestComponent : Component
-    {
-        public override string Name => "AppearanceTest";
-
-        float time;
-        bool state;
-
-        public void OnUpdate(float frameTime)
-        {
-            time += frameTime;
-            if (time > 1)
-            {
-                time -= 1;
-                Owner.GetComponent<AppearanceComponent>().SetData("test", state = !state);
-            }
-        }
-    }
 }

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

@@ -1,7 +1,5 @@
 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;
 
@@ -10,7 +8,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     ///     Defines data fields used in the <see cref="InputSystem"/>.
     /// </summary>
-    class InputComponent : Component
+    public class InputComponent : Component
     {
         /// <inheritdoc />
         public override string Name => "Input";

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

@@ -80,7 +80,7 @@ namespace Robust.Client.GameObjects
                 var position = Owner.Transform.Coordinates;
                 foreach (var neighbor in grid.GetInDir(position, dir))
                 {
-                    if (Owner.EntityManager.ComponentManager.TryGetComponent(neighbor, out ClientOccluderComponent? comp) && comp.Enabled)
+                    if (Owner.EntityManager.TryGetComponent(neighbor, out ClientOccluderComponent? comp) && comp.Enabled)
                     {
                         Occluding |= oclDir;
                         break;

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

@@ -1,14 +1,6 @@
-using System;
-using System.Collections.Generic;
 using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
 using Robust.Shared.Animations;
-using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameStates;
-using Robust.Shared.IoC;
-using Robust.Shared.Log;
-using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -17,41 +9,28 @@ using Robust.Shared.ViewVariables;
 namespace Robust.Client.GameObjects
 {
     [RegisterComponent]
-    [ComponentReference(typeof(IPointLightComponent))]
-    [NetworkedComponent()]
-    public class PointLightComponent : Component, IPointLightComponent, ISerializationHooks
+    [ComponentReference(typeof(SharedPointLightComponent))]
+    public class PointLightComponent : SharedPointLightComponent, ISerializationHooks
     {
-        [Dependency] private readonly IResourceCache _resourceCache = default!;
-
-        public override string Name => "PointLight";
-
         internal bool TreeUpdateQueued { get; set; }
 
         [ViewVariables(VVAccess.ReadWrite)]
         [Animatable]
-        public Color Color
+        public override Color Color
         {
             get => _color;
-            set => _color = value;
-        }
-
-        [ViewVariables(VVAccess.ReadWrite)]
-        public Vector2 Offset
-        {
-            get => _offset;
-            set => _offset = value;
+            set => base.Color = value;
         }
 
         [ViewVariables(VVAccess.ReadWrite)]
         [Animatable]
-        public bool Enabled
+        public override bool Enabled
         {
             get => _enabled;
             set
             {
                 if (_enabled == value) return;
-
-                _enabled = value;
+                base.Enabled = value;
                 Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, new PointLightUpdateEvent());
             }
         }
@@ -92,7 +71,6 @@ namespace Robust.Client.GameObjects
             set => _rotation = value;
         }
 
-        /// <inheritdoc />
         /// <summary>
         /// The resource path to the mask texture the light will use.
         /// </summary>
@@ -102,8 +80,9 @@ namespace Robust.Client.GameObjects
             get => _maskPath;
             set
             {
+                if (_maskPath?.Equals(value) != false) return;
                 _maskPath = value;
-                UpdateMask();
+                EntitySystem.Get<PointLightSystem>().UpdateMask(this);
             }
         }
 
@@ -141,16 +120,8 @@ namespace Robust.Client.GameObjects
             set => _visibleNested = value;
         }
 
-        [DataField("radius")]
-        private float _radius = 5f;
         [DataField("nestedvisible")]
         private bool _visibleNested = true;
-        [DataField("color")]
-        private Color _color = Color.White;
-        [DataField("offset")]
-        private Vector2 _offset = Vector2.Zero;
-        [DataField("enabled")]
-        private bool _enabled = true;
         [DataField("autoRot")]
         private bool _maskAutoRotate;
         private Angle _rotation;
@@ -159,74 +130,27 @@ namespace Robust.Client.GameObjects
         [DataField("softness")]
         private float _softness = 1f;
         [DataField("mask")]
-        private string? _maskPath;
+        internal string? _maskPath;
 
         /// <summary>
         ///     Radius, in meters.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
         [Animatable]
-        public float Radius
+        public override float Radius
         {
             get => _radius;
             set
             {
-                if (MathHelper.CloseTo(value, _radius)) return;
+                if (MathHelper.CloseToPercent(value, _radius)) return;
 
-                _radius = MathF.Max(value, 0.01f); // setting radius to 0 causes exceptions, so just use a value close enough to zero that it's unnoticeable.
+                base.Radius = value;
                 Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new PointLightRadiusChangedEvent(this));
             }
         }
 
-        private void UpdateMask()
-        {
-            if (_maskPath is not null)
-                Mask = _resourceCache.GetResource<TextureResource>(_maskPath);
-            else
-                Mask = null;
-        }
-
         [ViewVariables]
         internal RenderingTreeComponent? RenderTree { get; set; }
-
-        void ISerializationHooks.AfterDeserialization()
-        {
-            if (_maskPath != null)
-            {
-                Mask = IoCManager.Resolve<IResourceCache>().GetResource<TextureResource>(_maskPath);
-            }
-        }
-
-        protected override void Initialize()
-        {
-            base.Initialize();
-            UpdateMask();
-        }
-
-        protected override void OnRemove()
-        {
-            base.OnRemove();
-
-            var map = Owner.Transform.MapID;
-            if (map != MapId.Nullspace)
-            {
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                    new RenderTreeRemoveLightEvent(this, map));
-            }
-        }
-
-        /// <inheritdoc />
-        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
-        {
-            if (curState == null)
-                return;
-
-            var newState = (PointLightComponentState) curState;
-            Enabled = newState.Enabled;
-            Radius = newState.Radius;
-            Offset = newState.Offset;
-            Color = newState.Color;
-        }
     }
 
     public class PointLightRadiusChangedEvent : EntityEventArgs
@@ -239,7 +163,7 @@ namespace Robust.Client.GameObjects
         }
     }
 
-    internal sealed class PointLightUpdateEvent : EntityEventArgs
+    public sealed class PointLightUpdateEvent : EntityEventArgs
     {
 
     }

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

@@ -228,6 +228,6 @@ namespace Robust.Client.GameObjects
         /// <summary>
         ///     Calculate sprite bounding box in world-space coordinates.
         /// </summary>
-        Box2 CalculateBoundingBox();
+        Box2 CalculateBoundingBox(Vector2 worldPos);
     }
 }

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

@@ -0,0 +1,90 @@
+using System.Collections.Generic;
+using Robust.Client.Graphics;
+using Robust.Client.Graphics.Clyde;
+using Robust.Shared.Console;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.GameObjects
+{
+    public sealed class ShowSpriteBBCommand : IConsoleCommand
+    {
+        public string Command => "showspritebb";
+        public string Description => "Toggle whether sprite bounds are shown";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<SpriteBoundsSystem>().Enabled ^= true;
+        }
+    }
+
+    public sealed class SpriteBoundsSystem : EntitySystem
+    {
+        private SpriteBoundsOverlay? _overlay;
+
+        public bool Enabled
+        {
+            get => _enabled;
+            set
+            {
+                if (_enabled == value) return;
+
+                _enabled = value;
+
+                if (_enabled)
+                {
+                    DebugTools.AssertNull(_overlay);
+                    var overlayManager = IoCManager.Resolve<IOverlayManager>();
+                    _overlay = new SpriteBoundsOverlay(EntitySystem.Get<RenderingTreeSystem>(), IoCManager.Resolve<IEyeManager>());
+                    overlayManager.AddOverlay(_overlay);
+                }
+                else
+                {
+                    if (_overlay == null) return;
+                    var overlayManager = IoCManager.Resolve<IOverlayManager>();
+                    overlayManager.RemoveOverlay(_overlay);
+                    _overlay = null;
+                }
+            }
+        }
+
+        private bool _enabled;
+    }
+
+    public class SpriteBoundsOverlay : Overlay
+    {
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+        private readonly IEyeManager _eyeManager = default!;
+        private RenderingTreeSystem _renderTree;
+
+        public SpriteBoundsOverlay(RenderingTreeSystem renderTree, IEyeManager eyeManager)
+        {
+            _renderTree = renderTree;
+            _eyeManager = eyeManager;
+        }
+
+        protected internal override void Draw(in OverlayDrawArgs args)
+        {
+            var handle = args.WorldHandle;
+            var currentMap = _eyeManager.CurrentMap;
+            var viewport = _eyeManager.GetWorldViewbounds();
+
+            foreach (var comp in _renderTree.GetRenderTrees(currentMap, viewport))
+            {
+                var localAABB = comp.Owner.Transform.InvWorldMatrix.TransformBox(viewport);
+
+                foreach (var sprite in comp.SpriteTree.QueryAabb(localAABB))
+                {
+                    var worldPos = sprite.Owner.Transform.WorldPosition;
+                    var bounds = sprite.CalculateBoundingBox(worldPos);
+                    handle.DrawRect(bounds, Color.Red.WithAlpha(0.2f));
+                    handle.DrawRect(bounds.Scale(0.2f).Translated(-new Vector2(0f, bounds.Extents.Y)), Color.Blue.WithAlpha(0.5f));
+                }
+            }
+        }
+    }
+}

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

@@ -1212,13 +1212,12 @@ namespace Robust.Client.GameObjects
         public IEnumerable<ISpriteLayer> AllLayers => Layers;
 
         // Lobby SpriteView rendering path
-        internal void Render(DrawingHandleWorld drawingHandle, Angle worldRotation, Direction? overrideDirection = null)
+        internal void Render(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Direction? overrideDirection = null)
         {
-            RenderInternal(drawingHandle, worldRotation, Vector2.Zero, overrideDirection);
+            RenderInternal(drawingHandle, eyeRotation, worldRotation, Vector2.Zero, overrideDirection);
         }
 
-        [DataField("noRot")]
-        private bool _screenLock = true;
+        [DataField("noRot")] private bool _screenLock = false;
 
         [DataField("overrideDir")]
         private Direction _overrideDirection = Direction.East;
@@ -1239,7 +1238,7 @@ namespace Robust.Client.GameObjects
         public bool EnableDirectionOverride { get => _enableOverrideDirection; set => _enableOverrideDirection = value; }
 
         // Sprite rendering path
-        internal void Render(DrawingHandleWorld drawingHandle, in Angle worldRotation, in Vector2 worldPosition)
+        internal void Render(DrawingHandleWorld drawingHandle, Angle eyeRotation, in Angle worldRotation, in Vector2 worldPosition)
         {
             Direction? overrideDir = null;
             if (_enableOverrideDirection)
@@ -1247,27 +1246,29 @@ namespace Robust.Client.GameObjects
                 overrideDir = _overrideDirection;
             }
 
-            RenderInternal(drawingHandle, worldRotation, worldPosition, overrideDir);
+            RenderInternal(drawingHandle, eyeRotation, worldRotation, worldPosition, overrideDir);
         }
 
-        private void CalcModelMatrix(int numDirs, Angle worldRotation, Vector2 worldPosition, out Matrix3 modelMatrix)
+        private void CalcModelMatrix(int numDirs, Angle eyeRotation, Angle worldRotation, Vector2 worldPosition, out Matrix3 modelMatrix)
         {
             Angle angle;
 
             if (_screenLock)
             {
-                angle = Angle.Zero;
+                // Negate the eye rotation in the model matrix, so that later when the view matrix is applied the
+                // sprite will be locked upright to the screen
+                angle = new Angle(-eyeRotation.Theta);
             }
             else
             {
-                angle = CalcRectWorldAngle(worldRotation, numDirs);
+                angle = CalcRectWorldAngle(worldRotation + eyeRotation, numDirs) - eyeRotation;
             }
 
             var sWorldRotation = angle;
             modelMatrix = Matrix3.CreateTransform(in worldPosition, in sWorldRotation);
         }
 
-        private void RenderInternal(DrawingHandleWorld drawingHandle, Angle worldRotation, Vector2 worldPosition, Direction? overrideDirection)
+        private void RenderInternal(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Vector2 worldPosition, Direction? overrideDirection)
         {
             var localMatrix = GetLocalMatrix();
 
@@ -1280,17 +1281,17 @@ namespace Robust.Client.GameObjects
 
                 var numDirs = GetLayerDirectionCount(layer);
 
-                CalcModelMatrix(numDirs, worldRotation, worldPosition, out var modelMatrix);
+                CalcModelMatrix(numDirs, eyeRotation, worldRotation, worldPosition, out var modelMatrix);
                 Matrix3.Multiply(ref localMatrix, ref modelMatrix, out var transformMatrix);
                 drawingHandle.SetTransform(in transformMatrix);
 
-                RenderLayer(drawingHandle, layer, worldRotation, overrideDirection);
+                RenderLayer(drawingHandle, layer, eyeRotation, worldRotation, overrideDirection);
             }
         }
 
-        private void RenderLayer(DrawingHandleWorld drawingHandle, Layer layer, Angle worldRotation, Direction? overrideDirection)
+        private void RenderLayer(DrawingHandleWorld drawingHandle, Layer layer, Angle eyeRotation, Angle worldRotation, Direction? overrideDirection)
         {
-            var texture = GetRenderTexture(layer, worldRotation, overrideDirection);
+            var texture = GetRenderTexture(layer, worldRotation + eyeRotation, overrideDirection);
 
             if (layer.Shader != null)
             {
@@ -1510,6 +1511,11 @@ namespace Robust.Client.GameObjects
 
         private void QueueUpdateIsInert()
         {
+            // Look this was an easy way to get bounds checks for layer updates.
+            // If you really want it optimal you'll need to comb through all 2k lines of spritecomponent.
+            if (Owner?.EntityManager?.EventBus != null)
+                UpdateBounds();
+
             if (_inertUpdateQueued)
                 return;
 
@@ -1624,11 +1630,11 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc/>
-        public Box2 CalculateBoundingBox()
+        public Box2 CalculateBoundingBox(Vector2 worldPos)
         {
             // fast check for empty sprites
             if (Layers.Count == 0)
-                return new Box2();
+                return new Box2(worldPos, worldPos);
 
             // we need to calculate bounding box taking into account all nested layers
             // because layers can have offsets, scale or rotation we need to calculate a new BB
@@ -1651,11 +1657,15 @@ namespace Robust.Client.GameObjects
                 new Box2Rotated(spriteBox, Rotation).CalcBoundingBox() : spriteBox;
 
             // move it all to world transform system (with sprite offset)
-            var worldPosition = Owner.Transform.WorldPosition;
-            var worldBB = spriteBB.Translated(Offset + worldPosition);
+            var worldBB = spriteBB.Translated(Offset + worldPos);
             return worldBB;
         }
 
+        internal void UpdateBounds()
+        {
+            Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, new SpriteUpdateEvent());
+        }
+
         /// <summary>
         ///     Enum to "offset" a cardinal direction.
         /// </summary>
@@ -1711,7 +1721,19 @@ namespace Robust.Client.GameObjects
             public bool AutoAnimated = true;
 
             [ViewVariables(VVAccess.ReadWrite)]
-            public Vector2 Offset { get; set; }
+            public Vector2 Offset
+            {
+                get => _offset;
+                set
+                {
+                    if (_offset.EqualsApprox(value)) return;
+
+                    _offset = value;
+                    _parent.UpdateBounds();
+                }
+            }
+
+            private Vector2 _offset;
 
             [ViewVariables]
             public DirectionOffset DirOffset { get; set; }
@@ -1983,7 +2005,6 @@ namespace Robust.Client.GameObjects
                 // TODO: scale & rotation for layers is currently unimplemented.
                 return Box2.CenteredAround(Offset, PixelSize / EyeManager.PixelsPerMeter);
             }
-
         }
 
         void IAnimationProperties.SetAnimatableProperty(string name, object value)

Robust.Client/GameObjects/Components/RenderingTreeComponent.cs

@@ -15,11 +15,13 @@ namespace Robust.Client.GameObjects
         private static Box2 SpriteAabbFunc(in SpriteComponent value)
         {
             var worldPos = value.Owner.Transform.WorldPosition;
+            var worldRot = value.Owner.Transform.WorldRotation;
+            var bounds = new Box2Rotated(value.CalculateBoundingBox(worldPos), worldRot, worldPos);
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
 
-            var pos = worldPos - tree?.Owner.Transform.WorldPosition ?? Vector2.Zero;
+            var localAABB = tree?.Owner.Transform.InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
 
-            return new Box2(pos, pos);
+            return localAABB;
         }
 
         private static Box2 LightAabbFunc(in PointLightComponent value)
@@ -28,30 +30,34 @@ namespace Robust.Client.GameObjects
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
             var boxSize = value.Radius * 2;
 
-            var pos = worldPos - tree?.Owner.Transform.WorldPosition ?? Vector2.Zero;
+            var localPos = tree?.Owner.Transform.InvWorldMatrix.Transform(worldPos) ?? worldPos;
 
-            return Box2.CenteredAround(pos, (boxSize, boxSize));
+            return Box2.CenteredAround(localPos, (boxSize, boxSize));
         }
 
-        internal static Box2 SpriteAabbFunc(SpriteComponent value, Vector2? worldPos = null)
+        internal static Box2 SpriteAabbFunc(SpriteComponent value, Vector2? worldPos = null, Angle? worldRot = null)
         {
             worldPos ??= value.Owner.Transform.WorldPosition;
+            worldRot ??= value.Owner.Transform.WorldRotation;
+            var bounds = new Box2Rotated(value.CalculateBoundingBox(worldPos.Value), worldRot.Value, worldPos.Value);
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
 
-            var pos = worldPos - tree?.Owner.Transform.WorldPosition ?? Vector2.Zero;
+            var localAABB = tree?.Owner.Transform.InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
 
-            return new Box2(pos, pos);
+            return localAABB;
         }
 
         internal static Box2 LightAabbFunc(PointLightComponent value, Vector2? worldPos = null)
         {
+            // Lights are circles so don't need entity's rotation
+
             worldPos ??= value.Owner.Transform.WorldPosition;
             var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
             var boxSize = value.Radius * 2;
 
-            var pos = worldPos - tree?.Owner.Transform.WorldPosition ?? Vector2.Zero;
+            var localPos = tree?.Owner.Transform.InvWorldMatrix.Transform(worldPos.Value) ?? worldPos.Value;
 
-            return Box2.CenteredAround(pos, (boxSize, boxSize));
+            return Box2.CenteredAround(localPos, (boxSize, boxSize));
         }
     }
 }

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Reflection;
@@ -85,6 +86,10 @@ namespace Robust.Client.GameObjects
                 SendMessage(new CloseBoundInterfaceMessage(), uiKey);
             _openInterfaces.Remove(uiKey);
             boundUserInterface.Dispose();
+
+            var playerSession = IoCManager.Resolve<IPlayerManager>().LocalPlayer?.Session;
+            if(playerSession != null)
+                Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, new BoundUIClosedEvent(uiKey, Owner.Uid, playerSession));
         }
 
         internal void SendMessage(BoundUserInterfaceMessage message, object uiKey)

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -1,15 +1,98 @@
+using System.Collections.Generic;
+using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
-    internal sealed class AnimationPlayerSystem : EntitySystem
+    public sealed class AnimationPlayerSystem : EntitySystem
     {
+        private readonly List<AnimationPlayerComponent> _activeAnimations = new();
+
         public override void FrameUpdate(float frameTime)
         {
-            foreach (var animationPlayerComponent in EntityManager.ComponentManager.EntityQuery<AnimationPlayerComponent>(true))
+            for (var i = _activeAnimations.Count - 1; i >= 0; i--)
             {
-                animationPlayerComponent.Update(frameTime);
+                var anim = _activeAnimations[i];
+                if (!Update(anim, frameTime)) continue;
+                _activeAnimations.RemoveSwap(i);
+                anim.HasPlayingAnimation = false;
             }
         }
+
+        internal void AddComponent(AnimationPlayerComponent component)
+        {
+            if (component.HasPlayingAnimation) return;
+            _activeAnimations.Add(component);
+            component.HasPlayingAnimation = true;
+        }
+
+        private bool Update(AnimationPlayerComponent component, float frameTime)
+        {
+            if (component.PlayingAnimationCount == 0 ||
+                component.Deleted)
+                return true;
+
+            var remie = new RemQueue<string>();
+            foreach (var (key, playback) in component.PlayingAnimations)
+            {
+                var keep = AnimationPlaybackShared.UpdatePlayback(component.Owner, playback, frameTime);
+                if (!keep)
+                {
+                    remie.Add(key);
+                }
+            }
+
+            foreach (var key in remie)
+            {
+                component.PlayingAnimations.Remove(key);
+                EntityManager.EventBus.RaiseLocalEvent(component.Owner.Uid, new AnimationCompletedEvent {Uid = component.Owner.Uid, Key = key});
+                component.AnimationComplete(key);
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        ///     Start playing an animation.
+        /// </summary>
+        public void Play(EntityUid uid, Animation animation, string key)
+        {
+            var component = EntityManager.EnsureComponent<AnimationPlayerComponent>(EntityManager.GetEntity(uid));
+            Play(component, animation, key);
+        }
+
+        /// <summary>
+        ///     Start playing an animation.
+        /// </summary>
+        public void Play(AnimationPlayerComponent component, Animation animation, string key)
+        {
+            AddComponent(component);
+            var playback = new AnimationPlaybackShared.AnimationPlayback(animation);
+
+            component.PlayingAnimations.Add(key, playback);
+        }
+
+        public bool HasRunningAnimation(EntityUid uid, string key)
+        {
+            return EntityManager.TryGetComponent(uid, out AnimationPlayerComponent? component) &&
+                   component.PlayingAnimations.ContainsKey(key);
+        }
+
+        public bool HasRunningAnimation(AnimationPlayerComponent component, string key)
+        {
+            return component.PlayingAnimations.ContainsKey(key);
+        }
+
+        public void Stop(AnimationPlayerComponent component, string key)
+        {
+            component.PlayingAnimations.Remove(key);
+        }
+    }
+
+    public sealed class AnimationCompletedEvent : EntityEventArgs
+    {
+        public EntityUid Uid { get; init; }
+        public string Key { get; init; } = string.Empty;
     }
 }

Robust.Client/GameObjects/EntitySystems/AppearanceTestSystem.cs

@@ -1,15 +0,0 @@
-using Robust.Shared.GameObjects;
-
-namespace Robust.Client.GameObjects
-{
-    class AppearanceTestSystem : EntitySystem
-    {
-        public override void Update(float frameTime)
-        {
-            foreach (var appearanceTestComponent in EntityManager.ComponentManager.EntityQuery<AppearanceTestComponent>(true))
-            {
-                appearanceTestComponent.OnUpdate(frameTime);
-            }
-        }
-    }
-}

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.IO;
 using JetBrains.Annotations;
 using Robust.Client.Audio;
 using Robust.Client.Graphics;
@@ -8,6 +10,7 @@ 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;
@@ -23,8 +26,7 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IClydeAudio _clyde = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
-
-        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+        [Dependency] private readonly SharedBroadphaseSystem _broadPhaseSystem = default!;
 
         private readonly List<PlayingStream> _playingClydeStreams = new();
 
@@ -38,7 +40,6 @@ namespace Robust.Client.GameObjects
             SubscribeNetworkEvent<StopAudioMessageClient>(StopAudioMessageHandler);
 
             SubscribeLocalEvent<SoundSystem.QueryAudioSystem>((ev => ev.Audio = this));
-            _broadPhaseSystem = Get<SharedBroadPhaseSystem>();
         }
 
         private void StopAudioMessageHandler(StopAudioMessageClient ev)
@@ -98,6 +99,8 @@ namespace Robust.Client.GameObjects
             // Update positions of streams every frame.
             try
             {
+                var ourPos = _eyeManager.CurrentEye.Position.Position;
+
                 foreach (var stream in _playingClydeStreams)
                 {
                     if (!stream.Source.IsPlaying)
@@ -141,7 +144,7 @@ namespace Robust.Client.GameObjects
                         }
                         else
                         {
-                            var sourceRelative = _eyeManager.CurrentEye.Position.Position - pos.Position;
+                            var sourceRelative = ourPos - pos.Position;
                             var occlusion = 0f;
                             if (sourceRelative.Length > 0)
                             {
@@ -155,14 +158,54 @@ namespace Robust.Client.GameObjects
                                     stream.TrackingEntity);
                             }
 
-                            stream.Source.SetVolume(stream.Volume);
+                            var distance = MathF.Max(stream.ReferenceDistance, MathF.Min(sourceRelative.Length, stream.MaxDistance));
+                            float gain;
+
+                            // Technically these are formulas for gain not decibels but EHHHHHHHH.
+                            switch (stream.Attenuation)
+                            {
+                                case Attenuation.Default:
+                                    gain = 1f;
+                                    break;
+                                // You thought I'd implement clamping per source? Hell no that's just for the overall OpenAL setting
+                                // I didn't even wanna implement this much for linear but figured it'd be cleaner.
+                                case Attenuation.InverseDistanceClamped:
+                                case Attenuation.InverseDistance:
+                                    gain = stream.ReferenceDistance /
+                                           (stream.ReferenceDistance + stream.RolloffFactor * (distance - stream.ReferenceDistance));
+
+                                    break;
+                                case Attenuation.LinearDistanceClamped:
+                                case Attenuation.LinearDistance:
+                                    gain = 1f - stream.RolloffFactor * (distance - stream.ReferenceDistance) /
+                                        (stream.MaxDistance - stream.ReferenceDistance);
+
+                                    break;
+                                case Attenuation.ExponentDistanceClamped:
+                                case Attenuation.ExponentDistance:
+                                    gain = MathF.Pow((distance / stream.ReferenceDistance),
+                                        (-stream.RolloffFactor));
+                                    break;
+                                default:
+                                    throw new ArgumentOutOfRangeException($"No implemented attenuation for {stream.Attenuation.ToString()}");
+                            }
+
+                            var volume = MathF.Pow(10, stream.Volume / 10);
+                            var actualGain = MathF.Max(0f, volume * gain);
+
+                            stream.Source.SetVolumeDirect(actualGain);
                             stream.Source.SetOcclusion(occlusion);
                         }
 
-                        if (!stream.Source.SetPosition(pos.Position))
+                        SetAudioPos(stream, stream.Attenuation != Attenuation.NoAttenuation ? pos.Position : ourPos);
+
+                        void SetAudioPos(PlayingStream stream, Vector2 pos)
                         {
-                            Logger.Warning("Interrupting positional audio, can't set position.");
-                            stream.Source.StopPlaying();
+                            if (!stream.Source.SetPosition(pos))
+                            {
+                                Logger.Warning("Interrupting positional audio, can't set position.");
+                                stream.Source.StopPlaying();
+                            }
                         }
 
                         if (stream.TrackingEntity != null)
@@ -219,6 +262,10 @@ namespace Robust.Client.GameObjects
             var playing = new PlayingStream
             {
                 Source = source,
+                Attenuation = audioParams?.Attenuation ?? Attenuation.Default,
+                MaxDistance = audioParams?.MaxDistance ?? float.MaxValue,
+                ReferenceDistance = audioParams?.ReferenceDistance ?? 1f,
+                RolloffFactor = audioParams?.RolloffFactor ?? 1f,
                 Volume = audioParams?.Volume ?? 0
             };
             _playingClydeStreams.Add(playing);
@@ -265,6 +312,10 @@ namespace Robust.Client.GameObjects
             {
                 Source = source,
                 TrackingEntity = entity,
+                Attenuation = audioParams?.Attenuation ?? Attenuation.Default,
+                MaxDistance = audioParams?.MaxDistance ?? float.MaxValue,
+                ReferenceDistance = audioParams?.ReferenceDistance ?? 1f,
+                RolloffFactor = audioParams?.RolloffFactor ?? 1f,
                 Volume = audioParams?.Volume ?? 0
             };
             _playingClydeStreams.Add(playing);
@@ -301,7 +352,7 @@ namespace Robust.Client.GameObjects
             if (!source.SetPosition(coordinates.ToMapPos(EntityManager)))
             {
                 source.Dispose();
-                Logger.Warning("Can't play positional audio \"{stream.Name}\", can't set position.");
+                Logger.Warning($"Can't play positional audio \"{stream.Name}\", can't set position.");
                 return null;
             }
 
@@ -312,6 +363,10 @@ namespace Robust.Client.GameObjects
             {
                 Source = source,
                 TrackingCoordinates = coordinates,
+                Attenuation = audioParams?.Attenuation ?? Attenuation.Default,
+                MaxDistance = audioParams?.MaxDistance ?? float.MaxValue,
+                ReferenceDistance = audioParams?.ReferenceDistance ?? 1f,
+                RolloffFactor = audioParams?.RolloffFactor ?? 1f,
                 Volume = audioParams?.Volume ?? 0
             };
             _playingClydeStreams.Add(playing);
@@ -327,6 +382,9 @@ namespace Robust.Client.GameObjects
 
             source.SetPitch(audioParams.Value.PitchScale);
             source.SetVolume(audioParams.Value.Volume);
+            source.SetRolloffFactor(audioParams.Value.RolloffFactor);
+            source.SetMaxDistance(audioParams.Value.MaxDistance);
+            source.SetReferenceDistance(audioParams.Value.ReferenceDistance);
             source.SetPlaybackPosition(audioParams.Value.PlayOffsetSeconds);
             source.IsLooping = audioParams.Value.Loop;
         }
@@ -340,6 +398,27 @@ namespace Robust.Client.GameObjects
             public bool Done;
             public float Volume;
 
+            public float MaxDistance;
+            public float ReferenceDistance;
+            public float RolloffFactor;
+
+            public Attenuation Attenuation
+            {
+                get => _attenuation;
+                set
+                {
+                    if (value == _attenuation) return;
+                    _attenuation = value;
+                    if (_attenuation != Attenuation.Default)
+                    {
+                        // Need to disable default attenuation when using a custom one
+                        // Damn Sloth wanting linear ambience sounds so they smoothly cut-off and are short-range
+                        Source.SetRolloffFactor(0f);
+                    }
+                }
+            }
+            private Attenuation _attenuation = Attenuation.Default;
+
             public void Stop()
             {
                 Source.StopPlaying();
@@ -364,6 +443,12 @@ namespace Robust.Client.GameObjects
             return Play(filename, entity, audioParams);
         }
 
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityUid uid, AudioParams? audioParams = null)
+        {
+            return EntityManager.TryGetEntity(uid, out var entity)
+                ? Play(filename, entity, audioParams) : null;
+        }
+
         /// <inheritdoc />
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {

Robust.Client/GameObjects/EntitySystems/ClientContainerSystem.cs

@@ -1,94 +0,0 @@
-using System.Collections.Generic;
-using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-
-namespace Robust.Client.GameObjects
-{
-    public class ClientContainerSystem : ContainerSystem
-    {
-        private readonly HashSet<IEntity> _updateQueue = new();
-
-        public override void Initialize()
-        {
-            base.Initialize();
-
-            SubscribeLocalEvent<UpdateContainerOcclusionMessage>(UpdateContainerOcclusion);
-
-            UpdatesBefore.Add(typeof(SpriteSystem));
-        }
-
-        private void UpdateContainerOcclusion(UpdateContainerOcclusionMessage ev)
-        {
-            _updateQueue.Add(ev.Entity);
-        }
-
-        public override void FrameUpdate(float frameTime)
-        {
-            base.FrameUpdate(frameTime);
-
-            foreach (var toUpdate in _updateQueue)
-            {
-                if (toUpdate.Deleted)
-                {
-                    continue;
-                }
-
-                UpdateEntityRecursively(toUpdate);
-            }
-
-            _updateQueue.Clear();
-        }
-
-        private static void UpdateEntityRecursively(IEntity entity)
-        {
-            // TODO: Since we are recursing down,
-            // we could cache ShowContents data here to speed it up for children.
-            // Am lazy though.
-            UpdateEntity(entity);
-
-            foreach (var child in entity.Transform.Children)
-            {
-                UpdateEntityRecursively(child.Owner);
-            }
-        }
-
-        private static void UpdateEntity(IEntity entity)
-        {
-            if (entity.TryGetComponent(out SpriteComponent? sprite))
-            {
-                sprite.ContainerOccluded = false;
-
-                // We have to recursively scan for containers upwards in case of nested containers.
-                var tempParent = entity;
-                while (tempParent.TryGetContainer(out var container))
-                {
-                    if (!container.ShowContents)
-                    {
-                        sprite.ContainerOccluded = true;
-                        break;
-                    }
-
-                    tempParent = container.Owner;
-                }
-            }
-
-            if (entity.TryGetComponent(out PointLightComponent? light))
-            {
-                light.ContainerOccluded = false;
-
-                // We have to recursively scan for containers upwards in case of nested containers.
-                var tempParent = entity;
-                while (tempParent.TryGetContainer(out var container))
-                {
-                    if (container.OccludesLight)
-                    {
-                        light.ContainerOccluded = true;
-                        break;
-                    }
-
-                    tempParent = container.Owner;
-                }
-            }
-        }
-    }
-}

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -52,7 +52,7 @@ namespace Robust.Client.GameObjects
             while (_dirtyEntities.TryDequeue(out var entity))
             {
                 if (EntityManager.EntityExists(entity)
-                    && ComponentManager.TryGetComponent(entity, out ClientOccluderComponent? occluder)
+                    && EntityManager.TryGetComponent(entity, out ClientOccluderComponent? occluder)
                     && occluder.UpdateGeneration != _updateGeneration)
                 {
                     occluder.Update();
@@ -62,7 +62,7 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        private static void HandleAnchorChanged(EntityUid uid, ClientOccluderComponent component, AnchorStateChangedEvent args)
+        private static void HandleAnchorChanged(EntityUid uid, ClientOccluderComponent component, ref AnchorStateChangedEvent args)
         {
             component.AnchorStateChanged();
         }
@@ -100,7 +100,7 @@ namespace Robust.Client.GameObjects
         {
             foreach (var entity in candidates)
             {
-                if (ComponentManager.HasComponent<ClientOccluderComponent>(entity))
+                if (EntityManager.HasComponent<ClientOccluderComponent>(entity))
                 {
                     _dirtyEntities.Enqueue(entity);
                 }

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
+using static Robust.Shared.Containers.ContainerManagerComponent;
+
+namespace Robust.Client.GameObjects
+{
+    public class ContainerSystem : SharedContainerSystem
+    {
+        [Dependency] private readonly IRobustSerializer _serializer = default!;
+        [Dependency] private readonly IDynamicTypeFactoryInternal _dynFactory = default!;
+
+        private readonly HashSet<IEntity> _updateQueue = new();
+
+        public readonly Dictionary<EntityUid, IContainer> ExpectedEntities = new();
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeLocalEvent<UpdateContainerOcclusionMessage>(UpdateContainerOcclusion);
+            SubscribeLocalEvent<EntityInitializedMessage>(HandleEntityInitialized);
+            SubscribeLocalEvent<ContainerManagerComponent, ComponentHandleState>(HandleComponentState);
+
+            UpdatesBefore.Add(typeof(SpriteSystem));
+        }
+
+        private void UpdateContainerOcclusion(UpdateContainerOcclusionMessage ev)
+        {
+            _updateQueue.Add(ev.Entity);
+        }
+
+        private void HandleEntityInitialized(EntityInitializedMessage ev)
+        {
+            if (!ExpectedEntities.TryGetValue(ev.Entity.Uid, out var container))
+                return;
+
+            RemoveExpectedEntity(ev.Entity.Uid);
+
+            if (container.Deleted)
+                return;
+
+            container.Insert(ev.Entity);
+        }
+
+        private void HandleComponentState(EntityUid uid, ContainerManagerComponent component, ref ComponentHandleState args)
+        {
+            if (args.Current is not ContainerManagerComponentState cast)
+                return;
+
+            // Delete now-gone containers.
+            List<string>? toDelete = null;
+            foreach (var (id, container) in component.Containers)
+            {
+                if (!cast.ContainerSet.Any(data => data.Id == id))
+                {
+                    container.EmptyContainer(true);
+                    container.Shutdown();
+                    toDelete ??= new List<string>();
+                    toDelete.Add(id);
+                }
+            }
+
+            if (toDelete != null)
+            {
+                foreach (var dead in toDelete)
+                {
+                    component.Containers.Remove(dead);
+                }
+            }
+
+            // Add new containers and update existing contents.
+
+            foreach (var (containerType, id, showEnts, occludesLight, entityUids) in cast.ContainerSet)
+            {
+                if (!component.Containers.TryGetValue(id, out var container))
+                {
+                    container = ContainerFactory(component, containerType, id);
+                    component.Containers.Add(id, container);
+                }
+
+                // sync show flag
+                container.ShowContents = showEnts;
+                container.OccludesLight = occludesLight;
+
+                // Remove gone entities.
+                List<IEntity>? toRemove = null;
+                foreach (var entity in container.ContainedEntities)
+                {
+                    if (!entityUids.Contains(entity.Uid))
+                    {
+                        toRemove ??= new List<IEntity>();
+                        toRemove.Add(entity);
+                    }
+                }
+
+                if (toRemove != null)
+                {
+                    foreach (var goner in toRemove)
+                        container.Remove(goner);
+                }
+
+                // Remove entities that were expected, but have been removed from the container.
+                List<EntityUid>? removedExpected = null;
+                foreach (var entityUid in container.ExpectedEntities)
+                {
+                    if (!entityUids.Contains(entityUid))
+                    {
+                        removedExpected ??= new List<EntityUid>();
+                        removedExpected.Add(entityUid);
+                    }
+                }
+
+                if (removedExpected != null)
+                {
+                    foreach (var entityUid in removedExpected)
+                        RemoveExpectedEntity(entityUid);
+                }
+
+                // Add new entities.
+                foreach (var entityUid in entityUids)
+                {
+                    if (!EntityManager.TryGetEntity(entityUid, out var entity))
+                    {
+                        AddExpectedEntity(entityUid, container);
+                        continue;
+                    }
+
+                    if (!container.ContainedEntities.Contains(entity))
+                        container.Insert(entity);
+                }
+            }
+        }
+
+        private IContainer ContainerFactory(ContainerManagerComponent component, string containerType, string id)
+        {
+            var type = _serializer.FindSerializedType(typeof(IContainer), containerType);
+            if (type is null) throw new ArgumentException($"Container of type {containerType} for id {id} cannot be found.");
+
+            var newContainer = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type);
+            newContainer.ID = id;
+            newContainer.Manager = component;
+            return newContainer;
+        }
+
+        public void AddExpectedEntity(EntityUid uid, IContainer container)
+        {
+            if (ExpectedEntities.ContainsKey(uid))
+                return;
+
+            ExpectedEntities.Add(uid, container);
+            container.ExpectedEntities.Add(uid);
+        }
+
+        public void RemoveExpectedEntity(EntityUid uid)
+        {
+            if (!ExpectedEntities.TryGetValue(uid, out var container))
+                return;
+
+            ExpectedEntities.Remove(uid);
+            container.ExpectedEntities.Remove(uid);
+        }
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+
+            foreach (var toUpdate in _updateQueue)
+            {
+                if (toUpdate.Deleted)
+                {
+                    continue;
+                }
+
+                UpdateEntityRecursively(toUpdate);
+            }
+
+            _updateQueue.Clear();
+        }
+
+        private static void UpdateEntityRecursively(IEntity entity)
+        {
+            // TODO: Since we are recursing down,
+            // we could cache ShowContents data here to speed it up for children.
+            // Am lazy though.
+            UpdateEntity(entity);
+
+            foreach (var child in entity.Transform.Children)
+            {
+                UpdateEntityRecursively(child.Owner);
+            }
+        }
+
+        private static void UpdateEntity(IEntity entity)
+        {
+            if (entity.TryGetComponent(out SpriteComponent? sprite))
+            {
+                sprite.ContainerOccluded = false;
+
+                // We have to recursively scan for containers upwards in case of nested containers.
+                var tempParent = entity;
+                while (tempParent.TryGetContainer(out var container))
+                {
+                    if (!container.ShowContents)
+                    {
+                        sprite.ContainerOccluded = true;
+                        break;
+                    }
+
+                    tempParent = container.Owner;
+                }
+            }
+
+            if (entity.TryGetComponent(out PointLightComponent? light))
+            {
+                light.ContainerOccluded = false;
+
+                // We have to recursively scan for containers upwards in case of nested containers.
+                var tempParent = entity;
+                while (tempParent.TryGetContainer(out var container))
+                {
+                    if (container.OccludesLight)
+                    {
+                        light.ContainerOccluded = true;
+                        break;
+                    }
+
+                    tempParent = container.Owner;
+                }
+            }
+        }
+    }
+}

Robust.Client/GameObjects/EntitySystems/DebugGridTileLookupSystem.cs

@@ -60,7 +60,6 @@ namespace Robust.Client.GameObjects
         public override void Shutdown()
         {
             base.Shutdown();
-            UnsubscribeNetworkEvent<SendGridTileLookupMessage>();
             IoCManager.Resolve<IUserInterfaceManager>().StateRoot.RemoveChild(_label);
         }
 

Robust.Client/GameObjects/EntitySystems/DebugLightTreeSystem.cs

@@ -65,14 +65,15 @@ namespace Robust.Client.GameObjects
                 var map = _eyeManager.CurrentMap;
                 if (map == MapId.Nullspace) return;
 
-                var viewport = _eyeManager.GetWorldViewport();
+                var viewport = _eyeManager.GetWorldViewbounds();
+                var worldBounds = viewport.CalcBoundingBox();
 
-                foreach (var tree in _tree.GetLightTrees(map, viewport))
+                foreach (var tree in _tree.GetRenderTrees(map, viewport))
                 {
-                    foreach (var light in tree)
+                    foreach (var light in tree.LightTree)
                     {
                         var aabb = _lookup.GetWorldAabbFromEntity(light.Owner);
-                        if (!aabb.Intersects(viewport)) continue;
+                        if (!aabb.Intersects(worldBounds)) continue;
 
                         args.WorldHandle.DrawRect(aabb, Color.Green.WithAlpha(0.1f));
                     }

Robust.Client/GameObjects/EntitySystems/EyeUpdateSystem.cs

@@ -2,10 +2,12 @@
 using JetBrains.Annotations;
 using Robust.Client.Graphics;
 using Robust.Client.Physics;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
 #nullable enable
@@ -20,12 +22,12 @@ namespace Robust.Client.GameObjects
     {
         // How fast the camera rotates in radians
         private const float CameraRotateSpeed = MathF.PI;
-        private const float CameraSnapTolerance = 0.01f;
 
-#pragma warning disable 649, CS8618
-        // ReSharper disable once NotNullMemberIsNotInitialized
-        [Dependency] private readonly IEyeManager _eyeManager;
-#pragma warning restore 649, CS8618
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+        private bool _isLerping = false;
 
         /// <inheritdoc />
         public override void Initialize()
@@ -55,6 +57,9 @@ namespace Robust.Client.GameObjects
         public override void FrameUpdate(float frameTime)
         {
             var currentEye = _eyeManager.CurrentEye;
+
+            // TODO: Content should have its own way of handling this. We should have a default behavior that they can overwrite.
+            /*
             var inputSystem = EntitySystemManager.GetEntitySystem<InputSystem>();
 
             var direction = 0;
@@ -74,20 +79,26 @@ namespace Robust.Client.GameObjects
                 currentEye.Rotation += CameraRotateSpeed * frameTime * direction;
                 currentEye.Rotation = currentEye.Rotation.Reduced();
             }
-            else
-            {
-                // snap to cardinal directions
-                var closestDir = currentEye.Rotation.GetCardinalDir().ToVec();
-                var currentDir = currentEye.Rotation.ToVec();
+            */
 
-                var dot = Vector2.Dot(closestDir, currentDir);
-                if (MathHelper.CloseTo(dot, 1, CameraSnapTolerance))
-                {
-                    currentEye.Rotation = closestDir.ToAngle();
-                }
+            var playerTransform = _playerManager.LocalPlayer?.ControlledEntity?.Transform;
+
+            if (playerTransform == null) return;
+
+            var gridId = playerTransform.GridID;
+
+            var parent = gridId != GridId.Invalid && EntityManager.TryGetEntity(_mapManager.GetGrid(gridId).GridEntityId, out var gridEnt) ?
+                gridEnt.Transform
+                : _mapManager.GetMapEntity(playerTransform.MapID).Transform;
+
+            if (!_isLerping)
+            {
+                // TODO: Detect parent change and start lerping
+                var parentRotation = parent.WorldRotation;
+                currentEye.Rotation = -parentRotation;
             }
 
-            foreach (var eyeComponent in EntityManager.ComponentManager.EntityQuery<EyeComponent>(true))
+            foreach (var eyeComponent in EntityManager.EntityQuery<EyeComponent>(true))
             {
                 eyeComponent.UpdateEyePosition();
             }

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -0,0 +1,86 @@
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.GameObjects
+{
+    public class GridChunkBoundsDebugSystem : EntitySystem
+    {
+        private GridChunkBoundsOverlay? _overlay;
+
+        public bool Enabled
+        {
+            get => _enabled;
+            set
+            {
+                if (_enabled == value) return;
+
+                _enabled = value;
+
+                if (_enabled)
+                {
+                    DebugTools.Assert(_overlay == null);
+                    _overlay = new GridChunkBoundsOverlay(
+                        IoCManager.Resolve<IEntityManager>(),
+                        IoCManager.Resolve<IEyeManager>(),
+                        IoCManager.Resolve<IMapManager>());
+
+                    IoCManager.Resolve<IOverlayManager>().AddOverlay(_overlay);
+                }
+                else
+                {
+                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(_overlay!);
+                    _overlay = null;
+                }
+            }
+        }
+
+        private bool _enabled;
+    }
+
+    internal sealed class GridChunkBoundsOverlay : Overlay
+    {
+        private readonly IEntityManager _entityManager;
+        private readonly IEyeManager _eyeManager;
+        private readonly IMapManager _mapManager;
+
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+        public GridChunkBoundsOverlay(IEntityManager entManager, IEyeManager eyeManager, IMapManager mapManager)
+        {
+            _entityManager = entManager;
+            _eyeManager = eyeManager;
+            _mapManager = mapManager;
+        }
+
+        protected internal override void Draw(in OverlayDrawArgs args)
+        {
+            var currentMap = _eyeManager.CurrentMap;
+            var viewport = _eyeManager.GetWorldViewport();
+
+            foreach (var grid in _mapManager.FindGridsIntersecting(currentMap, viewport))
+            {
+                var gridEnt = _entityManager.GetEntity(grid.GridEntityId);
+
+                if (!_entityManager.TryGetComponent<PhysicsComponent>(gridEnt.Uid, out var body)) continue;
+
+                var transform = body.GetTransform();
+
+                foreach (var fixture in body.Fixtures)
+                {
+                    for (var i = 0; i < fixture.Shape.ChildCount; i++)
+                    {
+                        var aabb = fixture.Shape.ComputeAABB(transform, i);
+
+                        args.WorldHandle.DrawRect(aabb, Color.Green.WithAlpha(0.2f));
+                        args.WorldHandle.DrawRect(aabb, Color.Red.WithAlpha(0.5f), false);
+                    }
+                }
+            }
+        }
+    }
+}

Robust.Client/GameObjects/EntitySystems/GridFixtureSystem.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects
+{
+    internal sealed class GridFixtureSystem : SharedGridFixtureSystem
+    {
+
+    }
+}

Robust.Client/GameObjects/EntitySystems/MapSystem.cs

@@ -0,0 +1,9 @@
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects
+{
+    internal sealed class MapSystem : SharedMapSystem
+    {
+
+    }
+}

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -0,0 +1,44 @@
+using Robust.Client.ResourceManagement;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+
+namespace Robust.Client.GameObjects
+{
+    public sealed class PointLightSystem : SharedPointLightSystem
+    {
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<PointLightComponent, ComponentInit>(HandleInit);
+            SubscribeLocalEvent<PointLightComponent, ComponentRemove>(HandleRemove);
+        }
+
+        private void HandleInit(EntityUid uid, PointLightComponent component, ComponentInit args)
+        {
+            UpdateMask(component);
+        }
+
+        private void HandleRemove(EntityUid uid, PointLightComponent component, ComponentRemove args)
+        {
+            var ent = EntityManager.GetEntity(uid);
+            var map = ent.Transform.MapID;
+            // TODO: Just make this update the tree directly and not allocate
+            if (map != MapId.Nullspace)
+            {
+                EntityManager.EventBus.RaiseEvent(EventSource.Local,
+                    new RenderTreeRemoveLightEvent(component, map));
+            }
+        }
+
+        internal void UpdateMask(PointLightComponent component)
+        {
+            if (component._maskPath is not null)
+                component.Mask = _resourceCache.GetResource<TextureResource>(component._maskPath);
+            else
+                component.Mask = null;
+        }
+    }
+}

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -37,6 +37,18 @@ namespace Robust.Client.GameObjects
         /// </summary>
         public float MaxLightRadius { get; private set; }
 
+        internal IEnumerable<RenderingTreeComponent> GetRenderTrees(MapId mapId, Box2Rotated worldBounds)
+        {
+            if (mapId == MapId.Nullspace) yield break;
+
+            foreach (var grid in _mapManager.FindGridsIntersecting(mapId, worldBounds))
+            {
+                yield return EntityManager.GetEntity(grid.GridEntityId).GetComponent<RenderingTreeComponent>();
+            }
+
+            yield return _mapManager.GetMapEntity(mapId).GetComponent<RenderingTreeComponent>();
+        }
+
         internal IEnumerable<RenderingTreeComponent> GetRenderTrees(MapId mapId, Box2 worldAABB)
         {
             if (mapId == MapId.Nullspace) yield break;
@@ -49,22 +61,6 @@ namespace Robust.Client.GameObjects
             yield return _mapManager.GetMapEntity(mapId).GetComponent<RenderingTreeComponent>();
         }
 
-        internal IEnumerable<DynamicTree<SpriteComponent>> GetSpriteTrees(MapId mapId, Box2 worldAABB)
-        {
-            foreach (var comp in GetRenderTrees(mapId, worldAABB))
-            {
-                yield return comp.SpriteTree;
-            }
-        }
-
-        internal IEnumerable<DynamicTree<PointLightComponent>> GetLightTrees(MapId mapId, Box2 worldAABB)
-        {
-            foreach (var comp in GetRenderTrees(mapId, worldAABB))
-            {
-                yield return comp.LightTree;
-            }
-        }
-
         public override void Initialize()
         {
             base.Initialize();
@@ -108,7 +104,7 @@ namespace Robust.Client.GameObjects
             QueueSpriteUpdate(component);
         }
 
-        private void AnythingMoved(MoveEvent args)
+        private void AnythingMoved(ref MoveEvent args)
         {
             AnythingMovedSubHandler(args.Sender.Transform);
         }
@@ -146,7 +142,7 @@ namespace Robust.Client.GameObjects
             QueueSpriteUpdate(component);
         }
 
-        private void SpriteParentChanged(EntityUid uid, SpriteComponent component, EntParentChangedMessage args)
+        private void SpriteParentChanged(EntityUid uid, SpriteComponent component, ref EntParentChangedMessage args)
         {
             QueueSpriteUpdate(component);
         }
@@ -179,7 +175,7 @@ namespace Robust.Client.GameObjects
             QueueLightUpdate(component);
         }
 
-        private void LightParentChanged(EntityUid uid, PointLightComponent component, EntParentChangedMessage args)
+        private void LightParentChanged(EntityUid uid, PointLightComponent component, ref EntParentChangedMessage args)
         {
             QueueLightUpdate(component);
         }
@@ -267,6 +263,11 @@ namespace Robust.Client.GameObjects
             return null;
         }
 
+        private bool IsVisible(SpriteComponent component)
+        {
+            return component.Visible && !component.ContainerOccluded;
+        }
+
         public override void FrameUpdate(float frameTime)
         {
             _checkedChildren.Clear();
@@ -274,7 +275,7 @@ namespace Robust.Client.GameObjects
             foreach (var sprite in _spriteQueue)
             {
                 sprite.TreeUpdateQueued = false;
-                if (!sprite.Visible || sprite.ContainerOccluded)
+                if (!IsVisible(sprite))
                 {
                     ClearSprite(sprite);
                     continue;
@@ -335,7 +336,6 @@ namespace Robust.Client.GameObjects
                     Logger.WarningS(LoggerSawmill, $"Light radius for {light.Owner} set above max radius of {MaxLightRadius}. This may lead to pop-in.");
                 }
 
-                var treePos = newMapTree?.Owner.Transform.WorldPosition ?? Vector2.Zero;
                 var aabb = RenderingTreeComponent.LightAabbFunc(light, worldPos);
 
                 // If we're on a new map then clear the old one.

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -14,16 +14,14 @@ namespace Robust.Client.GameObjects
     public class SpriteSystem : EntitySystem
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly RenderingTreeSystem _treeSystem = default!;
 
-        private RenderingTreeSystem _treeSystem = default!;
         private readonly Queue<SpriteComponent> _inertUpdateQueue = new();
 
         public override void Initialize()
         {
             base.Initialize();
 
-            _treeSystem = Get<RenderingTreeSystem>();
             SubscribeLocalEvent<SpriteUpdateInertEvent>(QueueUpdateInert);
         }
 
@@ -40,9 +38,7 @@ namespace Robust.Client.GameObjects
                 sprite.DoUpdateIsInert();
             }
 
-            // So we could calculate the correct size of the entities based on the contents of their sprite...
-            // Or we can just assume that no entity is larger than 10x10 and get a stupid easy check.
-            var pvsBounds = _eyeManager.GetWorldViewport().Enlarged(5);
+            var pvsBounds = _eyeManager.GetWorldViewbounds();
 
             var currentMap = _eyeManager.CurrentMap;
             if (currentMap == MapId.Nullspace)
@@ -52,7 +48,7 @@ namespace Robust.Client.GameObjects
 
             foreach (var comp in _treeSystem.GetRenderTrees(currentMap, pvsBounds))
             {
-                var bounds = pvsBounds.Translated(-comp.Owner.Transform.WorldPosition);
+                var bounds = comp.Owner.Transform.InvWorldMatrix.TransformBox(pvsBounds);
 
                 comp.SpriteTree.QueryAabb(ref frameTime, (ref float state, in SpriteComponent value) =>
                 {

Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -1,11 +1,15 @@
 using JetBrains.Annotations;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 
 namespace Robust.Client.GameObjects
 {
     [UsedImplicitly]
-    public sealed class UserInterfaceSystem : EntitySystem
+    public sealed class UserInterfaceSystem : SharedUserInterfaceSystem
     {
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
         public override void Initialize()
         {
             base.Initialize();
@@ -24,7 +28,18 @@ namespace Robust.Client.GameObjects
 
         private void MessageReceived(BoundUIWrapMessage ev)
         {
-            var cmp = ComponentManager.GetComponent<ClientUserInterfaceComponent>(ev.Entity);
+            var uid = ev.Entity;
+            var cmp = EntityManager.GetComponent<ClientUserInterfaceComponent>(uid);
+
+            var message = ev.Message;
+            // This should probably not happen at this point, but better make extra sure!
+            if(_playerManager.LocalPlayer != null)
+                message.Session = _playerManager.LocalPlayer.Session;
+            message.Entity = uid;
+            message.UiKey = ev.UiKey;
+
+            // Raise as object so the correct type is used.
+            RaiseLocalEvent(uid, (object)message);
 
             cmp.MessageReceived(ev);
         }

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -20,6 +20,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
+using Robust.Shared.Players;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -50,7 +51,7 @@ namespace Robust.Client.GameStates
         [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 IClientEntityManager _entityManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
 #if EXCEPTION_TOLERANCE
         [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
@@ -334,8 +335,6 @@ namespace Robust.Client.GameStates
 
         private void ResetPredictedEntities(GameTick curTick)
         {
-            var bus = (EntityEventBus) _entities.EventBus;
-
             foreach (var entity in _entities.GetEntities())
             {
                 // TODO: 99% there's an off-by-one here.
@@ -353,7 +352,7 @@ namespace Robust.Client.GameStates
                 }
 
                 // TODO: handle component deletions/creations.
-                foreach (var (netId, comp) in _componentManager.GetNetComponents(entity.Uid))
+                foreach (var (netId, comp) in _entityManager.GetNetComponents(entity.Uid))
                 {
                     DebugTools.AssertNotNull(netId);
 
@@ -364,7 +363,8 @@ namespace Robust.Client.GameStates
 
                     Logger.DebugS(CVars.NetPredict.Name, $"  And also its component {comp.Name}");
                     // TODO: Handle interpolation.
-                    bus.RaiseComponentEvent(comp, new ComponentHandleState(compState, null));
+                    var handleState = new ComponentHandleState(compState, null);
+                    _entities.EventBus.RaiseComponentEvent(comp, ref handleState);
                     comp.HandleComponentState(compState, null);
                 }
             }
@@ -381,14 +381,16 @@ namespace Robust.Client.GameStates
             Debug.Assert(_players.LocalPlayer != null, "_players.LocalPlayer != null");
             var player = _players.LocalPlayer.Session;
 
+            var bus = _entityManager.EventBus;
+
             foreach (var createdEntity in createdEntities)
             {
                 var compData = new Dictionary<uint, ComponentState>();
                 outputData.Add(createdEntity, compData);
 
-                foreach (var (netId, component) in _componentManager.GetNetComponents(createdEntity))
+                foreach (var (netId, component) in _entityManager.GetNetComponents(createdEntity))
                 {
-                    var state = component.GetComponentState(player);
+                    var state = _entityManager.GetComponentState(bus, component, player);
 
                     if(state.GetType() == typeof(ComponentState))
                         continue;
@@ -472,14 +474,12 @@ namespace Robust.Client.GameStates
                 }
             }
 
-            var bus = (EntityEventBus) _entities.EventBus;
-
             // 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, bus, kvStates.Value.Item1,
+                HandleEntityState(entity, _entities.EventBus, kvStates.Value.Item1,
                     kvStates.Value.Item2);
             }
 
@@ -547,7 +547,7 @@ namespace Robust.Client.GameStates
             return created;
         }
 
-        private void HandleEntityState(IComponentManager compMan, IEntity entity, EntityEventBus bus, EntityState? curState,
+        private void HandleEntityState(IEntity entity, IEventBus bus, EntityState? curState,
             EntityState? nextState)
         {
             var compStateWork = new Dictionary<ushort, (ComponentState? curState, ComponentState? nextState)>();
@@ -559,21 +559,21 @@ namespace Robust.Client.GameStates
                 {
                     if (compChange.Deleted)
                     {
-                        if (compMan.TryGetComponent(entityUid, compChange.NetID, out var comp))
+                        if (_entityManager.TryGetComponent(entityUid, compChange.NetID, out var comp))
                         {
-                            compMan.RemoveComponent(entityUid, comp);
+                            _entityManager.RemoveComponent(entityUid, comp);
                         }
                     }
                     else
                     {
                         //Right now we just assume every state from an unseen entity is added
 
-                        if (compMan.HasComponent(entityUid, compChange.NetID))
+                        if (_entityManager.HasComponent(entityUid, compChange.NetID))
                             continue;
 
                         var newComp = (Component) _compFactory.GetComponent(compChange.NetID);
                         newComp.Owner = entity;
-                        compMan.AddComponent(entity, newComp, true);
+                        _entityManager.AddComponent(entity, newComp, true);
 
                         compStateWork[compChange.NetID] = (compChange.State, null);
                     }
@@ -605,11 +605,12 @@ namespace Robust.Client.GameStates
 
             foreach (var (netId, (cur, next)) in compStateWork)
             {
-                if (compMan.TryGetComponent(entityUid, (ushort) netId, out var component))
+                if (_entityManager.TryGetComponent(entityUid, (ushort) netId, out var component))
                 {
                     try
                     {
-                        bus.RaiseComponentEvent(component, new ComponentHandleState(cur, next));
+                        var handleState = new ComponentHandleState(cur, next);
+                        bus.RaiseComponentEvent(component, ref handleState);
                         component.HandleComponentState(cur, next);
                     }
                     catch (Exception e)

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -1,19 +1,19 @@
 using Robust.Shared.Enums;
-using Robust.Client.Graphics;
+using Robust.Client.Graphics;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
-using System;
+using Robust.Shared.Containers;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates
 {
     internal class NetInterpOverlay : Overlay
     {
-        [Dependency] private readonly IComponentManager _componentManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
@@ -32,13 +32,13 @@ namespace Robust.Client.GameStates
             handle.UseShader(_shader);
             var worldHandle = (DrawingHandleWorld) handle;
             var viewport = _eyeManager.GetWorldViewport();
-            foreach (var boundingBox in _componentManager.EntityQuery<IPhysBody>(true))
+            foreach (var boundingBox in _entityManager.EntityQuery<IPhysBody>(true))
             {
                 // all entities have a TransformComponent
-                var transform = ((IComponent)boundingBox).Owner.Transform;
+                var transform = boundingBox.Owner.Transform;
 
                 // if not on the same map, continue
-                if (transform.MapID != _eyeManager.CurrentMap || !transform.IsMapTransform)
+                if (transform.MapID != _eyeManager.CurrentMap || boundingBox.Owner.IsInContainer())
                     continue;
 
                 // This entity isn't lerping, no need to draw debug info for it

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -68,6 +68,28 @@ namespace Robust.Client.Graphics
             return new Box2(left, bottom, right, top);
         }
 
+        /// <inheritdoc />
+        public Box2Rotated GetWorldViewbounds()
+        {
+            var vpSize = _displayManager.ScreenSize;
+
+            var topRight = ScreenToMap(new Vector2(vpSize.X, 0)).Position;
+            var bottomLeft = ScreenToMap(new Vector2(0, vpSize.Y)).Position;
+
+            var rotation = new Angle(CurrentEye.Rotation);
+            var center = (bottomLeft + topRight) / 2;
+
+            var localTopRight = topRight - center;
+            var localBotLeft = bottomLeft - center;
+
+            localTopRight = rotation.RotateVec(localTopRight);
+            localBotLeft = rotation.RotateVec(localBotLeft);
+
+            var bounds = new Box2(localBotLeft, localTopRight).Translated(center);
+
+            return new Box2Rotated(bounds, -CurrentEye.Rotation, bounds.Center);
+        }
+
         /// <inheritdoc />
         public Vector2 WorldToScreen(Vector2 point)
         {
@@ -111,10 +133,11 @@ namespace Robust.Client.Graphics
         public MapCoordinates ScreenToMap(ScreenCoordinates point)
         {
             var (pos, window) = point;
-            if (window != MainViewport.Window?.Id)
+
+            if (_uiManager.MouseGetControl(point) is not IViewportControl viewport)
                 return default;
 
-            return MainViewport.ScreenToMap(pos);
+            return viewport.ScreenToMap(pos);
         }
 
         /// <inheritdoc />

Robust.Client/Graphics/ClientEye/IEyeManager.cs

@@ -31,6 +31,8 @@ namespace Robust.Client.Graphics
         /// </summary>
         Box2 GetWorldViewport();
 
+        Box2Rotated GetWorldViewbounds();
+
         /// <summary>
         /// Calculates the projection matrix to transform a point from camera space
         /// to UI screen space.
@@ -53,7 +55,7 @@ namespace Robust.Client.Graphics
         ScreenCoordinates CoordinatesToScreen(EntityCoordinates point);
 
         /// <summary>
-        /// Unprojects a point from UI screen space to world space using the current camera.
+        /// Unprojects a point from UI screen space to world space using the viewport under the screen coordinates.
         /// </summary>
         /// <remarks>
         /// The game exists on the 2D X/Y plane, so this function returns a point o the plane
@@ -64,7 +66,7 @@ namespace Robust.Client.Graphics
         MapCoordinates ScreenToMap(ScreenCoordinates point);
 
         /// <summary>
-        /// Unprojects a point from UI screen space to world space using the current camera.
+        /// Unprojects a point from UI screen space to world space using the main viewport.
         /// </summary>
         /// <remarks>
         /// The game exists on the 2D X/Y plane, so this function returns a point o the plane

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

@@ -9,6 +9,7 @@ using OpenToolkit.Audio.OpenAL;
 using OpenToolkit.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Client.Audio;
 using Robust.Shared;
+using Robust.Shared.Audio;
 using Robust.Shared.Log;
 using Vector2 = Robust.Shared.Maths.Vector2;
 
@@ -58,6 +59,7 @@ namespace Robust.Client.Graphics.Clyde
             IsEfxSupported = HasAlDeviceExtension("ALC_EXT_EFX");
 
             _cfg.OnValueChanged(CVars.AudioMasterVolume, SetMasterVolume, true);
+            _cfg.OnValueChanged(CVars.AudioAttenuation, SetAudioAttenuation, true);
         }
 
         private void _audioCreateContext()
@@ -192,6 +194,43 @@ namespace Robust.Client.Graphics.Clyde
             AL.Listener(ALListenerf.Gain, _baseGain * newVolume);
         }
 
+        public void SetAudioAttenuation(int value)
+        {
+            var attenuation = (Attenuation) value;
+
+            switch (attenuation)
+            {
+                case Attenuation.NoAttenuation:
+                    AL.DistanceModel(ALDistanceModel.None);
+                    break;
+                case Attenuation.InverseDistance:
+                    AL.DistanceModel(ALDistanceModel.InverseDistance);
+                    break;
+                case Attenuation.Default:
+                case Attenuation.InverseDistanceClamped:
+                    AL.DistanceModel(ALDistanceModel.InverseDistanceClamped);
+                    break;
+                case Attenuation.LinearDistance:
+                    AL.DistanceModel(ALDistanceModel.LinearDistance);
+                    break;
+                case Attenuation.LinearDistanceClamped:
+                    AL.DistanceModel(ALDistanceModel.LinearDistanceClamped);
+                    break;
+                case Attenuation.ExponentDistance:
+                    AL.DistanceModel(ALDistanceModel.ExponentDistance);
+                    break;
+                case Attenuation.ExponentDistanceClamped:
+                    AL.DistanceModel(ALDistanceModel.ExponentDistanceClamped);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException($"No implementation to set {attenuation.ToString()} for DistanceModel!");
+            }
+
+            var attToString = attenuation == Attenuation.Default ? Attenuation.InverseDistanceClamped : attenuation;
+
+            _openALSawmill.Info($"Set audio attenuation to {attToString.ToString()}");
+        }
+
         public IClydeAudioSource CreateAudioSource(AudioStream stream)
         {
             var source = AL.GenSource();
@@ -419,7 +458,7 @@ namespace Robust.Client.Graphics.Clyde
 
             public void StopPlaying()
             {
-                _checkDisposed();
+                if (_isDisposed()) return;
                 AL.SourceStop(SourceHandle);
                 _master._checkAlError();
             }
@@ -486,6 +525,27 @@ namespace Robust.Client.Graphics.Clyde
                 _master._checkAlError();
             }
 
+            public void SetMaxDistance(float distance)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle, ALSourcef.MaxDistance, distance);
+                _master._checkAlError();
+            }
+
+            public void SetRolloffFactor(float rolloffFactor)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle, ALSourcef.RolloffFactor, rolloffFactor);
+                _master._checkAlError();
+            }
+
+            public void SetReferenceDistance(float refDistance)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle, ALSourcef.ReferenceDistance, refDistance);
+                _master._checkAlError();
+            }
+
             public void SetOcclusion(float blocks)
             {
                 _checkDisposed();
@@ -612,6 +672,11 @@ namespace Robust.Client.Graphics.Clyde
                 SourceHandle = -1;
             }
 
+            private bool _isDisposed()
+            {
+                return SourceHandle == -1;
+            }
+
             private void _checkDisposed()
             {
                 if (SourceHandle == -1)
@@ -661,7 +726,7 @@ namespace Robust.Client.Graphics.Clyde
 
             public void StopPlaying()
             {
-                _checkDisposed();
+                if (_isDisposed()) return;
                 // ReSharper disable once PossibleInvalidOperationException
                 AL.SourceStop(SourceHandle!.Value);
                 _master._checkAlError();
@@ -726,6 +791,27 @@ namespace Robust.Client.Graphics.Clyde
                 _master._checkAlError();
             }
 
+            public void SetMaxDistance(float distance)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle!.Value, ALSourcef.MaxDistance, distance);
+                _master._checkAlError();
+            }
+
+            public void SetRolloffFactor(float rolloffFactor)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle!.Value, ALSourcef.RolloffFactor, rolloffFactor);
+                _master._checkAlError();
+            }
+
+            public void SetReferenceDistance(float refDistance)
+            {
+                _checkDisposed();
+                AL.Source(SourceHandle!.Value, ALSourcef.ReferenceDistance, refDistance);
+                _master._checkAlError();
+            }
+
             public void SetOcclusion(float blocks)
             {
                 _checkDisposed();
@@ -831,7 +917,7 @@ namespace Robust.Client.Graphics.Clyde
             {
                 if (SourceHandle == null) return;
 
-                if (!disposing || Thread.CurrentThread != _master._gameThread)
+                if (!_master.IsMainThread())
                 {
                     // We can't run this code inside another thread so tell Clyde to clear it up later.
                     _master.DeleteBufferedSourceOnMainThread(SourceHandle.Value, FilterHandle);
@@ -850,6 +936,11 @@ namespace Robust.Client.Graphics.Clyde
                 SourceHandle = null;
             }
 
+            private bool _isDisposed()
+            {
+                return SourceHandle == null;
+            }
+
             private void _checkDisposed()
             {
                 if (SourceHandle == null)

Robust.Client/Graphics/Clyde/Clyde.Constants.cs

@@ -2,7 +2,8 @@ namespace Robust.Client.Graphics.Clyde
 {
     internal sealed partial class Clyde
     {
-        private static readonly (string, uint)[] BaseShaderAttribLocations = {
+        private static readonly (string, uint)[] BaseShaderAttribLocations =
+        {
             ("aPos", 0),
             ("tCoord", 1)
         };
@@ -30,14 +31,21 @@ namespace Robust.Client.Graphics.Clyde
         // To be clear: You shouldn't change this. This just helps with understanding where Primitive Restart is being used.
         private const ushort PrimitiveRestartIndex = ushort.MaxValue;
 
-        private enum Renderer : short
+        private enum Renderer : sbyte
         {
-            // Default: Try all supported renderers (not necessarily the renderers shown here)
-            Default = default,
-            OpenGL33 = 1,
-            OpenGL31 = 2,
-            OpenGLES2 = 3,
+            // Auto: Try all supported renderers (not necessarily the renderers shown here)
+            Auto = default,
+            OpenGL = 1,
             Explode = -1,
         }
+
+        private enum RendererOpenGLVersion : byte
+        {
+            Auto = default,
+            GL33 = 1,
+            GL31 = 2,
+            GLES3 = 3,
+            GLES2 = 4,
+        }
     }
 }

Robust.Client/Graphics/Clyde/Clyde.Events.cs

@@ -62,7 +62,7 @@ namespace Robust.Client.Graphics.Clyde
                     TextEntered?.Invoke(args);
                     break;
                 case DEventWindowClosed(var reg, var args):
-                    reg.Closed?.Invoke(args);
+                    reg.RequestClosed?.Invoke(args);
                     CloseWindow?.Invoke(args);
 
                     if (reg.DisposeOnClose && !reg.IsMainWindow)
@@ -95,24 +95,17 @@ namespace Robust.Client.Graphics.Clyde
             _eventDispatchQueue.Enqueue(new DEventScroll(ev));
         }
 
-        private void SendCloseWindow(WindowReg windowReg, WindowClosedEventArgs ev)
+        private void SendCloseWindow(WindowReg windowReg, WindowRequestClosedEventArgs ev)
         {
             _eventDispatchQueue.Enqueue(new DEventWindowClosed(windowReg, ev));
         }
 
         private void SendWindowResized(WindowReg reg, Vector2i oldSize)
         {
-            if (reg.IsMainWindow)
-            {
-                UpdateMainWindowLoadedRtSize();
-                GL.Viewport(0, 0, reg.FramebufferSize.X, reg.FramebufferSize.Y);
-                CheckGlError();
-            }
-            else
-            {
-                reg.RenderTexture!.Dispose();
-                CreateWindowRenderTexture(reg);
-            }
+            var loaded = RtToLoaded(reg.RenderTarget);
+            loaded.Size = reg.FramebufferSize;
+
+            _glContext!.WindowResized(reg, oldSize);
 
             var eventArgs = new WindowResizedEventArgs(
                 oldSize,
@@ -156,7 +149,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private sealed record DEventScroll(MouseWheelEventArgs Args) : DEventBase;
 
-        private sealed record DEventWindowClosed(WindowReg Reg, WindowClosedEventArgs Args) : DEventBase;
+        private sealed record DEventWindowClosed(WindowReg Reg, WindowRequestClosedEventArgs Args) : DEventBase;
 
         private sealed record DEventWindowResized(WindowResizedEventArgs Args) : DEventBase;
 

Robust.Client/Graphics/Clyde/Clyde.GLContext.cs

@@ -0,0 +1,85 @@
+using System;
+using Robust.Shared;
+using Robust.Shared.Log;
+
+namespace Robust.Client.Graphics.Clyde
+{
+    internal sealed partial class Clyde
+    {
+        private GLContextBase? _glContext;
+
+        // Current OpenGL version we managed to initialize with.
+        private RendererOpenGLVersion _openGLVersion;
+
+        private void InitGLContextManager()
+        {
+            // Advanced GL contexts currently disabled due to lack of testing etc.
+            if (OperatingSystem.IsWindows() && _cfg.GetCVar(CVars.DisplayAngle))
+            {
+                /*
+                if (_cfg.GetCVar(CVars.DisplayAngleCustomSwapChain))
+                {
+                    _sawmillOgl.Debug("Trying custom swap chain ANGLE.");
+                    var ctxAngle = new GLContextAngle(this);
+
+                    if (ctxAngle.TryInitialize())
+                    {
+                        _sawmillOgl.Debug("Successfully initialized custom ANGLE");
+                        _glContext = ctxAngle;
+
+                        ctxAngle.EarlyInit();
+                        return;
+                    }
+                }
+                */
+
+                /*
+                if (_cfg.GetCVar(CVars.DisplayEgl))
+                {
+                    _sawmillOgl.Debug("Trying EGL");
+                    var ctxEgl = new GLContextEgl(this);
+                    ctxEgl.InitializePublic();
+                    _glContext = ctxEgl;
+                    return;
+                }
+                */
+            }
+
+            /*
+            if (OperatingSystem.IsLinux() && _cfg.GetCVar(CVars.DisplayEgl))
+            {
+                _sawmillOgl.Debug("Trying EGL");
+                var ctxEgl = new GLContextEgl(this);
+                ctxEgl.InitializePublic();
+                _glContext = ctxEgl;
+                return;
+            }
+            */
+
+            _glContext = new GLContextWindow(this);
+        }
+
+        private struct GLContextSpec
+        {
+            public int Major;
+            public int Minor;
+            public GLContextProfile Profile;
+            public GLContextCreationApi CreationApi;
+            // Used by GLContextWindow to figure out which GL version managed to initialize.
+            public RendererOpenGLVersion OpenGLVersion;
+        }
+
+        private enum GLContextProfile
+        {
+            Compatibility,
+            Core,
+            Es
+        }
+
+        private enum GLContextCreationApi
+        {
+            Native,
+            Egl,
+        }
+    }
+}

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

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Shared.Log;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -10,6 +9,8 @@ namespace Robust.Client.Graphics.Clyde
         // OpenGL feature detection go here.
 
         private bool _hasGLKhrDebug;
+        private bool _glDebuggerPresent;
+
         // As per the extension specification, when implemented as extension in an ES context,
         // function names have to be suffixed by "KHR"
         // This keeps track of whether that's necessary.
@@ -24,6 +25,7 @@ namespace Robust.Client.Graphics.Clyde
         private bool _hasGLVertexArrayObject;
         private bool _hasGLVertexArrayObjectOes;
         private bool _hasGLFloatFramebuffers;
+        private bool _hasGLES3Shaders;
         private bool HasGLAnyMapBuffer => _hasGLMapBuffer || _hasGLMapBufferRange || _hasGLMapBufferOes;
         private bool _hasGLMapBuffer;
         private bool _hasGLMapBufferOes;
@@ -57,6 +59,8 @@ namespace Robust.Client.Graphics.Clyde
         {
             var extensions = GetGLExtensions();
 
+            CheckGLDebuggerStatus(extensions);
+
             _sawmillOgl.Debug("OpenGL capabilities:");
 
             if (!_isGLES)
@@ -72,6 +76,12 @@ namespace Robust.Client.Graphics.Clyde
                 CheckGLCap(ref _hasGLMapBufferRange, "map_buffer_range", (3, 0));
                 CheckGLCap(ref _hasGLPixelBufferObjects, "pixel_buffer_object", (2, 1));
                 CheckGLCap(ref _hasGLStandardDerivatives, "standard_derivatives", (2, 1));
+
+                _hasGLSrgb = true;
+                _hasGLReadFramebuffer = true;
+                _hasGLPrimitiveRestart = true;
+                _hasGLUniformBuffers = true;
+                _hasGLFloatFramebuffers = true;
             }
             else
             {
@@ -94,15 +104,31 @@ namespace Robust.Client.Graphics.Clyde
                 CheckGLCap(ref _hasGLMapBufferRange, "map_buffer_range", (3, 0));
                 CheckGLCap(ref _hasGLPixelBufferObjects, "pixel_buffer_object", (3, 0));
                 CheckGLCap(ref _hasGLStandardDerivatives, "standard_derivatives", (3, 0), "GL_OES_standard_derivatives");
-            }
+                CheckGLCap(ref _hasGLReadFramebuffer, "read_framebuffer", (3, 0));
+                CheckGLCap(ref _hasGLPrimitiveRestart, "primitive_restart", (3, 1));
+                CheckGLCap(ref _hasGLUniformBuffers, "uniform_buffers", (3, 0));
+                CheckGLCap(ref _hasGLFloatFramebuffers, "float_framebuffers", (3, 2), "GL_EXT_color_buffer_float");
+                CheckGLCap(ref _hasGLES3Shaders, "gles3_shaders", (3, 0));
 
-            // TODO: Enable these on ES 3.0
-            _hasGLSrgb = !_isGLES;
-            _hasGLReadFramebuffer = !_isGLES;
-            _hasGLPrimitiveRestart = !_isGLES;
-            _hasGLUniformBuffers = !_isGLES;
-            // This is 3.2 or extensions
-            _hasGLFloatFramebuffers = !_isGLES;
+                if (major >= 3)
+                {
+                    if (_glContext!.HasBrokenWindowSrgb)
+                    {
+                        _hasGLSrgb = false;
+                        _sawmillOgl.Debug("  sRGB: false (window broken sRGB)");
+                    }
+                    else
+                    {
+                        _hasGLSrgb = true;
+                        _sawmillOgl.Debug("  sRGB: true");
+                    }
+                }
+                else
+                {
+                    _hasGLSrgb = false;
+                    _sawmillOgl.Debug("  sRGB: false");
+                }
+            }
 
             _sawmillOgl.Debug($"  GLES: {_isGLES}");
 
@@ -127,6 +153,19 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
+        private void CheckGLDebuggerStatus(HashSet<string> extensions)
+        {
+            if (!extensions.Contains("GL_EXT_debug_tool"))
+                return;
+
+            const int GL_DEBUG_TOOL_EXT = 0x6789;
+            const int GL_DEBUG_TOOL_NAME_EXT = 0x678A;
+
+            _glDebuggerPresent = GL.IsEnabled((EnableCap)GL_DEBUG_TOOL_EXT);
+            var name = GL.GetString((StringName)GL_DEBUG_TOOL_NAME_EXT);
+            _sawmillOgl.Debug($"OpenGL debugger present: {name}");
+        }
+
         private void RegisterBlockCVars()
         {
             string[] cvars =
@@ -141,7 +180,12 @@ namespace Robust.Client.Graphics.Clyde
                 "map_buffer_range",
                 "pixel_buffer_object",
                 "map_buffer_oes",
-                "standard_derivatives"
+                "standard_derivatives",
+                "read_framebuffer",
+                "primitive_restart",
+                "uniform_buffers",
+                "float_framebuffers",
+                "gles3_shaders",
             };
 
             foreach (var cvar in cvars)

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

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
@@ -19,18 +20,17 @@ namespace Robust.Client.Graphics.Clyde
         private int _verticesPerChunk(IMapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * 4;
         private int _indicesPerChunk(IMapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * GetQuadBatchIndexCount();
 
-        private void _drawGrids(Box2 worldBounds)
+        private void _drawGrids(Viewport viewport, Box2Rotated worldBounds, IEye eye)
         {
-            var mapId = _eyeManager.CurrentMap;
+            var mapId = eye.Position.MapId;
             if (!_mapManager.MapExists(mapId))
             {
-                // fall back to the default eye's map
-                _eyeManager.ClearCurrentEye();
-                mapId = _eyeManager.CurrentMap;
+                // fall back to nullspace map
+                mapId = MapId.Nullspace;
             }
 
             SetTexture(TextureUnit.Texture0, _tileDefinitionManager.TileTextureAtlas);
-            SetTexture(TextureUnit.Texture1, _lightingReady ? _currentViewport!.LightRenderTarget.Texture : _stockTextureWhite);
+            SetTexture(TextureUnit.Texture1, _lightingReady ? viewport.LightRenderTarget.Texture : _stockTextureWhite);
 
             var (gridProgram, _) = ActivateShaderInstance(_defaultShader.Handle);
             SetupGlobalUniformsImmediate(gridProgram, (ClydeTexture) _tileDefinitionManager.TileTextureAtlas);
@@ -40,7 +40,6 @@ namespace Robust.Client.Graphics.Clyde
             gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
             gridProgram.SetUniform(UniIModulate, Color.White);
 
-            var compMan = _entityManager.ComponentManager;
             foreach (var mapGrid in _mapManager.FindGridsIntersecting(mapId, worldBounds))
             {
                 var grid = (IMapGridInternal) mapGrid;
@@ -50,17 +49,11 @@ namespace Robust.Client.Graphics.Clyde
                     continue;
                 }
 
-                var transform = compMan.GetComponent<ITransformComponent>(grid.GridEntityId);
+                var transform = _entityManager.GetComponent<ITransformComponent>(grid.GridEntityId);
                 gridProgram.SetUniform(UniIModelMatrix, transform.WorldMatrix);
 
-                foreach (var (_, chunk) in grid.GetMapChunks())
+                foreach (var chunk in grid.GetMapChunks(worldBounds))
                 {
-                    // Calc world bounds for chunk.
-                    if (!chunk.CalcWorldBounds().Intersects(in worldBounds))
-                    {
-                        continue;
-                    }
-
                     if (_isChunkDirty(grid, chunk))
                     {
                         _updateChunkMesh(grid, chunk);
@@ -210,11 +203,14 @@ namespace Robust.Client.Graphics.Clyde
 
         private void _updateOnGridCreated(MapId mapId, GridId gridId)
         {
+            Logger.DebugS("grid", $"Adding {gridId} to grid renderer");
             _mapChunkData.Add(gridId, new Dictionary<Vector2i, MapChunkData>());
         }
 
         private void _updateOnGridRemoved(MapId mapId, GridId gridId)
         {
+            Logger.DebugS("grid", $"Removing {gridId} from grid renderer");
+
             var data = _mapChunkData[gridId];
             foreach (var chunkDatum in data.Values)
             {

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

@@ -2,6 +2,7 @@ using System;
 using System.Buffers;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Threading;
 using Robust.Client.GameObjects;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Map;
@@ -9,6 +10,7 @@ using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared;
 using Robust.Shared.Enums;
 
 namespace Robust.Client.Graphics.Clyde
@@ -25,12 +27,12 @@ namespace Robust.Client.Graphics.Clyde
                 =
                 new();
 
-        public unsafe void Render()
+        public void Render()
         {
             CheckTransferringScreenshots();
 
             var allMinimized = true;
-            foreach (var windowReg in _windowing!.AllWindows)
+            foreach (var windowReg in _windows)
             {
                 if (!windowReg.IsMinimized)
                 {
@@ -44,9 +46,8 @@ namespace Robust.Client.Graphics.Clyde
             {
                 ClearFramebuffer(Color.Black);
 
-                // We have to keep running swapbuffers here
-                // or else the user's PC will turn into a heater!!
-                SwapMainBuffers();
+                // Sleep to avoid turning the computer into a heater.
+                Thread.Sleep(16);
                 return;
             }
 
@@ -58,11 +59,9 @@ namespace Robust.Client.Graphics.Clyde
             _debugStats.Reset();
 
             // Basic pre-render busywork.
-            // Clear screen to black.
-            ClearFramebuffer(Color.Black);
 
             // Update shared UBOs.
-            _updateUniformConstants(_windowing.MainWindow!.FramebufferSize);
+            _updateUniformConstants(_mainWindow!.FramebufferSize);
 
             {
                 CalcScreenMatrices(ScreenSize, out var proj, out var view);
@@ -74,7 +73,7 @@ namespace Robust.Client.Graphics.Clyde
             {
                 DrawSplash(_renderHandle);
                 FlushRenderQueue();
-                SwapMainBuffers();
+                SwapAllBuffers();
                 return;
             }
 
@@ -84,6 +83,9 @@ namespace Robust.Client.Graphics.Clyde
                     RenderViewport(viewport);
             }
 
+            // Clear screen to correct color.
+            ClearFramebuffer(_userInterfaceManager.GetMainClearColor());
+
             using (DebugGroup("UI"))
             {
                 _userInterfaceManager.Render(_renderHandle);
@@ -92,10 +94,8 @@ namespace Robust.Client.Graphics.Clyde
 
             TakeScreenshot(ScreenshotType.Final);
 
-            BlitSecondaryWindows();
-
             // And finally, swap those buffers!
-            SwapMainBuffers();
+            SwapAllBuffers();
         }
 
         private void RenderOverlays(Viewport vp, OverlaySpace space, in Box2 worldBox)
@@ -130,7 +130,7 @@ namespace Robust.Client.Graphics.Clyde
         {
             var list = GetOverlaysForSpace(space);
 
-            var worldBounds = CalcWorldBounds(vp);
+            var worldBounds = CalcWorldAABB(vp);
             var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, worldBounds);
 
             foreach (var overlay in list)
@@ -201,23 +201,19 @@ namespace Robust.Client.Graphics.Clyde
         }
 
 
-        private void DrawEntities(Viewport viewport, Box2 worldBounds)
+        private void DrawEntities(Viewport viewport, Box2Rotated worldBounds, Box2 worldAABB, IEye eye)
         {
-            if (_eyeManager.CurrentMap == MapId.Nullspace || !_mapManager.HasMapEntity(_eyeManager.CurrentMap))
+            var mapId = eye.Position.MapId;
+            if (mapId == MapId.Nullspace || !_mapManager.HasMapEntity(mapId))
             {
                 return;
             }
 
-            RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowEntities, worldBounds);
+            RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowEntities, worldAABB);
 
             var screenSize = viewport.Size;
 
-            // So we could calculate the correct size of the entities based on the contents of their sprite...
-            // Or we can just assume that no entity is larger than 10x10 and get a stupid easy check.
-            // TODO: Make this check more accurate.
-            var widerBounds = worldBounds.Enlarged(5);
-
-            ProcessSpriteEntities(_eyeManager.CurrentMap, widerBounds, _drawingSpriteList);
+            ProcessSpriteEntities(mapId, worldBounds, _drawingSpriteList);
 
             var worldOverlays = new List<Overlay>();
 
@@ -265,7 +261,7 @@ namespace Robust.Client.Graphics.Clyde
                             null,
                             viewport,
                             new UIBox2i((0, 0), viewport.Size),
-                            worldBounds);
+                            worldAABB);
                         overlayIndex = j;
                         continue;
                     }
@@ -273,13 +269,15 @@ namespace Robust.Client.Graphics.Clyde
                     break;
                 }
 
+                var matrix = entry.worldMatrix;
+                var worldPosition = new Vector2(matrix.R0C2, matrix.R1C2);
 
                 RenderTexture? entityPostRenderTarget = null;
                 Vector2i roundedPos = default;
                 if (entry.sprite.PostShader != null)
                 {
                     // calculate world bounding box
-                    var spriteBB = entry.sprite.CalculateBoundingBox();
+                    var spriteBB = entry.sprite.CalculateBoundingBox(worldPosition);
                     var spriteLB = spriteBB.BottomLeft;
                     var spriteRT = spriteBB.TopRight;
 
@@ -291,6 +289,9 @@ namespace Robust.Client.Graphics.Clyde
                     // scale can be passed with PostShader as variable in future
                     var postShadeScale = 1.25f;
                     var screenSpriteSize = (Vector2i) ((screenRT - screenLB) * postShadeScale).Rounded();
+
+                    // Rotate the vector by the eye angle, otherwise the bounding box will be incorrect
+                    screenSpriteSize = (Vector2i) eye.Rotation.RotateVec(screenSpriteSize).Rounded();
                     screenSpriteSize.Y = -screenSpriteSize.Y;
 
                     // I'm not 100% sure why it works, but without it post-shader
@@ -323,9 +324,7 @@ namespace Robust.Client.Graphics.Clyde
                     }
                 }
 
-                var matrix = entry.worldMatrix;
-                var worldPosition = new Vector2(matrix.R0C2, matrix.R1C2);
-                entry.sprite.Render(_renderHandle.DrawingHandleWorld, in entry.worldRotation, in worldPosition);
+                entry.sprite.Render(_renderHandle.DrawingHandleWorld, eye.Rotation, in entry.worldRotation, in worldPosition);
 
                 if (entry.sprite.PostShader != null && entityPostRenderTarget != null)
                 {
@@ -363,14 +362,14 @@ namespace Robust.Client.Graphics.Clyde
         }
 
         [MethodImpl(MethodImplOptions.NoInlining)]
-        private void ProcessSpriteEntities(MapId map, Box2 worldBounds,
+        private void ProcessSpriteEntities(MapId map, Box2Rotated worldBounds,
             RefList<(SpriteComponent sprite, Matrix3 matrix, Angle worldRot, float yWorldPos)> list)
         {
             foreach (var comp in _entitySystemManager.GetEntitySystem<RenderingTreeSystem>().GetRenderTrees(map, worldBounds))
             {
-                var bounds = worldBounds.Translated(-comp.Owner.Transform.WorldPosition);
+                var bounds = comp.Owner.Transform.InvWorldMatrix.TransformBox(worldBounds);
 
-                comp.SpriteTree.QueryAabb(ref list, ((
+                comp.SpriteTree.QueryAabb(ref list, (
                     ref RefList<(SpriteComponent sprite, Matrix3 matrix, Angle worldRot, float yWorldPos)> state,
                     in SpriteComponent value) =>
                 {
@@ -381,22 +380,28 @@ namespace Robust.Client.Graphics.Clyde
                     entry.sprite = value;
                     entry.worldRot = transform.WorldRotation;
                     entry.matrix = transform.WorldMatrix;
-                    var worldPos = entry.matrix.Transform(transform.LocalPosition);
-                    entry.yWorldPos = worldPos.Y;
+                    var worldPos = new Vector2(entry.matrix.R0C2, entry.matrix.R1C2);
+                    // Didn't use the bounds from the query as that has to be re-calculated (and is probably more expensive than this).
+                    var bounds = value.CalculateBoundingBox(worldPos);
+                    entry.yWorldPos = worldPos.Y - bounds.Extents.Y;
                     return true;
 
-                }), bounds, true);
+                }, bounds, true);
             }
         }
 
         private void DrawSplash(IRenderHandle handle)
         {
-            var texture = _resourceCache.GetResource<TextureResource>("/Textures/Logo/logo.png").Texture;
+            // Clear screen to black for splash.
+            ClearFramebuffer(Color.Black);
+
+            var splashTex = _cfg.GetCVar(CVars.DisplaySplashLogo);
+            var texture = _resourceCache.GetResource<TextureResource>(splashTex).Texture;
 
             handle.DrawingHandleScreen.DrawTexture(texture, (ScreenSize - texture.Size) / 2);
         }
 
-        private void RenderInRenderTarget(RenderTargetBase rt, Action a)
+        private void RenderInRenderTarget(RenderTargetBase rt, Action a, Color clearColor=default)
         {
             // TODO: for the love of god all this state pushing/popping needs to be cleaned up.
 
@@ -410,7 +415,7 @@ namespace Robust.Client.Graphics.Clyde
 
             {
                 BindRenderTargetFull(RtToLoaded(rt));
-                ClearFramebuffer(default);
+                ClearFramebuffer(clearColor);
                 SetViewportImmediate(Box2i.FromDimensions(Vector2i.Zero, rt.Size));
                 _updateUniformConstants(rt.Size);
                 CalcScreenMatrices(rt.Size, out var proj, out var view);
@@ -453,30 +458,32 @@ namespace Robust.Client.Graphics.Clyde
                 SetProjViewFull(proj, view);
 
                 // Calculate world-space AABB for camera, to cull off-screen things.
+                var worldAABB = CalcWorldAABB(viewport);
                 var worldBounds = CalcWorldBounds(viewport);
 
                 if (_eyeManager.CurrentMap != MapId.Nullspace)
                 {
                     using (DebugGroup("Lights"))
                     {
-                        DrawLightsAndFov(viewport, worldBounds, eye);
+                        DrawLightsAndFov(viewport, worldBounds, worldAABB, eye);
                     }
 
-                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowWorld, worldBounds);
+                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowWorld, worldAABB);
                     FlushRenderQueue();
 
                     using (DebugGroup("Grids"))
                     {
-                        _drawGrids(worldBounds);
+                        _drawGrids(viewport, worldBounds, eye);
                     }
 
                     // We will also render worldspace overlays here so we can do them under / above entities as necessary
                     using (DebugGroup("Entities"))
                     {
-                        DrawEntities(viewport, worldBounds);
+                        DrawEntities(viewport, worldBounds, worldAABB, eye);
                     }
 
-                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowFOV, worldBounds);
+                    RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowFOV, worldAABB);
+                    FlushRenderQueue();
 
                     if (_lightManager.Enabled && _lightManager.DrawHardFov && eye.DrawFov)
                     {
@@ -509,24 +516,40 @@ namespace Robust.Client.Graphics.Clyde
                         UIBox2.FromDimensions(Vector2.Zero, viewport.Size), new Color(1, 1, 1, 0.5f));
                 }
 
-                RenderOverlays(viewport, OverlaySpace.WorldSpace, worldBounds);
+                RenderOverlays(viewport, OverlaySpace.WorldSpace, worldAABB);
                 FlushRenderQueue();
 
                 _currentViewport = oldVp;
             });
         }
 
-        private static Box2 CalcWorldBounds(Viewport viewport)
+        private static Box2 CalcWorldAABB(Viewport viewport)
         {
             var eye = viewport.Eye;
             if (eye == null)
                 return default;
 
-            // TODO: This seems completely unfit by lacking things like rotation handling.
+            return GetAABB(eye, viewport);
+        }
+
+        private static Box2 GetAABB(IEye eye, Viewport viewport)
+        {
             return Box2.CenteredAround(eye.Position.Position,
                 viewport.Size / viewport.RenderScale / EyeManager.PixelsPerMeter * eye.Zoom);
         }
 
+        private static Box2Rotated CalcWorldBounds(Viewport viewport)
+        {
+            var eye = viewport.Eye;
+            if (eye == null)
+                return default;
+
+            var rotation = -eye.Rotation;
+            var aabb = GetAABB(eye, viewport);
+
+            return new Box2Rotated(aabb, rotation, aabb.Center);
+        }
+
         private sealed class OverlayComparer : IComparer<Overlay>
         {
             public static readonly OverlayComparer Instance = new();

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

@@ -2,10 +2,8 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 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
@@ -276,7 +274,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private void LoadGLProc<T>(string name, out T field) where T : Delegate
         {
-            var proc = _windowing!.GraphicsBindingContext.GetProcAddress(name);
+            var proc = _glBindingsContext.GetProcAddress(name);
             if (proc == IntPtr.Zero || proc == new IntPtr(1) || proc == new IntPtr(2))
             {
                 throw new InvalidOperationException($"Unable to load GL function '{name}'!");

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

@@ -4,6 +4,7 @@ using System.Buffers;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.GameObjects;
 using Robust.Client.ResourceManagement;
+using Robust.Shared;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -43,6 +44,7 @@ namespace Robust.Client.Graphics.Clyde
         private ClydeHandle _fovShaderHandle;
         private ClydeHandle _fovLightShaderHandle;
         private ClydeHandle _wallBleedBlurShaderHandle;
+        private ClydeHandle _lightBlurShaderHandle;
         private ClydeHandle _mergeWallLayerShaderHandle;
 
         // Sampler used to sample the FovTexture with linear filtering, used in the lighting FOV pass
@@ -198,6 +200,7 @@ namespace Robust.Client.Graphics.Clyde
             _fovShaderHandle = LoadShaderHandle("/Shaders/Internal/fov.swsl");
             _fovLightShaderHandle = LoadShaderHandle("/Shaders/Internal/fov-lighting.swsl");
             _wallBleedBlurShaderHandle = LoadShaderHandle("/Shaders/Internal/wall-bleed-blur.swsl");
+            _lightBlurShaderHandle = LoadShaderHandle("/Shaders/Internal/light-blur.swsl");
             _mergeWallLayerShaderHandle = LoadShaderHandle("/Shaders/Internal/wall-merge.swsl");
         }
 
@@ -316,18 +319,25 @@ namespace Robust.Client.Graphics.Clyde
             CheckGlError();
         }
 
-        private void DrawLightsAndFov(Viewport viewport, Box2 worldBounds, IEye eye)
+        private void DrawLightsAndFov(Viewport viewport, Box2Rotated worldBounds, Box2 worldAABB, IEye eye)
         {
             if (!_lightManager.Enabled)
             {
                 return;
             }
 
-            var map = eye.Position.MapId;
+            var mapId = eye.Position.MapId;
 
-            var (lights, count, expandedBounds) = GetLightsToRender(map, worldBounds);
+            // If this map has lighting disabled, return
+            if (!_mapManager.GetMapEntity(mapId).GetComponent<IMapComponent>().LightingEnabled)
+            {
+                return;
+            }
 
-            UpdateOcclusionGeometry(map, expandedBounds, eye.Position.Position);
+            var (lights, count, expandedBounds) = GetLightsToRender(mapId, worldBounds, worldAABB);
+            eye.GetViewMatrix(out var eyeTransform, eye.Scale);
+
+            UpdateOcclusionGeometry(mapId, expandedBounds, eyeTransform);
 
             DrawFov(viewport, eye);
 
@@ -424,13 +434,13 @@ namespace Robust.Client.Graphics.Clyde
                     lightShader.SetUniformTextureMaybe(UniIMainTexture, TextureUnit.Texture0);
                 }
 
-                if (!MathHelper.CloseTo(lastRange, component.Radius))
+                if (!MathHelper.CloseToPercent(lastRange, component.Radius))
                 {
                     lastRange = component.Radius;
                     lightShader.SetUniformMaybe("lightRange", lastRange);
                 }
 
-                if (!MathHelper.CloseTo(lastPower, component.Energy))
+                if (!MathHelper.CloseToPercent(lastPower, component.Energy))
                 {
                     lastPower = component.Energy;
                     lightShader.SetUniformMaybe("lightPower", lastPower);
@@ -442,7 +452,7 @@ namespace Robust.Client.Graphics.Clyde
                     lightShader.SetUniformMaybe("lightColor", lastColor);
                 }
 
-                if (_enableSoftShadows && !MathHelper.CloseTo(lastSoftness, component.Softness))
+                if (_enableSoftShadows && !MathHelper.CloseToPercent(lastSoftness, component.Softness))
                 {
                     lastSoftness = component.Softness;
                     lightShader.SetUniformMaybe("lightSoftness", lastSoftness);
@@ -477,6 +487,9 @@ namespace Robust.Client.Graphics.Clyde
 
             CheckGlError();
 
+            if (_cfg.GetCVar(CVars.DisplayBlurLight))
+                BlurLights(viewport, eye);
+
             BlurOntoWalls(viewport, eye);
 
             MergeWallLayer(viewport);
@@ -491,39 +504,41 @@ namespace Robust.Client.Graphics.Clyde
         }
 
         private ((PointLightComponent light, Vector2 pos, float distanceSquared)[] lights, int count, Box2 expandedBounds)
-            GetLightsToRender(MapId map, in Box2 worldBounds)
+            GetLightsToRender(MapId map, in Box2Rotated worldBounds, in Box2 worldAABB)
         {
             var renderingTreeSystem = _entitySystemManager.GetEntitySystem<RenderingTreeSystem>();
-            var enlargedBounds = worldBounds.Enlarged(renderingTreeSystem.MaxLightRadius);
+            var enlargedBounds = worldAABB.Enlarged(renderingTreeSystem.MaxLightRadius);
 
             // Use worldbounds for this one as we only care if the light intersects our actual bounds
-            var state = (this, worldBounds, count: 0);
+            var state = (this, worldAABB, count: 0);
 
             foreach (var comp in renderingTreeSystem.GetRenderTrees(map, enlargedBounds))
             {
-                var bounds = worldBounds.Translated(-comp.Owner.Transform.WorldPosition);
+                var bounds = comp.Owner.Transform.InvWorldMatrix.TransformBox(worldBounds);
 
-                comp.LightTree.QueryAabb(ref state, (ref (Clyde clyde, Box2 worldBounds, int count) state, in PointLightComponent light) =>
+                comp.LightTree.QueryAabb(ref state, (ref (Clyde clyde, Box2 worldAABB, 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;
                     }
 
+                    var transform = light.Owner.Transform;
+
+                    if (float.IsNaN(transform.LocalPosition.X) || float.IsNaN(transform.LocalPosition.Y)) 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))
+                    if (!circle.Intersects(state.worldAABB))
                     {
                         return true;
                     }
 
-                    float distanceSquared = (state.worldBounds.Center - lightPos).LengthSquared;
+                    float distanceSquared = (state.worldAABB.Center - lightPos).LengthSquared;
                     state.clyde._lightsToRenderList[state.count++] = (light, lightPos, distanceSquared);
 
                     return true;
@@ -548,7 +563,7 @@ namespace Robust.Client.Graphics.Clyde
             // We expand the world bounds so that it encompasses the center of every light source.
             // This should make it so no culled occluder can make a difference.
             // (if the occluder is in the current lights at all, it's still not between the light and the world bounds).
-            var expandedBounds = worldBounds;
+            var expandedBounds = worldAABB;
 
             for (var i = 0; i < state.count; i++)
             {
@@ -559,6 +574,69 @@ namespace Robust.Client.Graphics.Clyde
             return (_lightsToRenderList, state.count, expandedBounds);
         }
 
+        private void BlurLights(Viewport viewport, IEye eye)
+        {
+            using var _ = DebugGroup(nameof(BlurLights));
+
+            GL.Disable(EnableCap.Blend);
+            CheckGlError();
+            CalcScreenMatrices(viewport.Size, out var proj, out var view);
+            SetProjViewBuffer(proj, view);
+
+            var shader = _loadedShaders[_lightBlurShaderHandle].Program;
+            shader.Use();
+
+            SetupGlobalUniformsImmediate(shader, viewport.LightRenderTarget.Texture);
+
+            var size = viewport.LightRenderTarget.Size;
+            shader.SetUniformMaybe("size", (Vector2)size);
+            shader.SetUniformTextureMaybe(UniIMainTexture, TextureUnit.Texture0);
+
+            GL.Viewport(0, 0, size.X, size.Y);
+            CheckGlError();
+
+            // Initially we're pulling from the light render target.
+            // So we set it out of the loop so
+            // _wallBleedIntermediateRenderTarget2 gets bound at the end of the loop body.
+            SetTexture(TextureUnit.Texture0, viewport.LightRenderTarget.Texture);
+
+            // Have to scale the blurring radius based on viewport size and camera zoom.
+            const float refCameraHeight = 14;
+            var facBase = _cfg.GetCVar(CVars.DisplayBlurLightFactor);
+            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 = facBase * (refCameraHeight / cameraSize);
+
+            // Multi-iteration gaussian blur.
+            for (var i = 3; i > 0; i--)
+            {
+                var scale = (i + 1) * factor;
+                // Set factor.
+                shader.SetUniformMaybe("radius", scale);
+
+                BindRenderTargetFull(viewport.LightBlurTarget);
+
+                // Blur horizontally to _wallBleedIntermediateRenderTarget1.
+                shader.SetUniformMaybe("direction", Vector2.UnitX);
+                _drawQuad(Vector2.Zero, viewport.Size, Matrix3.Identity, shader);
+
+                SetTexture(TextureUnit.Texture0, viewport.LightBlurTarget.Texture);
+
+                BindRenderTargetFull(viewport.LightRenderTarget);
+
+                // Blur vertically to _wallBleedIntermediateRenderTarget2.
+                shader.SetUniformMaybe("direction", Vector2.UnitY);
+                _drawQuad(Vector2.Zero, viewport.Size, Matrix3.Identity, shader);
+
+                SetTexture(TextureUnit.Texture0, viewport.LightRenderTarget.Texture);
+            }
+
+            GL.Enable(EnableCap.Blend);
+            CheckGlError();
+            // We didn't trample over the old _currentMatrices so just roll it back.
+            SetProjViewBuffer(_currentMatrixProj, _currentMatrixView);
+        }
+
         private void BlurOntoWalls(Viewport viewport, IEye eye)
         {
             using var _ = DebugGroup(nameof(BlurOntoWalls));
@@ -741,7 +819,7 @@ namespace Robust.Client.Graphics.Clyde
             _drawQuad(a, b, Matrix3.Identity, shader);
         }
 
-        private void UpdateOcclusionGeometry(MapId map, Box2 expandedBounds, Vector2 eyePosition)
+        private void UpdateOcclusionGeometry(MapId map, Box2 expandedBounds, Matrix3 eyeTransform)
         {
             // This method generates two sets of occlusion geometry:
             // 3D geometry used during depth projection.
@@ -773,24 +851,11 @@ namespace Robust.Client.Graphics.Clyde
                 var ii = 0;
                 var imi = 0;
 
-                foreach (var gridId in _mapManager.FindGridIdsIntersecting(map, expandedBounds, true))
+                foreach (var comp in occluderSystem.GetOccluderTrees(map, expandedBounds))
                 {
-                    if (!occluderSystem.TryGetOccluderTreeForGrid(map, gridId, out var occluderTree)) continue;
+                    var treeBounds = comp.Owner.Transform.InvWorldMatrix.TransformBox(expandedBounds);
 
-                    Box2 gridBounds;
-
-                    if (gridId == GridId.Invalid)
-                    {
-                        gridBounds = expandedBounds;
-                    }
-                    else
-                    {
-                        // TODO: Ideally this would clamp to the outer border of what we can see
-                        var grid = _mapManager.GetGrid(gridId);
-                        gridBounds = expandedBounds.Translated(-grid.WorldPosition);
-                    }
-
-                    occluderTree.QueryAabb((in OccluderComponent sOccluder) =>
+                    comp.Tree.QueryAabb((in OccluderComponent sOccluder) =>
                     {
                         var occluder = (ClientOccluderComponent)sOccluder;
                         var transform = occluder.Owner.Transform;
@@ -802,16 +867,16 @@ namespace Robust.Client.Graphics.Clyde
                         var worldTransform = transform.WorldMatrix;
                         var box = occluder.BoundingBox;
 
-                        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);
+                        var tl = worldTransform.Transform(box.TopLeft);
+                        var tr = worldTransform.Transform(box.TopRight);
+                        var br = worldTransform.Transform(box.BottomRight);
+                        var bl = worldTransform.Transform(box.BottomLeft);
 
                         // Faces.
-                        var faceN = new Vector4(tlX, tlY, trX, trY);
-                        var faceE = new Vector4(trX, trY, brX, brY);
-                        var faceS = new Vector4(brX, brY, blX, blY);
-                        var faceW = new Vector4(blX, blY, tlX, tlY);
+                        var faceN = new Vector4(tl.X, tl.Y, tr.X, tr.Y);
+                        var faceE = new Vector4(tr.X, tr.Y, br.X, br.Y);
+                        var faceS = new Vector4(br.X, br.Y, bl.X, bl.Y);
+                        var faceW = new Vector4(bl.X, bl.Y, tl.X, tl.Y);
 
                         //
                         // Buckle up.
@@ -844,10 +909,10 @@ namespace Robust.Client.Graphics.Clyde
                         //
 
                         // Calculate delta positions from camera.
-                        var (dTlX, dTlY) = (tlX, tlY) - eyePosition;
-                        var (dTrX, dTrY) = (trX, trY) - eyePosition;
-                        var (dBlX, dBlY) = (blX, blY) - eyePosition;
-                        var (dBrX, dBrY) = (brX, brY) - eyePosition;
+                        var (dTlX, dTlY) = eyeTransform.Transform(tl);
+                        var (dTrX, dTrY) = eyeTransform.Transform(tr);
+                        var (dBlX, dBlY) = eyeTransform.Transform(bl);
+                        var (dBrX, dBrY) = eyeTransform.Transform(br);
 
                         // Get which neighbors are occluding.
                         var no = (occluder.Occluding & OccluderDir.North) != 0;
@@ -908,10 +973,10 @@ namespace Robust.Client.Graphics.Clyde
                         }
 
                         // Generate mask geometry.
-                        arrayMaskBuffer[ami + 0] = new Vector2(tlX, tlY);
-                        arrayMaskBuffer[ami + 1] = new Vector2(trX, trY);
-                        arrayMaskBuffer[ami + 2] = new Vector2(brX, brY);
-                        arrayMaskBuffer[ami + 3] = new Vector2(blX, blY);
+                        arrayMaskBuffer[ami + 0] = new Vector2(tl.X, tl.Y);
+                        arrayMaskBuffer[ami + 1] = new Vector2(tr.X, tr.Y);
+                        arrayMaskBuffer[ami + 2] = new Vector2(br.X, br.Y);
+                        arrayMaskBuffer[ami + 3] = new Vector2(bl.X, bl.Y);
 
                         // Generate mask indices.
                         QuadBatchIndexWrite(indexMaskBuffer, ref imi, (ushort)ami);
@@ -919,7 +984,7 @@ namespace Robust.Client.Graphics.Clyde
                         ami += 4;
 
                         return true;
-                    }, gridBounds);
+                    }, treeBounds);
                 }
 
                 _occlusionDataLength = ii;
@@ -971,6 +1036,11 @@ namespace Robust.Client.Graphics.Clyde
                 lightMapSampleParameters,
                 $"{viewport.Name}-{nameof(viewport.LightRenderTarget)}");
 
+            viewport.LightBlurTarget = CreateRenderTarget(lightMapSize,
+                new RenderTargetFormatParameters(lightMapColorFormat),
+                lightMapSampleParameters,
+                $"{viewport.Name}-{nameof(viewport.LightBlurTarget)}");
+
             viewport.WallBleedIntermediateRenderTarget1 = CreateRenderTarget(lightMapSizeQuart, lightMapColorFormat,
                 lightMapSampleParameters,
                 $"{viewport.Name}-{nameof(viewport.WallBleedIntermediateRenderTarget1)}");