Optimise anchor snap

Robust.Client.CEF Renamed to Robust.Client.WebView since CEF should really be an implementation detail.
Content is no longer responsible for initializing and managing the module, this is done automatically by the engine.
WebView is initialized by declaring it in a manifest.yml file in the game resources. In the future the launcher will read this same file to manage WebView module versions.
CefManager has been made private and the content-visible API is now IWebViewManager.

.appveyor.yml

@@ -1,52 +0,0 @@
-environment:
-  sonarqubekey:
-    secure: h3llq6OeVa94hJ71UOEQSQDq75vFt+doso7iFry0gvt/fFcyeonY9wY+ETOIVITK
-  global:
-    PYTHONUNBUFFERED: True
-    HEADLESS: 1  # For the unit tests.
-
-version: 0.1.0.{build}
-pull_requests:
-  do_not_increment_build_number: true
-
-image: Visual Studio 2019
-install:
-- ps: >
-    if (-Not $env:APPVEYOR_PULL_REQUEST_NUMBER -And $env:APPVEYOR_REPO_BRANCH -Eq "master")
-    {
-      cinst msbuild-sonarqube-runner;
-    }
-
-before_build:
-- cmd: py -3.5 -m pip install --user requests
-- cmd: git submodule update --init --recursive
-- ps: >
-    if (-Not $env:APPVEYOR_PULL_REQUEST_NUMBER -And $env:APPVEYOR_REPO_BRANCH -Eq "master")
-    {
-      SonarScanner.MSBuild.exe begin /k:"ss14" /d:"sonar.host.url=https://sonarcloud.io" /d:"sonar.login=$env:sonarqubekey" /o:"space-wizards" /d:sonar.cs.nunit.reportsPaths="$(Get-Location)\nunitTestResult.xml";
-    }
-
-platform: x64
-configuration: Debug
-
-cache:
-- packages -> **\*.csproj
-- Dependencies
-
-build:
-  project: RobustToolbox.sln
-  parallel: false
-  verbosity: minimal
-
-build_script:
-- ps: dotnet build RobustToolbox.sln /p:AppVeyor=yes
-
-test_script:
-- ps: dotnet test Robust.UnitTesting/Robust.UnitTesting.csproj
-
-after_test:
-- ps: >
-    if (-Not $env:APPVEYOR_PULL_REQUEST_NUMBER -And $env:APPVEYOR_REPO_BRANCH -Eq "master")
-    {
-      SonarScanner.MSBuild.exe end /d:"sonar.login=$env:sonarqubekey";
-    }

.gitmodules

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

Lidgren.Network/Lidgren.Network.csproj

@@ -3,10 +3,10 @@
   <PropertyGroup>
     <TargetFramework>netcoreapp3.1</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
-    <DefineConstants Condition="'$(TargetFramework)' == 'netstandard2.1' or '$(TargetFramework)' == 'netcoreapp3.1'">$(DefineConstants);HAS_FULL_SPAN</DefineConstants>
     <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
     <DefaultItemExcludes>Lidgren.Network/**/*</DefaultItemExcludes>
     <DefineConstants>$(DefineConstants);USE_RELEASE_STATISTICS</DefineConstants>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>

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/fov-lighting.swsl

@@ -2,29 +2,15 @@ preset raw;
 
 #include "/Shaders/Internal/shadow_cast_shared.swsl"
 
+#include "/Shaders/Internal/fov_shared.swsl"
+
 const highp float g_MinVariance = 0.0;
 
-varying highp vec2 worldPosition;
-
-// Center of the FOV, in world coordinates.
-uniform highp vec2 center;
-
-void vertex()
-{
-    highp vec3 transformed = modelMatrix * vec3(VERTEX, 1.0);
-    worldPosition = transformed.xy;
-    transformed = projectionMatrix * viewMatrix * transformed;
-
-    VERTEX = transformed.xy;
-}
-
 void fragment()
 {
-    highp vec2 diff = worldPosition - center;
+    highp float ourDist = length(worldSpaceDiff);
 
-    highp float ourDist = length(diff);
-
-    highp vec2 occlDist = occludeDepth(diff, TEXTURE, 0.25);
+    highp vec2 occlDist = occludeDepth(worldSpaceDiff, TEXTURE, 0.25);
 
     highp float occlusion = ChebyshevUpperBound(occlDist, ourDist);
 

Resources/Shaders/Internal/fov.swsl

@@ -2,32 +2,18 @@ preset raw;
 
 #include "/Shaders/Internal/shadow_cast_shared.swsl"
 
+#include "/Shaders/Internal/fov_shared.swsl"
+
 const highp float g_MinVariance = 0.0;
 
-varying highp vec2 worldPosition;
-
-// Center of the FOV, in world coordinates.
-uniform highp vec2 center;
-
-void vertex()
-{
-    highp vec3 transformed = modelMatrix * vec3(VERTEX, 1.0);
-    worldPosition = transformed.xy;
-    transformed = projectionMatrix * viewMatrix * transformed;
-
-    VERTEX = transformed.xy;
-}
-
 void fragment()
 {
-    highp vec2 diff = worldPosition - center;
+    highp float ourDist = length(worldSpaceDiff);
 
-    highp float ourDist = length(diff);
-
-    highp float occlDist = occludeDepth(diff, TEXTURE, 0.75).r;
+    highp float occlDist = occludeDepth(worldSpaceDiff, TEXTURE, 0.75).r;
 
     // *Very* simple biased shadow check for FOV.
-    if (!doesOcclude(diff, TEXTURE, 0.75, -0.75/32.0))
+    if (!doesOcclude(worldSpaceDiff, TEXTURE, 0.75, -0.75/32.0))
     {
         discard;
     }

Resources/Shaders/Internal/fov_shared.swsl

@@ -0,0 +1,16 @@
+// Shared between fov-lighting.swsl and fov.swsl, which both use the Clyde quad,
+//  manually transformed into clip-space to cover the entire viewport
+
+// World-space position offset from centre to pixel.
+varying highp vec2 worldSpaceDiff;
+
+// Inverted transformation matrix from clip coordinates to difference coordinates.
+uniform highp mat3 clipToDiff;
+
+void vertex()
+{
+    // Convert quad-space (0.0 to 1.0) to clip-space (-1.0 to 1.0)
+    VERTEX = (VERTEX.xy - 0.5) * 2.0;
+    worldSpaceDiff = (clipToDiff * vec3(VERTEX, 1.0)).xy;
+}
+

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;
+}

Resources/Shaders/Internal/light_shared.swsl

@@ -40,7 +40,7 @@ void fragment()
     highp vec2 diff = worldPosition - lightCenter;
 
     // Totally not hacky PCF on top of VSM.
-    highp float occlusion = createOcclusion(diff);
+    highp float occlusion = lightIndex < 0.0 ? 1.0 : createOcclusion(diff);
 
     if (occlusion == 0.0)
     {

Robust.Analyzers/FriendAnalyzer.cs

@@ -0,0 +1,129 @@
+using System.Collections.Generic;
+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 (InheritsFromOrEquals(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}"));
+                }
+            }
+        }
+
+        private bool InheritsFromOrEquals(INamedTypeSymbol type, INamedTypeSymbol baseType)
+        {
+            foreach (var otherType in GetBaseTypesAndThis(type))
+            {
+                if (SymbolEqualityComparer.Default.Equals(otherType, baseType))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private IEnumerable<INamedTypeSymbol> GetBaseTypesAndThis(INamedTypeSymbol namedType)
+        {
+            var current = namedType;
+            while (current != null)
+            {
+                yield return current;
+                current = current.BaseType;
+            }
+        }
+    }
+}

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.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/Robust.Client.NameGenerator.csproj

@@ -13,5 +13,6 @@
     <Compile Link="XamlX\filename" Include="../XamlX/src/XamlX/**/*.cs" />
     <Compile Remove="../XamlX/src/XamlX/**/SreTypeSystem.cs" />
     <Compile Remove="../XamlX/src/XamlX/obj/**" />
+    <Compile Include="..\Robust.Client\UserInterface\ControlPropertyAccess.cs" />
   </ItemGroup>
 </Project>

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -6,6 +6,7 @@ using System.Text;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
+using Robust.Client.UserInterface;
 using XamlX.Ast;
 using XamlX.Emit;
 using XamlX.IL;
@@ -37,9 +38,10 @@ namespace Robust.Client.AutoGenerated
 
         class NameVisitor : IXamlAstVisitor
         {
-            private List<(string name, string type)> _names = new List<(string name, string type)>();
+            private readonly List<(string name, string type, AccessLevel access)> _names =
+                new List<(string name, string type, AccessLevel access)>();
 
-            public static List<(string name, string type)> GetNames(IXamlAstNode node)
+            public static List<(string name, string type, AccessLevel access)> GetNames(IXamlAstNode node)
             {
                 var visitor = new NameVisitor();
                 node.Visit(visitor);
@@ -56,27 +58,42 @@ namespace Robust.Client.AutoGenerated
                 {
                     var clrtype = objectNode.Type.GetClrType();
                     var isControl = IsControl(clrtype);
-                    //clrtype.Interfaces.Any(i =>
-                    //i.IsInterface && i.FullName == "Robust.Client.UserInterface.IControl");
 
                     if (!isControl)
                         return node;
 
+                    // Find Name and Access properties
+                    XamlAstTextNode nameText = null;
+                    XamlAstTextNode accessText = null;
                     foreach (var child in objectNode.Children)
                     {
                         if (child is XamlAstXamlPropertyValueNode propertyValueNode &&
                             propertyValueNode.Property is XamlAstNamePropertyReference namedProperty &&
-                            namedProperty.Name == "Name" &&
                             propertyValueNode.Values.Count > 0 &&
                             propertyValueNode.Values[0] is XamlAstTextNode text)
                         {
-                            var reg = (text.Text, $@"{clrtype.Namespace}.{clrtype.Name}");
-                            if (!_names.Contains(reg))
+                            switch (namedProperty.Name)
                             {
-                                _names.Add(reg);
+                                case "Name":
+                                    nameText = text;
+                                    break;
+                                case "Access":
+                                    accessText = text;
+                                    break;
                             }
                         }
                     }
+
+                    if (nameText == null)
+                        return node;
+
+                    var reg = (nameText.Text,
+                        $@"{clrtype.Namespace}.{clrtype.Name}",
+                        accessText != null ? (AccessLevel) Enum.Parse(typeof(AccessLevel), accessText.Text) : AccessLevel.Protected);
+                    if (!_names.Contains(reg))
+                    {
+                        _names.Add(reg);
+                    }
                 }
 
                 return node;
@@ -94,7 +111,8 @@ namespace Robust.Client.AutoGenerated
         private static string GenerateSourceCode(
             INamedTypeSymbol classSymbol,
             string xamlFile,
-            CSharpCompilation comp)
+            CSharpCompilation comp,
+            string fileName)
         {
             var className = classSymbol.Name;
             var nameSpace = classSymbol.ContainingNamespace.ToDisplayString();
@@ -112,11 +130,48 @@ namespace Robust.Client.AutoGenerated
             compiler.Transform(parsed);
             var initialRoot = (XamlAstObjectNode) parsed.Root;
             var names = NameVisitor.GetNames(initialRoot);
-            var fieldAccess = classSymbol.IsSealed ? "private" : "protected";
-            //var names = NameVisitor.GetNames((XamlAstObjectNode)XDocumentXamlParser.Parse(xamlFile).Root);
-            var namedControls = names.Select(info => "        " +
-                                                     $"{fieldAccess} global::{info.type} {info.name} => " +
-                                                     $"this.FindControl<global::{info.type}>(\"{info.name}\");");
+
+            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 namedControls = names.Select(info =>
+            {
+                (string name, string type, AccessLevel access) = info;
+
+                string accessStr;
+                switch (access)
+                {
+                    case AccessLevel.Public:
+                        accessStr = "public";
+                        break;
+                    case AccessLevel.Protected when classSymbol.IsSealed:
+                    case AccessLevel.PrivateProtected when classSymbol.IsSealed:
+                    case AccessLevel.Private:
+                        accessStr = "private";
+                        break;
+                    case AccessLevel.Protected:
+                        accessStr = "protected";
+                        break;
+                    case AccessLevel.PrivateProtected:
+                        accessStr = "private protected";
+                        break;
+                    case AccessLevel.Internal:
+                    case AccessLevel.ProtectedInternal when classSymbol.IsSealed:
+                        accessStr = "internal";
+                        break;
+                    case AccessLevel.ProtectedInternal:
+                        accessStr = "protected internal";
+                        break;
+                    default:
+                        throw new ArgumentException($"Invalid access level \"{Enum.GetName(typeof(AccessLevel), access)}\" " +
+                                                    $"for control {name} in file {fileName}.");
+                }
+
+                return $"        {accessStr} global::{type} {name} => this.FindControl<global::{type}>(\"{name}\");";
+            });
+
             return $@"// <auto-generated />
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
@@ -130,7 +185,6 @@ namespace {nameSpace}
 ";
         }
 
-
         public void Execute(GeneratorExecutionContext context)
         {
             var comp = (CSharpCompilation) context.Compilation;
@@ -201,9 +255,24 @@ namespace {nameSpace}
 
                 try
                 {
-                    var sourceCode = GenerateSourceCode(typeSymbol, txt, comp);
+                    var sourceCode = GenerateSourceCode(typeSymbol, txt, comp, xamlFileName);
                     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 +326,7 @@ namespace {nameSpace}
                     context.ReportDiagnostic(
                         Diagnostic.Create(
                             new DiagnosticDescriptor(
-                                "RXN0004",
+                                "RXN0006",
                                 missingPartialKeywordMessage,
                                 missingPartialKeywordMessage,
                                 "Usage",

Robust.Client.WebView/BeforeBrowseContext.cs

@@ -0,0 +1,32 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/BrowserWindowCreateParameters.cs

@@ -0,0 +1,16 @@
+namespace Robust.Client.WebView
+{
+    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.WebView/CefKeyCodes.cs

@@ -0,0 +1,225 @@
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Robust.Client.WebView
+{
+    [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.WebView/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.WebView
+{
+    internal partial class CefManager
+    {
+        [Dependency] private readonly IClydeInternal _clyde = default!;
+
+        private readonly List<WebViewWindowImpl> _browserWindows = new();
+
+        public IEnumerable<IWebViewWindow> AllBrowserWindows => _browserWindows;
+
+        public IWebViewWindow 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 WebViewWindowImpl(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 WebViewWindowImpl : IWebViewWindow
+        {
+            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 WebViewWindowImpl(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 WebViewWindowImpl _windowImpl;
+
+            public WindowLifeSpanHandler(WebViewWindowImpl windowImpl)
+            {
+                _windowImpl = windowImpl;
+            }
+
+            protected override void OnBeforeClose(CefBrowser browser)
+            {
+                base.OnBeforeClose(browser);
+
+                _windowImpl.OnClose();
+            }
+        }
+    }
+}

Robust.Client.WebView/CefManager.cs

@@ -0,0 +1,96 @@
+using System;
+using System.IO;
+using Robust.Client.WebView;
+using Robust.Client.WebViewHook;
+using Robust.Shared.ContentPack;
+using Robust.Shared.IoC;
+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;
+
+[assembly: WebViewManagerImpl(typeof(CefManager))]
+
+namespace Robust.Client.WebView
+{
+    internal partial class CefManager : IWebViewManagerHook, IWebViewManager
+    {
+        private CefApp _app = default!;
+        private bool _initialized = false;
+
+        public void Initialize()
+        {
+            IoCManager.RegisterInstance<IWebViewManager>(this);
+            IoCManager.RegisterInstance<CefManager>(this);
+
+            DebugTools.Assert(!_initialized);
+
+            string subProcessName;
+            if (OperatingSystem.IsWindows())
+                subProcessName = "Robust.Client.WebView.exe";
+            else if (OperatingSystem.IsLinux())
+                subProcessName = "Robust.Client.WebView";
+            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_94.4.1+g4b61a8c+chromium-94.0.4606.54
+            // Windows: https://cef-builds.spotifycdn.com/cef_binary_94.4.1%2Bg4b61a8c%2Bchromium-94.0.4606.54_windows64_minimal.tar.bz2
+            // Linux: https://cef-builds.spotifycdn.com/cef_binary_94.4.1%2Bg4b61a8c%2Bchromium-94.0.4606.54_linux64_minimal.tar.bz2
+            // Here's how to get it to work:
+            // 1. Copy all the contents of "Release" to the bin/Content.Client folder.
+            // 2. Copy all the contents of "Resources" to the bin/Content.Client folder.
+            // -------------------------------------------------------------------------------------
+
+            _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!");
+        }
+
+        public void Update()
+        {
+            DebugTools.Assert(_initialized);
+
+            // Calling this makes CEF do its work, without using its own update loop.
+            CefRuntime.DoMessageLoopWork();
+        }
+
+        public void Shutdown()
+        {
+            DebugTools.Assert(_initialized);
+
+            CefRuntime.Shutdown();
+        }
+    }
+}

Robust.Client.WebView/IWebViewControl.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Robust.Client.WebView
+{
+    public interface IWebViewControl
+    {
+        /// <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.WebView/IWebViewManager.cs

@@ -0,0 +1,7 @@
+namespace Robust.Client.WebView
+{
+    public interface IWebViewManager
+    {
+        IWebViewWindow CreateBrowserWindow(BrowserWindowCreateParameters createParams);
+    }
+}

Robust.Client.WebView/IWebViewWindow.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Robust.Client.WebView
+{
+    public interface IWebViewWindow : IWebViewControl, IDisposable
+    {
+        bool Closed { get; }
+    }
+}

Robust.Client.WebView/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.WebView
+{
+    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.WebView/Program.cs

@@ -0,0 +1,33 @@
+using System;
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/RequestHandlerContext.cs

@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/RequestResults.cs

@@ -0,0 +1,100 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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()
+            {
+            }
+
+            protected override void Dispose(bool disposing)
+            {
+                base.Dispose(disposing);
+
+                _stream.Dispose();
+            }
+        }
+    }
+}

Robust.Client.WebView/Robust.Client.WebView.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.WebView/RobustCefApp.cs

@@ -0,0 +1,48 @@
+using System;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/RobustCefClient.cs

@@ -0,0 +1,23 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    // 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.WebView/RobustLoadHandler.cs

@@ -0,0 +1,17 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/RobustRequestHandler.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.WebView
+{
+    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.WebView/WebViewControl.cs

@@ -0,0 +1,595 @@
+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.WebView.CefKeyCodes;
+using static Robust.Client.WebView.CefKeyCodes.ChromiumKeyboardCode;
+using static Robust.Client.Input.Keyboard;
+
+namespace Robust.Client.WebView
+{
+    /// <summary>
+    /// An UI control that presents web content.
+    /// </summary>
+    public sealed class WebViewControl : Control, IWebViewControl, 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 WebViewControl()
+        {
+            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/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 SharedPhysicsSystem _broadPhaseSystem = default!;
 
         [ViewVariables]
         public bool IsAvailable
@@ -88,13 +88,14 @@ namespace Robust.Client.Audio.Midi
         private float _volume = 0f;
         private bool _volumeDirty = true;
 
+        // Not reliable until Fluidsynth is initialized!
         [ViewVariables(VVAccess.ReadWrite)]
         public float Volume
         {
             get => _volume;
             set
             {
-                if (MathHelper.CloseTo(_volume, value))
+                if (MathHelper.CloseToPercent(_volume, value))
                     return;
 
                 _cfgMan.SetCVar(CVars.MidiVolume, value);
@@ -134,6 +135,7 @@ namespace Robust.Client.Audio.Midi
         {
             if (FluidsynthInitialized || _failedInitialize) return;
 
+            _volume = _cfgMan.GetCVar(CVars.MidiVolume);
             _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
             {
                 _volume = value;
@@ -175,7 +177,7 @@ namespace Robust.Client.Audio.Midi
             _midiThread = new Thread(ThreadUpdate);
             _midiThread.Start();
 
-            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
+            _broadPhaseSystem = EntitySystem.Get<SharedPhysicsSystem>();
             FluidsynthInitialized = true;
         }
 
@@ -254,11 +256,12 @@ namespace Robust.Client.Audio.Midi
                         renderer.LoadSoundfont(WindowsSoundfont, true);
                 }
 
+                renderer.Source.SetVolume(Volume);
+
                 lock (_renderers)
                 {
                     _renderers.Add(renderer);
                 }
-
                 return renderer;
             }
             finally

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;
 
@@ -39,6 +37,11 @@ namespace Robust.Client.Audio.Midi
         /// </summary>
         bool LoopMidi { get; set; }
 
+        /// <summary>
+        ///     This increases all note on velocities to 127.
+        /// </summary>
+        bool VolumeBoost { get; set; }
+
         /// <summary>
         ///     The midi program (instrument) the renderer is using.
         /// </summary>
@@ -220,7 +223,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 +237,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 +251,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;
@@ -299,6 +302,9 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool VolumeBoost { get; set; }
+
         [ViewVariables(VVAccess.ReadWrite)]
         public IEntity? TrackingEntity { get; set; } = null;
 
@@ -541,6 +547,8 @@ namespace Robust.Client.Audio.Midi
 
                         // Note On 0x90
                         case 144:
+                            if (VolumeBoost)
+                                midiEvent.Velocity = 127;
                             _synth.NoteOn(midiEvent.Channel, midiEvent.Key, midiEvent.Velocity);
                             break;
 
@@ -575,16 +583,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 +646,7 @@ namespace Robust.Client.Audio.Midi
             _sequencer?.UnregisterClient(_debugRegister);
             _sequencer?.UnregisterClient(_synthRegister);
             _sequencer?.Dispose();
-            
+
             _synth?.Dispose();
             _player?.Dispose();
         }

Robust.Client/BaseClient.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net;
 using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
@@ -31,7 +31,6 @@ namespace Robust.Client
         [Dependency] private readonly IDiscordRichPresence _discord = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IClientGameStateManager _gameStates = default!;
-        [Dependency] private readonly IDebugDrawingManager _debugDrawMan = default!;
 
         /// <inheritdoc />
         public ushort DefaultPort { get; } = 1212;
@@ -57,7 +56,6 @@ namespace Robust.Client
             _configManager.OnValueChanged(CVars.NetTickrate, TickRateChanged, invokeImmediately: true);
 
             _playMan.Initialize();
-            _debugDrawMan.Initialize();
             Reset();
         }
 

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;
@@ -71,11 +72,11 @@ namespace Robust.Client
             IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
             IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
             IoCManager.Register<IDebugDrawing, DebugDrawing>();
-            IoCManager.Register<IDebugDrawingManager, DebugDrawingManager>();
             IoCManager.Register<ILightManager, LightManager>();
             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";
@@ -200,16 +188,16 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (!int.TryParse(args[0], out var id))
+            if (!float.TryParse(args[0], out var duration))
             {
-                shell.WriteError($"{args[0]} is not a valid integer.");
+                shell.WriteError($"{args[0]} is not a valid float.");
                 return;
             }
 
-            var mgr = IoCManager.Resolve<IDebugDrawingManager>();
+            var mgr = EntitySystem.Get<DebugRayDrawingSystem>();
             mgr.DebugDrawRays = !mgr.DebugDrawRays;
-            shell.WriteError("Toggled showing rays to:" + mgr.DebugDrawRays.ToString());
-            mgr.DebugRayLifetime = TimeSpan.FromSeconds((double)int.Parse(args[0], CultureInfo.InvariantCulture));
+            shell.WriteError("Toggled showing rays to:" + mgr.DebugDrawRays);
+            mgr.DebugRayLifetime = TimeSpan.FromSeconds(duration);
         }
     }
 
@@ -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/HelpCommands.cs

@@ -63,7 +63,7 @@ namespace Robust.Client.Console.Commands
 
             var conGroup = IoCManager.Resolve<IClientConGroupController>();
             foreach (var command in shell.ConsoleHost.RegisteredCommands.Values
-                .Where(p => p.Command.Contains(filter) && conGroup.CanCommand(p.Command))
+                .Where(p => p.Command.Contains(filter) && (p is not ServerDummyCommand || conGroup.CanCommand(p.Command)))
                 .OrderBy(c => c.Command))
             {
                 shell.WriteLine(command.Command + ": " + command.Description);

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} <aabbs / contactnormals / contactpoints / joints / shapeinfo / shapes>";
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             if (args.Length != 1)
@@ -21,12 +21,21 @@ namespace Robust.Client.Console.Commands
 
             switch (args[0])
             {
+                case "aabbs":
+                    system.Flags ^= PhysicsDebugFlags.AABBs;
+                    break;
                 case "contactnormals":
                     system.Flags ^= PhysicsDebugFlags.ContactNormals;
                     break;
                 case "contactpoints":
                     system.Flags ^= PhysicsDebugFlags.ContactPoints;
                     break;
+                case "joints":
+                    system.Flags ^= PhysicsDebugFlags.Joints;
+                    break;
+                case "shapeinfo":
+                    system.Flags ^= PhysicsDebugFlags.ShapeInfo;
+                    break;
                 case "shapes":
                     system.Flags ^= PhysicsDebugFlags.Shapes;
                     break;

Robust.Client/Console/Completions.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Collections.Immutable;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Input;
+using Robust.Shared.Maths;
+using Robust.Shared.Network.Messages;
+using Robust.Shared.Utility;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
+using static Robust.Shared.Network.Messages.MsgScriptCompletionResponse;
+
+namespace Robust.Client.Console
+{
+    public class Completions : SS14Window
+    {
+        private HistoryLineEdit _textBar;
+        private ScrollContainer _suggestPanel = new()
+        {
+            HScrollEnabled = false,
+        };
+
+        private BoxContainer _suggestBox = new()
+        {
+            Orientation = LayoutOrientation.Vertical,
+            HorizontalAlignment = HAlignment.Left,
+        };
+
+        public Completions(HistoryLineEdit textBar) : base()
+        {
+            Title = "Suggestions";
+            MouseFilter = MouseFilterMode.Pass;
+
+            _textBar = textBar;
+            _suggestPanel.AddChild(_suggestBox);
+            ContentsContainer.AddChild(_suggestPanel);
+        }
+
+        private bool _firstopen = true;
+        public void OpenAt(Vector2 position, Vector2 size)
+        {
+            if (_firstopen)
+            {
+                SetSize = size;
+                LayoutContainer.SetPosition(this, position);
+                _firstopen = false;
+            }
+            Open();
+        }
+
+        private ImmutableArray<LiteResult> _results;
+
+        public void Update()
+        {
+            _suggestBox.RemoveAllChildren();
+            foreach (var res in _results)
+            {
+                var label = new Entry(res);
+
+                label.OnKeyBindDown += ev =>
+                {
+                    if (ev.Function == EngineKeyFunctions.UIClick)
+                        _textBar.InsertAtCursor(label.Result.Properties["InsertionText"]);
+                };
+
+                _suggestBox.AddChild(label);
+            }
+        }
+
+        public void TextChanged() => Close();
+
+        public void SetSuggestions(MsgScriptCompletionResponse response)
+        {
+            _results = response.Results;
+            Update();
+        }
+
+        // Label and ghetto button.
+        public class Entry : RichTextLabel
+        {
+            public readonly LiteResult Result;
+
+            public Entry(LiteResult result)
+            {
+                MouseFilter = MouseFilterMode.Stop;
+                Result = result;
+                var compl = new FormattedMessage();
+                var dim = Color.FromHsl((0f, 0f, 0.8f, 1f));
+
+                // warning: ew ahead
+                string basen = "default";
+                if (Result.Tags.Contains("Interface"))
+                    basen = "interface name";
+                else if (Result.Tags.Contains("Class"))
+                    basen = "class name";
+                else if (Result.Tags.Contains("Struct"))
+                    basen = "struct name";
+                else if (Result.Tags.Contains("Keyword"))
+                    basen = "keyword";
+                else if (Result.Tags.Contains("Namespace"))
+                    basen = "namespace name";
+                else if (Result.Tags.Contains("Method"))
+                    basen = "method name";
+                else if (Result.Tags.Contains("Property"))
+                    basen = "property name";
+                else if (Result.Tags.Contains("Field"))
+                    basen = "field name";
+
+                Color basec = ScriptingColorScheme.ColorScheme[basen];
+                compl.PushColor(basec * dim);
+                compl.AddText(Result.DisplayTextPrefix);
+                compl.PushColor(basec);
+                compl.AddText(Result.DisplayText);
+                compl.PushColor(basec * dim);
+                compl.AddText(Result.DisplayTextSuffix);
+                compl.AddText(" [" + String.Join(", ", Result.Tags) + "]");
+                if (Result.InlineDescription.Length != 0)
+                {
+                    compl.PushNewline();
+                    compl.AddText(": ");
+                    compl.PushColor(Color.LightSlateGray);
+                    compl.AddText(Result.InlineDescription);
+                }
+                SetMessage(compl);
+            }
+        }
+    }
+}

Robust.Client/Console/ScriptClient.ScriptConsoleServer.cs

@@ -46,6 +46,16 @@ namespace Robust.Client.Console
 
             }
 
+            protected override void Complete()
+            {
+                var msg = _client._netManager.CreateNetMessage<MsgScriptCompletion>();
+                msg.ScriptSession = _session;
+                msg.Code = InputBar.Text;
+                msg.Cursor = InputBar.CursorPosition;
+
+                _client._netManager.ClientSendMessage(msg);
+            }
+
             public override void Close()
             {
                 base.Close();
@@ -95,6 +105,12 @@ namespace Robust.Client.Console
 
                 OutputPanel.AddText(">");
             }
+
+            public void ReceiveCompletionResponse(MsgScriptCompletionResponse response)
+            {
+                Suggestions.SetSuggestions(response);
+                Suggestions.OpenAt((Position.X + Size.X, Position.Y), (Size.X / 2, Size.Y));
+            }
         }
     }
 }

Robust.Client/Console/ScriptClient.cs

@@ -20,6 +20,8 @@ namespace Robust.Client.Console
             _netManager.RegisterNetMessage<MsgScriptStop>();
             _netManager.RegisterNetMessage<MsgScriptEval>();
             _netManager.RegisterNetMessage<MsgScriptStart>();
+            _netManager.RegisterNetMessage<MsgScriptCompletion>();
+            _netManager.RegisterNetMessage<MsgScriptCompletionResponse>(ReceiveScriptCompletionResponse);
             _netManager.RegisterNetMessage<MsgScriptResponse>(ReceiveScriptResponse);
             _netManager.RegisterNetMessage<MsgScriptStartAck>(ReceiveScriptStartAckResponse);
         }
@@ -44,6 +46,16 @@ namespace Robust.Client.Console
             console.ReceiveResponse(message);
         }
 
+        private void ReceiveScriptCompletionResponse(MsgScriptCompletionResponse message)
+        {
+            if (!_activeConsoles.TryGetValue(message.ScriptSession, out var console))
+            {
+                return;
+            }
+
+            console.ReceiveCompletionResponse(message);
+        }
+
         public bool CanScript => _conGroupController.CanScript();
 
         public void StartSession()

Robust.Client/Console/ScriptConsoleClient.cs

@@ -13,10 +13,11 @@ using Microsoft.CodeAnalysis.Text;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.ViewVariables;
 using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Utility;
+using SixLabors.ImageSharp;
+using Color = Robust.Shared.Maths.Color;
 
 #nullable enable
 
@@ -52,6 +53,9 @@ namespace Robust.Client.Console
             OutputPanel.AddText(">");
         }
 
+        // No-op for now.
+        protected override void Complete() { }
+
         protected override async void Run()
         {
             var code = InputBar.Text;
@@ -116,7 +120,7 @@ namespace Robust.Client.Console
             }
             else
             {
-                var options = ScriptInstanceShared.GetScriptOptions(_reflectionManager);
+                var options = ScriptInstanceShared.GetScriptOptions(_reflectionManager).AddReferences(typeof(Image).Assembly);
                 newScript = CSharpScript.Create(code, options, typeof(ScriptGlobals));
             }
 

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,60 @@
 * 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;
+using Robust.Shared.Physics.Dynamics.Joints;
 
 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 +83,14 @@ 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(
+                            EntityManager,
+                            IoCManager.Resolve<IEyeManager>(),
+                            IoCManager.Resolve<IInputManager>(),
+                            IoCManager.Resolve<IResourceCache>(),
+                            this,
+                            Get<SharedPhysicsSystem>()));
 
                 if (value == PhysicsDebugFlags.None)
                     IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
@@ -66,7 +103,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 +112,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,58 +144,288 @@ 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,
+        Joints = 1 << 4,
+        AABBs = 1 << 5,
     }
 
     internal sealed class PhysicsDebugOverlay : Overlay
     {
-        private DebugPhysicsSystem _physics = default!;
+        private IEntityManager _entityManager = default!;
+        private IEyeManager _eyeManager = default!;
+        private IInputManager _inputManager = default!;
+        private DebugPhysicsSystem _debugPhysicsSystem = default!;
+        private SharedPhysicsSystem _physicsSystem = default!;
 
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+        public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
 
-        public PhysicsDebugOverlay(DebugPhysicsSystem system)
+        private static readonly Color JointColor = new(0.5f, 0.8f, 0.8f);
+
+        private readonly Font _font;
+
+        private HashSet<Joint> _drawnJoints = new();
+
+        public PhysicsDebugOverlay(IEntityManager entityManager, IEyeManager eyeManager, IInputManager inputManager, IResourceCache cache, DebugPhysicsSystem system, SharedPhysicsSystem physicsSystem)
         {
-            _physics = system;
+            _entityManager = entityManager;
+            _eyeManager = eyeManager;
+            _inputManager = inputManager;
+            _debugPhysicsSystem = system;
+            _physicsSystem = physicsSystem;
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+        }
+
+        private void DrawWorld(DrawingHandleWorld worldHandle)
+        {
+            var viewport = _eyeManager.GetWorldViewport();
+            var viewBounds = _eyeManager.GetWorldViewbounds();
+            var mapId = _eyeManager.CurrentMap;
+
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Shapes) != 0 && !viewport.IsEmpty())
+            {
+                foreach (var physBody in _physicsSystem.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 ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.AABBs) != 0 && !viewport.IsEmpty())
+            {
+                foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
+                {
+                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+
+                    var xform = physBody.GetTransform();
+
+                    const float AlphaModifier = 0.2f;
+                    Box2? aabb = null;
+
+                    foreach (var fixture in physBody.Fixtures)
+                    {
+                        for (var i = 0; i < fixture.Shape.ChildCount; i++)
+                        {
+                            var shapeBB = fixture.Shape.ComputeAABB(xform, i);
+                            aabb = aabb?.Union(shapeBB) ?? shapeBB;
+                        }
+                    }
+
+                    if (aabb == null) continue;
+
+                    worldHandle.DrawRect(aabb.Value, Color.Red.WithAlpha(AlphaModifier), false);
+                }
+            }
+
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Joints) != 0x0)
+            {
+                _drawnJoints.Clear();
+
+                foreach (var jointComponent in _entityManager.EntityQuery<JointComponent>(true))
+                {
+                    if (jointComponent.JointCount == 0 ||
+                        !_entityManager.TryGetComponent(jointComponent.Owner.Uid, out TransformComponent? xf1) ||
+                        !viewport.Contains(xf1.WorldPosition)) continue;
+
+                    foreach (var (_, joint) in jointComponent.Joints)
+                    {
+                        if (_drawnJoints.Contains(joint)) continue;
+                        DrawJoint(worldHandle, joint);
+                        _drawnJoints.Add(joint);
+                    }
+                }
+            }
+
+            if ((_debugPhysicsSystem.Flags & (PhysicsDebugFlags.ContactPoints | PhysicsDebugFlags.ContactNormals)) != 0)
+            {
+                const float axisScale = 0.3f;
+
+                for (var i = 0; i < _debugPhysicsSystem.PointCount; ++i)
+                {
+                    var point = _debugPhysicsSystem.Points[i];
+
+                    const float radius = 0.1f;
+
+                    if ((_debugPhysicsSystem.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 ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ContactNormals) != 0)
+                    {
+                        Vector2 p1 = point.Position;
+                        Vector2 p2 = p1 + point.Normal * axisScale;
+                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 255));
+                    }
+                }
+
+                _debugPhysicsSystem.PointCount = 0;
+            }
+        }
+
+        private void DrawScreen(DrawingHandleScreen screenHandle)
+        {
+            var mapId = _eyeManager.CurrentMap;
+            var mousePos = _inputManager.MouseScreenPosition;
+
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
+            {
+                var hoverBodies = new List<PhysicsComponent>();
+                var bounds = Box2.UnitCentered.Translated(_eyeManager.ScreenToMap(mousePos.Position).Position);
+
+                foreach (var physBody in _physicsSystem.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;
+            if (_debugPhysicsSystem.Flags == PhysicsDebugFlags.None) return;
 
-            var worldHandle = args.WorldHandle;
-
-            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0)
+            switch (args.Space)
             {
-                // Port DebugDrawing over.
+                case OverlaySpace.ScreenSpace:
+                    DrawScreen((DrawingHandleScreen) args.DrawingHandle);
+                    break;
+                case OverlaySpace.WorldSpace:
+                    DrawWorld((DrawingHandleWorld) args.DrawingHandle);
+                    break;
             }
+        }
 
-            if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+        private void DrawShape(DrawingHandleWorld worldHandle, Fixture fixture, Transform xform, Color color)
+        {
+            switch (fixture.Shape)
             {
-                const float axisScale = 0.3f;
+                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);
 
-                for (int i = 0; i < _physics.PointCount; ++i)
-                {
-                    DebugPhysicsSystem.ContactPoint point = _physics._points[i];
-
-                    if (point.State == PointState.Add)
-                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 243, 77));
-                    else if (point.State == PointState.Persist)
-                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 77, 77));
-
-                    if ((_physics.Flags & PhysicsDebugFlags.ContactNormals) != 0)
+                    if (edge.OneSided)
                     {
-                        Vector2 p1 = point.Position;
-                        Vector2 p2 = p1 + point.Normal * axisScale;
-                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 102));
+                        worldHandle.DrawCircle(v1, 0.5f, color);
+                        worldHandle.DrawCircle(v2, 0.5f, color);
                     }
-                }
 
-                _physics.PointCount = 0;
+                    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;
+            }
+        }
+
+        private void DrawJoint(DrawingHandleWorld worldHandle, Joint joint)
+        {
+            if (!_entityManager.TryGetComponent(joint.BodyAUid, out TransformComponent? xform1) ||
+                !_entityManager.TryGetComponent(joint.BodyBUid, out TransformComponent? xform2)) return;
+
+            var matrix1 = xform1.WorldMatrix;
+            var matrix2 = xform2.WorldMatrix;
+
+            var xf1 = new Vector2(matrix1.R0C2, matrix1.R1C2);
+            var xf2 = new Vector2(matrix2.R0C2, matrix2.R1C2);
+
+            var p1 = matrix1.Transform(joint.LocalAnchorA);
+            var p2 = matrix2.Transform(joint.LocalAnchorB);
+
+            switch (joint)
+            {
+                case DistanceJoint:
+                    worldHandle.DrawLine(xf1, xf2, JointColor);
+                    break;
+                default:
+                    worldHandle.DrawLine(xf1, p1, JointColor);
+                    worldHandle.DrawLine(p1, p2, JointColor);
+                    worldHandle.DrawLine(xf2, p2, JointColor);
+                    break;
             }
         }
     }

Robust.Client/Debugging/DebugRayDrawingSystem.cs

@@ -2,21 +2,22 @@ using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
+using Robust.Shared.Physics;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.Debugging
 {
-    internal class DebugDrawingManager : IDebugDrawingManager
+    internal sealed class DebugRayDrawingSystem : EntitySystem
     {
-        [Dependency] private readonly IClientNetManager _net = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly IGameTiming _gameTimer = default!;
 
-        private readonly List<RayWithLifetime> raysWithLifeTime = new();
+        private readonly List<RayWithLifetime> _raysWithLifeTime = new();
         private bool _debugDrawRays;
 
         private struct RayWithLifetime
@@ -52,9 +53,30 @@ namespace Robust.Client.Debugging
 
         public TimeSpan DebugRayLifetime { get; set; } = TimeSpan.FromSeconds(5);
 
-        public void Initialize()
+        public override void Initialize()
         {
-            _net.RegisterNetMessage<MsgRay>(HandleDrawRay);
+            base.Initialize();
+            SubscribeNetworkEvent<MsgRay>(HandleDrawRay);
+            // To catch anything that's client-only and not sent by the server.
+            SubscribeLocalEvent<DebugDrawRayMessage>(OnDebugDrawRay);
+        }
+
+        private void OnDebugDrawRay(DebugDrawRayMessage ev)
+        {
+            if (!_debugDrawRays)
+            {
+                return;
+            }
+
+            var newRayWithLifetime = new RayWithLifetime
+            {
+                DidActuallyHit = ev.Data.Results != null,
+                RayOrigin = ev.Data.Ray.Position,
+                RayHit = ev.Data.Results?.HitPos ?? ev.Data.Ray.Direction * ev.Data.MaxLength + ev.Data.Ray.Position,
+                LifeTime = _gameTimer.RealTime + DebugRayLifetime
+            };
+
+            _raysWithLifeTime.Add(newRayWithLifetime);
         }
 
         private void HandleDrawRay(MsgRay msg)
@@ -74,15 +96,15 @@ namespace Robust.Client.Debugging
                 LifeTime = _gameTimer.RealTime + DebugRayLifetime
             };
 
-            raysWithLifeTime.Add(newRayWithLifetime);
+            _raysWithLifeTime.Add(newRayWithLifetime);
         }
 
         private sealed class DebugDrawRayOverlay : Overlay
         {
-            private readonly DebugDrawingManager _owner;
+            private readonly DebugRayDrawingSystem _owner;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public DebugDrawRayOverlay(DebugDrawingManager owner)
+            public DebugDrawRayOverlay(DebugRayDrawingSystem owner)
             {
                 _owner = owner;
             }
@@ -90,7 +112,7 @@ namespace Robust.Client.Debugging
             protected internal override void Draw(in OverlayDrawArgs args)
             {
                 var handle = args.WorldHandle;
-                foreach (var ray in _owner.raysWithLifeTime)
+                foreach (var ray in _owner._raysWithLifeTime)
                 {
                     handle.DrawLine(
                         ray.RayOrigin,
@@ -103,7 +125,7 @@ namespace Robust.Client.Debugging
             {
                 base.FrameUpdate(args);
 
-                _owner.raysWithLifeTime.RemoveAll(r => r.LifeTime < _owner._gameTimer.RealTime);
+                _owner._raysWithLifeTime.RemoveAll(r => r.LifeTime < _owner._gameTimer.RealTime);
             }
         }
     }

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/Debugging/IDebugDrawingManager.cs

@@ -1,11 +0,0 @@
-using System;
-
-namespace Robust.Client.Debugging
-{
-    public interface IDebugDrawingManager
-    {
-        bool DebugDrawRays { get; set; }
-        TimeSpan DebugRayLifetime { get; set; }
-        void Initialize();
-    }
-}

Robust.Client/GameController/GameController.RobustModules.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Reflection;
+using Robust.Client.WebViewHook;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+namespace Robust.Client
+{
+    internal sealed partial class GameController
+    {
+        private void LoadOptionalRobustModules()
+        {
+            // In the future, this manifest should be loaded somewhere else and used for more parts of init.
+            // For now, this is fine.
+            var manifest = LoadResourceManifest();
+
+            foreach (var module in manifest.Modules)
+            {
+                switch (module)
+                {
+                    case "Robust.Client.WebView":
+                        LoadRobustWebView();
+                        break;
+                    default:
+                        Logger.Error($"Unknown Robust module: {module}");
+                        return;
+                }
+            }
+        }
+
+        private void LoadRobustWebView()
+        {
+            Logger.Debug("Loading Robust.Client.WebView");
+
+            var assembly = LoadRobustModuleAssembly("Robust.Client.WebView");
+            var attribute = assembly.GetCustomAttribute<WebViewManagerImplAttribute>()!;
+            DebugTools.AssertNotNull(attribute);
+
+            var managerType = attribute.ImplementationType;
+            _webViewHook = (IWebViewManagerHook)Activator.CreateInstance(managerType)!;
+            _webViewHook.Initialize();
+
+            Logger.Debug("Done initializing Robust.Client.WebView");
+        }
+
+        private Assembly LoadRobustModuleAssembly(string assemblyName)
+        {
+            // TODO: Launcher distribution and all that stuff.
+            return Assembly.Load(assemblyName);
+        }
+    }
+}

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;
@@ -16,6 +17,7 @@ using Robust.Client.State;
 using Robust.Client.UserInterface;
 using Robust.Client.Utility;
 using Robust.Client.ViewVariables;
+using Robust.Client.WebViewHook;
 using Robust.LoaderApi;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
@@ -31,6 +33,7 @@ using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
+using YamlDotNet.RepresentationModel;
 
 namespace Robust.Client
 {
@@ -66,6 +69,8 @@ namespace Robust.Client
         [Dependency] private readonly IMidiManager _midiManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
 
+        private IWebViewManagerHook? _webViewHook;
+
         private CommandLineArgs? _commandLineArgs;
 
         // Arguments for loader-load. Not used otherwise.
@@ -86,7 +91,7 @@ namespace Robust.Client
             _clyde.SetWindowTitle(Options.DefaultWindowTitle);
 
             _taskManager.Initialize();
-            _fontManager.SetFontDpi((uint) _configurationManager.GetCVar(CVars.DisplayFontDpi));
+            _fontManager.SetFontDpi((uint)_configurationManager.GetCVar(CVars.DisplayFontDpi));
 
             // Disable load context usage on content start.
             // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
@@ -106,6 +111,9 @@ namespace Robust.Client
 
             IoCManager.Resolve<ISerializationManager>().Initialize();
 
+            // Load optional Robust modules.
+            LoadOptionalRobustModules();
+
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
             _modLoader.BroadcastRunLevel(ModRunLevel.Init);
@@ -139,6 +147,7 @@ namespace Robust.Client
 
             _authManager.LoadFromEnv();
 
+            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
             GC.Collect();
 
             // Setup main loop
@@ -194,6 +203,39 @@ namespace Robust.Client
             return true;
         }
 
+        private ResourceManifestData LoadResourceManifest()
+        {
+            // Parses /manifest.yml for game-specific settings that cannot be exclusively set up by content code.
+            if (!_resourceCache.TryContentFileRead("/manifest.yml", out var stream))
+                return new ResourceManifestData(Array.Empty<string>());
+
+            var yamlStream = new YamlStream();
+            using (stream)
+            {
+                using var streamReader = new StreamReader(stream, EncodingHelpers.UTF8);
+                yamlStream.Load(streamReader);
+            }
+
+            if (yamlStream.Documents.Count != 1 || yamlStream.Documents[0].RootNode is not YamlMappingNode mapping)
+            {
+                throw new InvalidOperationException(
+                    "Expected a single YAML document with root mapping for /manifest.yml");
+            }
+
+            var modules = Array.Empty<string>();
+            if (mapping.TryGetNode("modules", out var modulesMap))
+            {
+                var sequence = (YamlSequenceNode)modulesMap;
+                modules = new string[sequence.Children.Count];
+                for (var i = 0; i < modules.Length; i++)
+                {
+                    modules[i] = sequence[i].AsString();
+                }
+            }
+
+            return new ResourceManifestData(modules);
+        }
+
         internal bool StartupSystemSplash(GameControllerOptions options, Func<ILogHandler>? logHandlerFactory)
         {
             Options = options;
@@ -215,8 +257,10 @@ namespace Robust.Client
                             System.Console.WriteLine($"LogLevel {level} does not exist!");
                             continue;
                         }
+
                         logLevel = result;
                     }
+
                     _logManager.GetSawmill(sawmill).Level = logLevel;
                 }
             }
@@ -255,14 +299,25 @@ 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);
 
             var mountOptions = _commandLineArgs != null
-                ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions) : Options.MountOptions;
+                ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)
+                : Options.MountOptions;
 
-            ProgramShared.DoMounts(_resourceCache, mountOptions, Options.ContentBuildDirectory, Options.AssemblyDirectory,
+            ProgramShared.DoMounts(_resourceCache, mountOptions, Options.ContentBuildDirectory,
+                Options.AssemblyDirectory,
                 Options.LoadContentResources, _loaderArgs != null && !Options.ResourceMountDisabled, ContentStart);
 
             if (_loaderArgs != null)
@@ -383,6 +438,7 @@ namespace Robust.Client
 
         private void Update(FrameEventArgs frameEventArgs)
         {
+            _webViewHook?.Update();
             _clyde.FrameProcess(frameEventArgs);
             _modLoader.BroadcastUpdate(ModUpdateLevel.FramePreEngine, frameEventArgs);
             _stateManager.FrameUpdate(frameEventArgs);
@@ -431,7 +487,7 @@ namespace Robust.Client
             var uh = logManager.GetSawmill("unhandled");
             AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
             {
-                var message = ((Exception) args.ExceptionObject).ToString();
+                var message = ((Exception)args.ExceptionObject).ToString();
                 uh.Log(args.IsTerminating ? LogLevel.Fatal : LogLevel.Error, message);
             };
 
@@ -472,11 +528,17 @@ namespace Robust.Client
 
         internal void Cleanup()
         {
+            _modLoader.Shutdown();
+
+            _webViewHook?.Shutdown();
+
             _networkManager.Shutdown("Client shutting down");
             _midiManager.Shutdown();
             IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Shutdown();
             _clyde.Shutdown();
         }
+
+        private sealed record ResourceManifestData(string[] Modules);
     }
 }

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/ClientEntityManager.cs

@@ -40,7 +40,7 @@ namespace Robust.Client.GameObjects
 
         void IClientEntityManagerInternal.InitializeEntity(IEntity entity)
         {
-            EntityManager.InitializeEntity((Entity)entity);
+            base.InitializeEntity((Entity)entity);
         }
 
         void IClientEntityManagerInternal.StartEntity(IEntity entity)

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,33 @@ 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);
-                }
-            }
+#pragma warning disable 618
+            AnimationCompleted?.Invoke(key);
+#pragma warning restore 618
         }
 
+        [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,14 @@ namespace Robust.Client.GameObjects
             set => _visibleNested = value;
         }
 
-        [DataField("radius")]
-        private float _radius = 5f;
+        /// <summary>
+        ///     Whether this pointlight should cast shadows
+        /// </summary>
+        [DataField("castShadows")]
+        public bool CastShadows = true;
+
         [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 +136,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 +169,7 @@ namespace Robust.Client.GameObjects
         }
     }
 
-    internal sealed class PointLightUpdateEvent : EntityEventArgs
+    public sealed class PointLightUpdateEvent : EntityEventArgs
     {
 
     }

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

@@ -43,15 +43,6 @@ namespace Robust.Client.GameObjects
         [Animatable]
         Color Color { get; set; }
 
-        /// <summary>
-        ///     Controls whether we use RSI directions to rotate, or just get angular rotation applied.
-        ///     If true, all rotation to this sprite component is negated (that is rotation from say the owner being rotated).
-        ///     Rotation transformations on individual layers still apply.
-        ///     If false, all layers get locked to south and rotation is a transformation.
-        /// </summary>
-        [Obsolete("Use NoRotation and/or DirectionOverride")]
-        bool Directional { get; set; }
-
         /// <summary>
         /// All sprite rotation is locked, and will always be drawn upright on
         /// the screen, regardless of world or view orientation.
@@ -228,6 +219,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

@@ -114,23 +114,6 @@ namespace Robust.Client.GameObjects
             set => color = value;
         }
 
-        /// <summary>
-        ///     Controls whether we use RSI directions to rotate, or just get angular rotation applied.
-        ///     If true, all rotation to this sprite component is negated (that is rotation from say the owner being rotated).
-        ///     Rotation transformations on individual layers still apply.
-        ///     If false, all layers get locked to south and rotation is a transformation.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        [Obsolete("Use NoRotation and/or DirectionOverride")]
-        public bool Directional
-        {
-            get => _directional;
-            set => _directional = value;
-        }
-
-        [DataField("directional")]
-        private bool _directional = true;
-
         [ViewVariables]
         internal RenderingTreeComponent? RenderTree { get; set; } = null;
 
@@ -365,7 +348,7 @@ namespace Robust.Client.GameObjects
                     }
                     else
                     {
-                        Logger.ErrorS(LogCategory, "Unable to load RSI '{0}'. Trace:\n{1}", rsiPath);
+                        Logger.ErrorS(LogCategory, "Unable to load RSI '{0}'.", rsiPath);
                     }
                 }
             }
@@ -402,7 +385,6 @@ namespace Robust.Client.GameObjects
         {
             //deep copying things to avoid entanglement
             _baseRsi = other._baseRsi;
-            _directional = other._directional;
             _visible = other._visible;
             _layerMapShared = other._layerMapShared;
             color = other.color;
@@ -564,7 +546,7 @@ namespace Robust.Client.GameObjects
                 Logger.ErrorS(LogCategory, "Unable to load RSI '{0}'. Trace:\n{1}", rsiPath, Environment.StackTrace);
             }
 
-            return AddLayer(stateId, res?.RSI);
+            return AddLayer(stateId, res?.RSI, newIndex);
         }
 
         public int AddLayerState(string stateId, ResourcePath rsiPath, int? newIndex = null)
@@ -1212,13 +1194,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 +1220,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,28 +1228,36 @@ 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)
         {
+            // Reduce the angles to fix math shenanigans
+            worldRotation = worldRotation.Reduced();
+
+            if (worldRotation.Theta < 0)
+                worldRotation = new Angle(worldRotation.Theta + Math.Tau);
+
             var localMatrix = GetLocalMatrix();
 
             foreach (var layer in Layers)
@@ -1279,18 +1268,19 @@ namespace Robust.Client.GameObjects
                 }
 
                 var numDirs = GetLayerDirectionCount(layer);
+                var layerRotation = worldRotation + layer.Rotation;
 
-                CalcModelMatrix(numDirs, worldRotation, worldPosition, out var modelMatrix);
+                CalcModelMatrix(numDirs, eyeRotation, layerRotation, 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, layerRotation, 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)
             {
@@ -1320,7 +1310,7 @@ namespace Robust.Client.GameObjects
         public static Angle CalcRectWorldAngle(Angle worldAngle, int numDirections)
         {
             var theta = worldAngle.Theta;
-            var segSize = (MathF.PI * 2) / (numDirections * 2);
+            var segSize = (Math.PI * 2) / (numDirections * 2);
             var segments = (int)(theta / segSize);
             var odd = segments % 2;
             var result = theta - (segments * segSize) - (odd * segSize);
@@ -1510,6 +1500,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 +1619,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 +1646,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 +1710,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 +1994,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)
@@ -2040,17 +2050,24 @@ namespace Robust.Client.GameObjects
 
         public static IEnumerable<IDirectionalTextureProvider> GetPrototypeTextures(EntityPrototype prototype, IResourceCache resourceCache)
         {
+            return GetPrototypeTextures(prototype, resourceCache, out var _);
+        }
+
+        public static IEnumerable<IDirectionalTextureProvider> GetPrototypeTextures(EntityPrototype prototype, IResourceCache resourceCache, out bool noRot)
+        {
+            var results = new List<IDirectionalTextureProvider>();
+            noRot = false;
             var icon = IconComponent.GetPrototypeIcon(prototype, resourceCache);
             if (icon != null)
             {
-                yield return icon;
-                yield break;
+                results.Add(icon);
+                return results;
             }
 
             if (!prototype.Components.TryGetValue("Sprite", out _))
             {
-                yield return resourceCache.GetFallback<TextureResource>().Texture;
-                yield break;
+                results.Add(resourceCache.GetFallback<TextureResource>().Texture);
+                return results;
             }
 
             var dummy = new DummyIconEntity { Prototype = prototype };
@@ -2069,7 +2086,8 @@ namespace Robust.Client.GameObjects
             var anyTexture = false;
             foreach (var layer in spriteComponent.AllLayers)
             {
-                if (layer.Texture != null) yield return layer.Texture;
+                if (layer.Texture != null)
+                    results.Add(layer.Texture);
                 if (!layer.RsiState.IsValid || !layer.Visible) continue;
 
                 var rsi = layer.Rsi ?? spriteComponent.BaseRSI;
@@ -2077,14 +2095,17 @@ namespace Robust.Client.GameObjects
                     !rsi.TryGetState(layer.RsiState, out var state))
                     continue;
 
-                yield return state;
+                results.Add(state);
                 anyTexture = true;
             }
 
+            noRot = spriteComponent.NoRotation;
+
             dummy.Delete();
 
             if (!anyTexture)
-                yield return resourceCache.GetFallback<TextureResource>().Texture;
+                results.Add(resourceCache.GetFallback<TextureResource>().Texture);
+            return results;
         }
 
         public static IRsiStateLike GetPrototypeIcon(EntityPrototype prototype, IResourceCache resourceCache)
@@ -2107,7 +2128,7 @@ namespace Robust.Client.GameObjects
         #region DummyIconEntity
         private class DummyIconEntity : IEntity
         {
-            public GameTick LastModifiedTick { get; } = GameTick.Zero;
+            GameTick IEntity.LastModifiedTick { get; set; } = GameTick.Zero;
             public IEntityManager EntityManager { get; } = null!;
             public string Name { get; set; } = string.Empty;
             public EntityUid Uid { get; } = EntityUid.Invalid;
@@ -2125,7 +2146,7 @@ namespace Robust.Client.GameObjects
             }
 
             public ITransformComponent Transform { get; } = null!;
-            public IMetaDataComponent MetaData { get; } = null!;
+            public MetaDataComponent MetaData { get; } = null!;
 
             private Dictionary<Type, IComponent> _components = new();
             private EntityLifeStage _lifeStage;

Robust.Client/GameObjects/Components/RenderingTreeComponent.cs

@@ -15,29 +15,49 @@ namespace Robust.Client.GameObjects
         private static Box2 SpriteAabbFunc(in SpriteComponent value)
         {
             var worldPos = value.Owner.Transform.WorldPosition;
-            return new Box2(worldPos, worldPos);
+            var worldRot = value.Owner.Transform.WorldRotation;
+            var bounds = new Box2Rotated(value.CalculateBoundingBox(worldPos), worldRot, worldPos);
+            var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
+
+            var localAABB = tree?.Owner.Transform.InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
+
+            return localAABB;
         }
 
         private static Box2 LightAabbFunc(in PointLightComponent value)
         {
             var worldPos = value.Owner.Transform.WorldPosition;
-
+            var tree = RenderingTreeSystem.GetRenderTree(value.Owner);
             var boxSize = value.Radius * 2;
-            return Box2.CenteredAround(worldPos, (boxSize, boxSize));
+
+            var localPos = tree?.Owner.Transform.InvWorldMatrix.Transform(worldPos) ?? worldPos;
+
+            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);
 
-            return new Box2(worldPos.Value, worldPos.Value);
+            var localAABB = tree?.Owner.Transform.InvWorldMatrix.TransformBox(bounds) ?? bounds.CalcBoundingBox();
+
+            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;
-            return Box2.CenteredAround(worldPos.Value, (boxSize, boxSize));
+
+            var localPos = tree?.Owner.Transform.InvWorldMatrix.Transform(worldPos.Value) ?? worldPos.Value;
+
+            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,23 +10,22 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
+using Robust.Shared.Maths;
 using Robust.Shared.Physics;
-using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Player;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
     [UsedImplicitly]
-    public class AudioSystem : EntitySystem, IAudioSystem
+    public class AudioSystem : SharedAudioSystem, IAudioSystem
     {
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [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 SharedPhysicsSystem _broadPhaseSystem = default!;
 
         private readonly List<PlayingStream> _playingClydeStreams = new();
 
@@ -38,7 +39,6 @@ namespace Robust.Client.GameObjects
             SubscribeNetworkEvent<StopAudioMessageClient>(StopAudioMessageHandler);
 
             SubscribeLocalEvent<SoundSystem.QueryAudioSystem>((ev => ev.Audio = this));
-            _broadPhaseSystem = Get<SharedBroadPhaseSystem>();
         }
 
         private void StopAudioMessageHandler(StopAudioMessageClient ev)
@@ -64,7 +64,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            var stream = (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.AudioParams);
+            var stream = (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.FallbackCoordinates, ev.AudioParams);
             if (stream != null)
             {
                 stream.NetIdentifier = ev.Identifier;
@@ -83,8 +83,8 @@ namespace Robust.Client.GameObjects
         private void PlayAudioEntityHandler(PlayAudioEntityMessage ev)
         {
             var stream = EntityManager.TryGetEntity(ev.EntityUid, out var entity) ?
-                (PlayingStream?) Play(ev.FileName, entity, ev.AudioParams)
-                : (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.AudioParams);
+                (PlayingStream?) Play(ev.FileName, entity, ev.FallbackCoordinates, ev.AudioParams)
+                : (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.FallbackCoordinates, ev.AudioParams);
 
             if (stream != null)
             {
@@ -98,6 +98,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)
@@ -132,6 +134,10 @@ namespace Robust.Client.GameObjects
                         mapPos = stream.TrackingEntity.Transform.MapPosition;
                     }
 
+                    // TODO Remove when coordinates can't be NaN
+                    if (mapPos == null || !float.IsFinite(mapPos.Value.X) || !float.IsFinite(mapPos.Value.Y))
+                        mapPos = stream.TrackingFallbackCoordinates?.ToMap(_entityManager);
+
                     if (mapPos != null)
                     {
                         var pos = mapPos.Value;
@@ -141,7 +147,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,21 +161,60 @@ 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)
                         {
                             stream.Source.SetVelocity(stream.TrackingEntity.GlobalLinearVelocity());
                         }
-
                     }
                 }
             }
@@ -219,6 +264,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);
@@ -230,12 +279,14 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
+        /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when entity is invalid.</param>
         /// <param name="audioParams"></param>
-        private IPlayingAudioStream? Play(string filename, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, IEntity entity, EntityCoordinates fallbackCoordinates,
+            AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
-                return Play(audio, entity, audioParams);
+                return Play(audio, entity, fallbackCoordinates, audioParams);
             }
 
             Logger.Error($"Server tried to play audio file {filename} which does not exist.");
@@ -247,15 +298,15 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
+        /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when entity is invalid.</param>
         /// <param name="audioParams"></param>
-        private IPlayingAudioStream? Play(AudioStream stream, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(AudioStream stream, IEntity entity, EntityCoordinates fallbackCoordinates,
+            AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
             if (!source.SetPosition(entity.Transform.WorldPosition))
             {
-                source.Dispose();
-                Logger.Warning($"Can't play positional audio \"{stream.Name}\", can't set position.");
-                return null;
+                return Play(stream, fallbackCoordinates, fallbackCoordinates, audioParams);
             }
 
             ApplyAudioParams(audioParams, source);
@@ -265,6 +316,11 @@ namespace Robust.Client.GameObjects
             {
                 Source = source,
                 TrackingEntity = entity,
+                TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null,
+                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);
@@ -276,12 +332,14 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
+        /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when coordinates are invalid.</param>
         /// <param name="audioParams"></param>
-        private IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, EntityCoordinates fallbackCoordinates,
+            AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
-                return Play(audio, coordinates, audioParams);
+                return Play(audio, coordinates, fallbackCoordinates, audioParams);
             }
 
             Logger.Error($"Server tried to play audio file {filename} which does not exist.");
@@ -293,18 +351,24 @@ namespace Robust.Client.GameObjects
         /// </summary>
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
+        /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when coordinates are invalid.</param>
         /// <param name="audioParams"></param>
         private IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
-            AudioParams? audioParams = null)
+            EntityCoordinates fallbackCoordinates, AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
-            if (!source.SetPosition(coordinates.ToMapPos(EntityManager)))
+            if (!source.SetPosition(fallbackCoordinates.Position))
             {
                 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;
             }
 
+            if (!coordinates.IsValid(_entityManager))
+            {
+                coordinates = fallbackCoordinates;
+            }
+
             ApplyAudioParams(audioParams, source);
 
             source.StartPlaying();
@@ -312,6 +376,11 @@ namespace Robust.Client.GameObjects
             {
                 Source = source,
                 TrackingCoordinates = coordinates,
+                TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null,
+                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 +396,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;
         }
@@ -337,9 +409,31 @@ namespace Robust.Client.GameObjects
             public IClydeAudioSource Source = default!;
             public IEntity TrackingEntity = default!;
             public EntityCoordinates? TrackingCoordinates;
+            public EntityCoordinates? TrackingFallbackCoordinates;
             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();
@@ -361,13 +455,19 @@ namespace Robust.Client.GameObjects
         /// <inheritdoc />
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, IEntity entity, AudioParams? audioParams = null)
         {
-            return Play(filename, entity, audioParams);
+            return Play(filename, entity, GetFallbackCoordinates(entity.Transform.MapPosition), audioParams);
+        }
+
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityUid uid, AudioParams? audioParams = null)
+        {
+            return EntityManager.TryGetEntity(uid, out var entity)
+                ? Play(filename, entity, GetFallbackCoordinates(entity.Transform.MapPosition), audioParams) : null;
         }
 
         /// <inheritdoc />
         public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {
-            return Play(filename, coordinates, audioParams);
+            return Play(filename, coordinates, GetFallbackCoordinates(coordinates.ToMap(_entityManager)), audioParams);
         }
     }
 }

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,11 +2,14 @@
 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;
+using Robust.Shared.Timing;
 
 #nullable enable
 
@@ -20,12 +23,14 @@ 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 ITransformComponent? _lastParent;
+
+        private float _accumulator;
 
         /// <inheritdoc />
         public override void Initialize()
@@ -55,39 +60,42 @@ namespace Robust.Client.GameObjects
         public override void FrameUpdate(float frameTime)
         {
             var currentEye = _eyeManager.CurrentEye;
-            var inputSystem = EntitySystemManager.GetEntitySystem<InputSystem>();
 
-            var direction = 0;
-            if (inputSystem.CmdStates[EngineKeyFunctions.CameraRotateRight] == BoundKeyState.Down)
-            {
-                direction += 1;
-            }
+            // TODO: Content should have its own way of handling this. We should have a default behavior that they can overwrite.
 
-            if (inputSystem.CmdStates[EngineKeyFunctions.CameraRotateLeft] == BoundKeyState.Down)
-            {
-                direction -= 1;
-            }
+            var playerTransform = _playerManager.LocalPlayer?.ControlledEntity?.Transform;
 
-            // apply camera rotation
-            if(direction != 0)
+            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 (parent != _lastParent)
             {
-                currentEye.Rotation += CameraRotateSpeed * frameTime * direction;
-                currentEye.Rotation = currentEye.Rotation.Reduced();
+                _accumulator += frameTime;
+
+                if (_accumulator >= 0.3f)
+                {
+                    _accumulator = 0f;
+                    _lastParent = parent;
+                }
             }
             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();
-                }
+                _lastParent = parent;
             }
 
-            foreach (var eyeComponent in EntityManager.ComponentManager.EntityQuery<EyeComponent>(true))
+            if (_lastParent == parent)
+            {
+                // TODO: Detect parent change and start lerping
+                var parentRotation = parent.WorldRotation;
+                currentEye.Rotation = -parentRotation;
+            }
+
+            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
+    {
+
+    }
+}