Version: 265.0.3

Also, only read assemblies once from disk

(cherry picked from commit 443a8dfca65be7d60c4bd46181b4c749b4756114)

.github/workflows/build-all-configurations.yml

@@ -0,0 +1,34 @@
+name: Build All Configurations
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        targetOS: [Windows, Linux, MacOS]
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4.2.2
+        with:
+          submodules: true
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4.1.0
+        with:
+          dotnet-version: 9.0.x
+
+      - name: Install dependencies
+        run: dotnet restore
+      - name: Build Debug
+        run: dotnet build --no-restore --configuration Debug /p:WarningsAsErrors=nullable /p:TargetOS=${{ matrix.targetOS }}
+      - name: Build Tools
+        run: dotnet build --no-restore --configuration Tools /p:WarningsAsErrors=nullable /p:TargetOS=${{ matrix.targetOS }}
+      - name: Build Release
+        run: dotnet build --no-restore --configuration Release /p:WarningsAsErrors=nullable /p:TargetOS=${{ matrix.targetOS }}

Directory.Packages.props

@@ -57,7 +57,7 @@
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.7" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
-    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
     <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
     <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.26100.1" />

MSBuild/Robust.Engine.Version.props

@@ -1,4 +1,4 @@
 <Project>
 
-    <!-- This file automatically reset by Tools/version.py -->
+    <!-- This file automatically reset by Tools/version.py -->
 

RELEASE-NOTES.md

@@ -54,16 +54,395 @@ END TEMPLATE-->
 *None yet*
 
 
+## 265.0.3
+
+
+## 265.0.2
+
+
+## 265.0.1
+
+
+## 265.0.0
+
+### Breaking changes
+
+* More members in `IntegrationInstance` now enforce that the instance is idle before accessing it.
+* `Prototype.ValidateDirectory` now requires that prototype IDs have no spaces or periods in them.
+* `IPrototypeManager.TryIndex` no longer logs errors unless using the overload with an optional parameter. Use `Resolve()` instead if error logging is desired.
+* `LocalizedCommands` now has a `Loc` property that refers to `LocalizationManager`. This can cause compile failures if you have static methods in child types that referenced static `Loc`.
+* `[AutoGenerateComponentState]` now works on parent members for inherited classes. This can cause compile failures in certain formerly silently broken cases with overriden properties.
+* `Vector3`, `Vector4`, `Quaternion`, and `Matrix4` have been removed from `Robust.Shared.Maths`. Use the `System.Numerics` types instead.
+
+### New features
+
+* `RobustClientPackaging.WriteClientResources()` and `RobustServerPackaging.WriteServerResources()` now have an overload taking in a set of things to ignore in the content resources directory.
+* Added `IPrototypeManager.Resolve()`, which logs an error if the resolved prototype does not exist. This is effectively the previous (but not original) default behavior of `IPrototypeManager.TryIndex`.
+* There's now a ViewVariables property editor for tuples.
+* Added `ColorNaming` helper functions for getting textual descriptions of color values.
+* Added Oklab/Oklch conversion functions for `Color`.
+* `ColorSelectorSliders` now displays textual descriptions of color values.
+* Added `TimeSpanExt.TryTimeSpan` to parse `TimeSpan`s with the `1.5h` format available in YAML.
+* Added `ITestContextLike` and related classes to allow controlling pooled integration instances better.
+* `EntProtoId` VV prop editors now don't allow setting invalid prototype IDs, inline with `ProtoId<T>`.
+* Custom VV controls can now be registered using `IViewVariableControlFactory`.
+* The entity spawn window now shows all placement modes registered with `IPlacementManager`.
+* Added `VectorHelpers.InterpolateCubic` for `System.Numerics` `Vector3` and `Vector4`.
+* Added deconstruct helpers for `System.Numerics` `Vector3` and `Vector4`.
+
+### Bugfixes
+
+* Pooled integration instances returned by `RobustIntegrationTest` are now treated as non-idle, for consistency with non-pooled startups.
+* `SharedAudioSystem.SetState` no longer calls `DirtyField` on `PlaybackPosition`, an unnetworked field.
+* Fix loading texture files from the root directory.
+* Fix integration test pooling leaking non-reusable instances.
+* Fix multiple bugs where VV displayed the wrong property editor for remote values.
+* VV displays group headings again in member list.
+* Fix a stack overflow that could occur with `ColorSelectorSliders`.
+* `MidiRenderer` now properly handles `NoteOn` events with 0 velocity (which should actually be treated as `NoteOff` events).
+
+### Other
+
+* The debug assert for `RobustRandom.Next(TimeSpan, TimeSpan)` now allows for the two arguments to be equal.
+* The configuration system will now report an error instead of warning if it fails to load the config file.
+* Members in `IntegrationInstance` that enforce the instance is idle now always allow access from the instance's thread (e.g. from a callback).
+* `IPrototypeManager` methods now have `[ForbidLiteral]` where appropriate.
+* Performance improvements to physics system.
+* `[ValidatePrototypeIdAttribute]` has been marked as obsolete.
+* `ParallelManager` no longer cuts out exception information for caught job exceptions.
+* Improved logging for PVS uninitialized/deleted entity errors.
+
+### Internal
+
+* General code & warning cleanup.
+* Fix `VisibilityTest` being unreliable.
+* `ColorSelectorSliders` has been internally refactored.
+* Added CI workflows that test all RT build configurations.
+
+## 264.0.0
+
+### Breaking changes
+
+* `IPrototypeManager.Index(Type kind, string id)` now throws `UnknownPrototypeException` instead of `KeyNotFoundException`, for consistency with `IPrototypeManager.Index<T>`.
+
+### New features
+
+* Types can now implement the new interface `IRobustCloneable<T>` to be cloned by the component state source generator.
+* Added extra Roslyn Analyzers to detect some misuse of prototypes:
+  * Network serializing prototypes (tagging them with `[Serializable, NetSerializable]`).
+  * Constructing new instances of prototypes directly.
+* Add `PrototypeManagerExt.Index` helper function that takes a nullable `ProtoId<T>`, returning null if the ID is null.
+* Added an `AlwaysActive` field to `WebViewControl` to make a browser window active even when not in the UI tree.
+* Made some common dependencies accessible through `IPlacementManager`.
+* Added a new `GENITIVE()` localization helper function, which is useful for certain languages.
+
+### Bugfixes
+
+* Sprite scale is now correctly applied to sprite boundaries in `SpriteSystem.GetLocalBounds`.
+* Fixed documentation for `IPrototypeManager.Index<T>` stating that `KeyNotFoundException` gets thrown, when in actuality `UnknownPrototypeException` gets thrown.
+
+### Other
+
+* More tiny optimizations to `DataDefinitionAnalyzer`.
+* NetSerializer has been updated. On debug, it will now report *where* a type that can't be serialized is referenced from.
+
+### Internal
+
+* Minor internal code cleanup.
+
+
+## 263.0.0
+
+### Breaking changes
+
+* Fully removed some non-`Entity<T>` container methods.
+
+### New features
+
+* `IMidiRenderer.LoadSoundfont` has been split into `LoadSoundfontResource` and `LoadSoundfontUser`, the original now being deprecated.
+* Client command execution now properly catches errors instead of letting them bubble up through the input stack.
+* Added `CompletionHelper.PrototypeIdsLimited` API to allow commands to autocomplete entity prototype IDs.
+* Added `spawn:in` Toolshed command.
+* Added `MapLoaderSystem.TryLoadGeneric` overload to load from a `Stream`.
+* Added `OutputPanel.GetMessage()` and `OutputPanel.SetMessage()` to allow replacing individual messages.
+
+### Bugfixes
+
+* Fixed debug asserts when using MIDI on Windows.
+* Fixed an error getting logged on startup on macOS related to window icons.
+* `CC-BY-NC-ND-4.0` is now a valid license for the RGA validator.
+* Fixed `TabContainer.CurrentTab` clamping against the wrong value.
+* Fix culture-based parsing in `TimespanSerializer`.
+* Fixed grid rendering blowing up on tile IDs that aren't registered.
+* Fixed debug assert when loading MIDI soundfonts on Windows.
+* Make `ColorSelectorSliders` properly update the dropdown when changing `SelectorType`.
+* Fixed `tpto` allowing teleports to oneself, thereby causing them to be deleted.
+* Fix OpenAL extensions being requested incorrectly, causing an error on macOS.
+* Fixed horizontal measuring of markup controls in rich text.
+
+### Other
+
+* Improved logging for some audio entity errors.
+* Avoided more server stutters when using `csci`.
+* Improved physics performance.
+* Made various localization functions like `GENDER()` not throw if passed a string instead of an `EntityUid`.
+* The generic clause on `EntitySystem.AddComp<T>` has been changed to `IComponent` (from `Component`) for consistency with `IEntityManager.AddComponent<T>`.
+* `DataDefinitionAnalyzer` has been optimized somewhat.
+* Improved assert logging error message when static data fields are encountered.
+
+### Internal
+
+* Warning cleanup.
+* Added more tests for `DataDefinitionAnalyzer`.
+* Consistently use `EntitySystem` proxy methods in engine.
+
+
+## 262.0.0
+
+### Breaking changes
+
+* Toolshed commands will now validate that each non-generic command argument is parseable (i.e., has a corresponding type parser). This check can be disabled by explicitly marking the argument as unparseable via `CommandArgumentAttribute.Unparseable`.
+
+### New features
+
+* `ToolshedManager.TryParse` now also supports nullable value types.
+* Add an ignoredComponents arg to IsDefault.
+
+### Bugfixes
+
+* Fix `SpriteComponent.Layer.Visible` setter not marking a sprite's bounding box as dirty.
+* The audio params in the passed SoundSpecifier for PlayStatic(SoundSpecifier, Filter, ...) will now be used as a default like other PlayStatic overrides.
+* Fix windows not saving their positions correctly when their x position is <= 0.
+* Fix transform state handling overriding PVS detachment.
+
+
+## 261.2.0
+
+### New features
+
+* Implement IEquatable for ResolvedPathSpecifier & ResolvedCollectionSpecifier.
+* Add NearestChunkEnumerator.
+
+### Bugfixes
+
+* Fix static entities not having the center of mass updated.
+* Fix TryQueueDelete.
+* Fix tpto potentially parenting grids to non-map entities.
+
+### Other
+
+* TileChangedEvent is now raised once in clientside grid state handling rather than per tile.
+* Removed ITileDefinition.ID as it was redundant.
+* Change the lifestage checks on predicted entity deletion to check for terminating.
+
+### Internal
+
+* Update some `GetComponentName<T>` uses to generic.
+
+
+## 261.1.0
+
+### New features
+
+* Automatically create logger sawmills for `UIController`s similar to `EntitySystem`s.
+
+### Bugfixes
+
+* Fix physics forces not auto-clearing / respecting the cvar.
+
+### Internal
+
+* Cleanup more compiler warnings in unit tests.
+
+
+## 261.0.0
+
+### Breaking changes
+
+* Remove unused TryGetContainingContainer override.
+* Stop recursive FrameUpdates for controls that are not visible.
+* Initialize LocMgr earlier in the callstack for GameController.
+* Fix FastNoiseLise fractal bounding and remove its DataField property as it should be derived on other properties updating.
+* Make RaiseMoveEvent internal.
+* MovedGridsComponent and PhysicsMapComponent are now purged and properties on `SharedPhysicsSystem`. Additionally the TransformComponent for Awake entities is stored alongside the PhysicsComponent for them.
+* TransformComponent is now stored on physics contacts.
+* Gravity2DComponent and Gravity2DController were moved to SharedPhysicsSystem.
+
+### New features
+
+* `IFileDialogManager` now allows specifying `FileAccess` and `FileShare` modes.
+* Add Intersects and Enlarged to Box2i in line with Box2.
+* Make `KeyFrame`s on `AnimationTrackProperty` public settable.
+* Add the spawned entities to a returned array from `SpawnEntitiesAttachedTo`.
+
+### Bugfixes
+
+* Fixed SDL3 file dialog implementation having a memory leak and not opening files read-write.
+* Fix GetMapLinearVelocity.
+
+### Other
+
+* `uploadfile` and `loadprototype` commands now only open files with read access.
+* Optimize `ToMapCoordinates`.
+
+### Internal
+
+* Cleanup on internals of `IFileDialogManager`, removing duplicate code.
+* Fix Contacts not correctly being marked as `Touching` while contact is ongoing.
+
+
+## 260.2.0
+
+### New features
+
+* Add `StringBuilder.Insert(int, string)` to sandbox.
+* Add the WorldNormal to the StartCollideEvent.
+
+
+## 260.1.0
+
+### New features
+
+* `ComponentFactory` is now exposed to `EntitySystem` as `Factory`
+
+### Other
+
+* Cleanup warnings in PLacementManager
+* Cleanup warnings in Clide.Sprite
+
+## 260.0.0
+
+### Breaking changes
+
+* Fix / change `StartCollideEvent.WorldPoint` to return all points for the collision which may be up to 2 instead of 1.
+
+### New features
+
+* Add SpriteSystem dependency to VisualizerSystem.
+* Add Vertical property to progress bars
+* Add some `EntProtoId` overloads for group entity spawn methods.
+
+
+## 259.0.0
+
+### Breaking changes
+
+* TileChangedEvent now has an array of tile changed entries rather than raising an individual event for every single tile changed.
+
+### Other
+
+* `Entity<T>` methods were marked as `readonly` as appropriate.
+
+
+## 258.0.1
+
+### Bugfixes
+
+* Fix static physics bodies not generating contacts if they spawn onto sleeping bodies.
+
+
+## 258.0.0
+
+### Breaking changes
+
+* `IMarkupTag` and related methods in `MarkupTagManager` have been obsoleted and should be replaced with the new `IMarkupTagHandler` interface. Various engine tags (e.g., `BoldTag`, `ColorTag`, etc) no longer implement the old interface.
+
+### New features
+
+* Add IsValidPath to ResPath and make some minor performance improvements.
+
+### Bugfixes
+
+* OutputPanel and RichTextLabel now remove controls associated with rich text tags when the text is updated.
+* Fix `SpriteComponent.Visible` datafield not being read from yaml.
+* Fix container state handling not forcing inserts.
+
+### Other
+
+* `SpriteSystem.LayerMapReserve()` no longer throws an exception if the specified layer already exists. This makes it behave like the obsoleted `SpriteComponent.LayerMapReserveBlank()`.
+
+
+## 257.0.2
+
+### Bugfixes
+
+* Fix unshaded sprite layers not rendering correctly.
+
+
+## 257.0.1
+
+### Bugfixes
+
+* Fix sprite layer bounding box calculations. This was causing various sprite rendering & render-tree lookup issues.
+
+
+## 257.0.0
+
+### Breaking changes
+
+* The client will now automatically pause any entities that leave their PVS range.
+* Contacts for terminating entities no longer raise wake events.
+
+### New features
+
+* Added `IPrototypeManager.IsIgnored()` for checking whether a given prototype kind has been marked as ignored via `RegisterIgnore()`.
+* Added `PoolManager` & `TestPair` classes to `Robust.UnitTesting`. These classes make it easier to create & use pooled server/client instance pairs in integration tests.
+* Catch NotYamlSerializable DataFields with an analyzer.
+* Optimized RSI preloading and texture atlas creation.
+
+### Bugfixes
+
+* Fix clients unintentionally un-pausing paused entities that re-enter pvs range
+
+### Other
+
+* The yaml prototype id serialiser now provides better feedback when trying to validate an id for a prototype kind that has been ignored via `IPrototypeManager.RegisterIgnore()`
+* Several SpriteComponent methods have been marked as obsolete, and should be replaced with new methods in SpriteSystem.
+* Rotation events no longer check for grid traversal.
+
+
+## 256.0.0
+
+### Breaking changes
+
+* `ITypeReaderWriter<TType, TNode>` has been removed due to being unused. Implement `ITypeSerializer<TType, TNode>` instead
+* Moved AsNullable extension methods to the Entity struct.
+
+### New features
+
+* Add DevWindow tab to show all loaded textures.
+* Add Vector2i / bitmask converfsion helpers.
+* Allow texture preload to be skipped for some textures.
+* Check audio file signatures instead of extensions.
+* Add CancellationTokenRegistration to sandbox.
+* Add the ability to serialize TimeSpan from text.
+* Add support for rotated / mirrored tiles.
+
+### Bugfixes
+
+* Fix yaml hot reloading.
+* Fix a linear dictionary lookup in PlacementManager.
+
+### Other
+
+* Make ItemList not run deselection callback on all items if they aren't selected.
+* Cleanup warnings for CS0649 & CS0414.
+
+### Internal
+
+* Move PointLight component states to shared.
+
+
 ## 255.1.0
 
 ### New features
 
-* The client localisation manager now supports hot-reloading ftl files. 
+* The client localisation manager now supports hot-reloading ftl files.
 * TransformSystem can now raise `GridUidChangedEvent` and `MapUidChangedEvent` when a entity's grid or map changes. This event is only raised if the `ExtraTransformEvents` metadata flag is enabled.
 
 ### Bugfixes
 
-* Fixed a server crash due to a `NullReferenceException` in PVS system when a player's local entity is also one of their view subscriptions.  
+* Fixed a server crash due to a `NullReferenceException` in PVS system when a player's local entity is also one of their view subscriptions.
 * Fix CompileRobustXamlTask for benchmarks.
 * .ftl files will now hot reload.
 * Fix placementmanager sometimes not clearing.

Resources/Locale/en-US/_engine_lib.ftl

@@ -21,7 +21,8 @@ zzzz-object-pronoun = { GENDER($ent) ->
    }
 
 # Used internally by the DAT-OBJ() function.
-# Not used in en-US. Created for supporting other languages.
+# Not used in en-US. Created to support other languages.
+# (e.g., "to him," "for her")
 zzzz-dat-object = { GENDER($ent) ->
     [male] him
     [female] her
@@ -29,6 +30,16 @@ zzzz-dat-object = { GENDER($ent) ->
    *[neuter] it
    }
 
+# Used internally by the GENITIVE() function.
+# Not used in en-US. Created to support other languages.
+# e.g., "у него" (Russian), "seines Vaters" (German).
+zzzz-genitive = { GENDER($ent) ->
+    [male] his
+    [female] her
+    [epicene] their
+   *[neuter] its
+   }
+
 # Used internally by the POSS-PRONOUN() function.
 zzzz-possessive-pronoun = { GENDER($ent) ->
     [male] his

Resources/Locale/en-US/color-naming.ftl

@@ -0,0 +1,32 @@
+color-hue-chroma-lightness = {$lightness} {$chroma} {$hue}
+color-hue-chroma = {$chroma} {$hue}
+color-hue-lightness = {$lightness} {$hue}
+color-very-dark = very dark
+color-dark = dark
+color-light = light
+color-very-light = very light
+color-mixed-hue = {$a} {$b}
+color-pale = pale
+color-gray-adjective = gray
+color-strong = strong
+color-pink = pink
+color-red = red
+color-orange = orange
+color-yellow = yellow
+color-green = green
+color-cyan = cyan
+color-blue = blue
+color-purple = purple
+color-brown = brown
+color-white = white
+color-gray = gray
+color-black = black
+
+color-pink-color-red = pinkish red
+color-red-color-orange = reddish orange
+color-orange-color-yellow = orangeish yellow
+color-yellow-color-green = yellowish green
+color-green-color-cyan = greenish cyan
+color-cyan-color-blue = cyanish blue
+color-blue-color-purple = blueish purple
+color-purple-color-pink = purpleish pink

Resources/Locale/en-US/custom-controls.ftl

@@ -9,6 +9,7 @@ entity-spawn-window-override-menu-tooltip = Override placement
 ## TileSpawnWindow
 
 tile-spawn-window-title = Place Tiles
+tile-spawn-window-mirror-button-text = Mirror Tiles
 
 ## Console
 

Resources/Locale/en-US/dev-window.ftl

@@ -0,0 +1,10 @@
+## "Textures" dev window tab
+
+dev-window-tab-textures-title = Textures
+dev-window-tab-textures-reload = Reload
+dev-window-tab-textures-filter = Filter
+dev-window-tab-textures-summary = Total (est): { $bytes }
+dev-window-tab-textures-info = Width: { $width } Height: { $height }
+    PixelType: { $pixelType } sRGB: { $srgb }
+    Name: { $name }
+    Est. memory usage: { $bytes }

Resources/Locale/en-US/toolshed-commands.ftl

@@ -195,6 +195,8 @@ command-description-spawn-at =
     Spawns an entity at the given coordinates.
 command-description-spawn-on =
     Spawns an entity on the given entity, at it's coordinates.
+command-description-spawn-in =
+    Spawns an entity in the given container on the given entity, dropping it at its coordinates if it doesn't fit
 command-description-spawn-attached =
     Spawns an entity attached to the given entity, at (0 0) relative to it.
 command-description-mappos =

Robust.Analyzers.Tests/DataDefinitionAnalyzerTest.cs

@@ -21,47 +21,53 @@ public sealed class DataDefinitionAnalyzerTest
             },
         };
 
+        test.TestState.Sources.Add(("TestTypeDefs.cs", TestTypeDefs));
+
         // ExpectedDiagnostics cannot be set, so we need to AddRange here...
         test.TestState.ExpectedDiagnostics.AddRange(expected);
 
         return test.RunAsync();
     }
 
+    private const string TestTypeDefs = """
+        using System;
+
+        namespace Robust.Shared.ViewVariables
+        {
+            public sealed class ViewVariablesAttribute : Attribute
+            {
+                public readonly VVAccess Access = VVAccess.ReadOnly;
+
+                public ViewVariablesAttribute() { }
+
+                public ViewVariablesAttribute(VVAccess access)
+                {
+                    Access = access;
+                }
+            }
+            public enum VVAccess : byte
+            {
+                ReadOnly = 0,
+                ReadWrite = 1,
+            }
+        }
+
+        namespace Robust.Shared.Serialization.Manager.Attributes
+        {
+            public class DataFieldBaseAttribute : Attribute;
+            public class DataFieldAttribute(string? tag = null) : DataFieldBaseAttribute;
+            public sealed class DataDefinitionAttribute : Attribute;
+            public sealed class NotYamlSerializableAttribute : Attribute;
+        }
+    """;
+
     [Test]
-    public async Task Test()
+    public async Task NoVVReadOnlyTest()
     {
         const string code = """
-            using System;
             using Robust.Shared.ViewVariables;
             using Robust.Shared.Serialization.Manager.Attributes;
 
-            namespace Robust.Shared.ViewVariables
-            {
-                public sealed class ViewVariablesAttribute : Attribute
-                {
-                    public readonly VVAccess Access = VVAccess.ReadOnly;
-
-                    public ViewVariablesAttribute() { }
-
-                    public ViewVariablesAttribute(VVAccess access)
-                    {
-                        Access = access;
-                    }
-                }
-                public enum VVAccess : byte
-                {
-                    ReadOnly = 0,
-                    ReadWrite = 1,
-                }
-            }
-
-            namespace Robust.Shared.Serialization.Manager.Attributes
-            {
-                public class DataFieldBaseAttribute : Attribute;
-                public class DataFieldAttribute : DataFieldBaseAttribute;
-                public sealed class DataDefinitionAttribute : Attribute;
-            }
-
             [DataDefinition]
             public sealed partial class Foo
             {
@@ -83,8 +89,8 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /0/Test0.cs(35,17): info RA0028: Data field Bad in data definition Foo has ViewVariables attribute with ReadWrite access, which is redundant
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldNoVVReadWriteRule).WithSpan(35, 17, 35, 50).WithArguments("Bad", "Foo")
+            // /0/Test0.cs(7,17): info RA0028: Data field Bad in data definition Foo has ViewVariables attribute with ReadWrite access, which is redundant
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldNoVVReadWriteRule).WithSpan(7, 17, 7, 50).WithArguments("Bad", "Foo")
         );
     }
 
@@ -92,16 +98,8 @@ public sealed class DataDefinitionAnalyzerTest
     public async Task ReadOnlyFieldTest()
     {
         const string code = """
-            using System;
             using Robust.Shared.Serialization.Manager.Attributes;
 
-            namespace Robust.Shared.Serialization.Manager.Attributes
-            {
-                public class DataFieldBaseAttribute : Attribute;
-                public class DataFieldAttribute : DataFieldBaseAttribute;
-                public sealed class DataDefinitionAttribute : Attribute;
-            }
-
             [DataDefinition]
             public sealed partial class Foo
             {
@@ -114,8 +112,63 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /0/Test0.cs(15,12): error RA0019: Data field Bad in data definition Foo is readonly
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldWritableRule).WithSpan(15, 12, 15, 20).WithArguments("Bad", "Foo")
+            // /0/Test0.cs(7,12): error RA0019: Data field Bad in data definition Foo is readonly
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldWritableRule).WithSpan(7, 12, 7, 20).WithArguments("Bad", "Foo")
+        );
+    }
+
+    [Test]
+    public async Task PartialDataDefinitionTest()
+    {
+        const string code = """
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            [DataDefinition]
+            public sealed class Foo { }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(4,15): error RA0017: Type Foo is a DataDefinition but is not partial
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataDefinitionPartialRule).WithSpan(4, 15, 4, 20).WithArguments("Foo")
+        );
+    }
+
+    [Test]
+    public async Task NestedPartialDataDefinitionTest()
+    {
+        const string code = """
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            public sealed class Foo
+            {
+                [DataDefinition]
+                public sealed partial class Nested { }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(3,15): error RA0018: Type Foo contains nested data definition Nested but is not partial
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.NestedDataDefinitionPartialRule).WithSpan(3, 15, 3, 20).WithArguments("Foo", "Nested")
+        );
+    }
+
+    [Test]
+    public async Task RedundantDataFieldTagTest()
+    {
+        const string code = """
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField("someValue")]
+                public int SomeValue;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(6,6): info RA0027: Data field SomeValue in data definition Foo has an explicitly set tag that matches autogenerated tag
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldRedundantTagRule).WithSpan(6, 6, 6, 28).WithArguments("SomeValue", "Foo")
         );
     }
 
@@ -123,16 +176,8 @@ public sealed class DataDefinitionAnalyzerTest
     public async Task ReadOnlyPropertyTest()
     {
         const string code = """
-            using System;
             using Robust.Shared.Serialization.Manager.Attributes;
 
-            namespace Robust.Shared.Serialization.Manager.Attributes
-            {
-                public class DataFieldBaseAttribute : Attribute;
-                public class DataFieldAttribute : DataFieldBaseAttribute;
-                public sealed class DataDefinitionAttribute : Attribute;
-            }
-
             [DataDefinition]
             public sealed partial class Foo
             {
@@ -145,8 +190,40 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /0/Test0.cs(15,20): error RA0020: Data field property Bad in data definition Foo does not have a setter
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldPropertyWritableRule).WithSpan(15, 20, 15, 28).WithArguments("Bad", "Foo")
+            // /0/Test0.cs(7,20): error RA0020: Data field property Bad in data definition Foo does not have a setter
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldPropertyWritableRule).WithSpan(7, 20, 7, 28).WithArguments("Bad", "Foo")
+        );
+    }
+
+    [Test]
+    public async Task NotYamlSerializableTest()
+    {
+        const string code = """
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            [NotYamlSerializable]
+            public sealed class NotSerializableClass { }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField]
+                public NotSerializableClass BadField;
+
+                [DataField]
+                public NotSerializableClass BadProperty { get; set; }
+
+                public NotSerializableClass GoodField; // Not a DataField, not a problem
+
+                public NotSerializableClass GoodProperty { get; set; } // Not a DataField, not a problem
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(10,12): error RA0033: Data field BadField in data definition Foo is type NotSerializableClass, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(10, 12, 10, 32).WithArguments("BadField", "Foo", "NotSerializableClass"),
+            // /0/Test0.cs(13,12): error RA0033: Data field BadProperty in data definition Foo is type NotSerializableClass, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(13, 12, 13, 32).WithArguments("BadProperty", "Foo", "NotSerializableClass")
         );
     }
 }

Robust.Analyzers.Tests/PrototypeInstantiationAnalyzerTest.cs

@@ -0,0 +1,64 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<Robust.Analyzers.PrototypeInstantiationAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+[TestOf(typeof(PrototypeInstantiationAnalyzer))]
+public sealed class PrototypeInstantiationAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new RTAnalyzerTest<PrototypeInstantiationAnalyzer>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Prototypes.Attributes.cs",
+            "Robust.Shared.Prototypes.IPrototype.cs",
+            "Robust.Shared.Serialization.Manager.Attributes.DataFieldAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Serialization;
+            using Robust.Shared.Prototypes;
+
+            [Prototype]
+            public sealed class FooPrototype : IPrototype
+            {
+                [IdDataField]
+                public string ID { get; private set; } = default!;
+            }
+
+            public static class Bad
+            {
+                public static FooPrototype Real()
+                {
+                    return new FooPrototype();
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(15,16): warning RA0039: Do not instantiate prototypes directly. Prototypes should always be instantiated by the prototype manager.
+            VerifyCS.Diagnostic().WithSpan(15, 16, 15, 34));
+    }
+}

Robust.Analyzers.Tests/PrototypeNetSerializableAnalyzerTest.cs

@@ -0,0 +1,61 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<Robust.Analyzers.PrototypeNetSerializableAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+[TestOf(typeof(PrototypeNetSerializableAnalyzer))]
+public sealed class PrototypeNetSerializableAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new RTAnalyzerTest<PrototypeNetSerializableAnalyzer>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Serialization.NetSerializableAttribute.cs",
+            "Robust.Shared.Prototypes.Attributes.cs",
+            "Robust.Shared.Prototypes.IPrototype.cs",
+            "Robust.Shared.Serialization.Manager.Attributes.DataFieldAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using System;
+            using Robust.Shared.Serialization;
+            using Robust.Shared.Prototypes;
+
+            [Prototype]
+            [Serializable, NetSerializable]
+            public sealed class FooPrototype : IPrototype
+            {
+                [IdDataField]
+                public string ID { get; private set; } = default!;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(7,21): warning RA0037: Type FooPrototype is a prototype and marked as [NetSerializable]. Prototypes should not be directly sent over the network, send their IDs instead.
+            VerifyCS.Diagnostic(PrototypeNetSerializableAnalyzer.RuleNetSerializable).WithSpan(7, 21, 7, 33).WithArguments("FooPrototype"),
+            // /0/Test0.cs(7,21): warning RA0038: Type FooPrototype is a prototype and marked as [Serializable]. Prototypes should not be directly sent over the network, send their IDs instead.
+            VerifyCS.Diagnostic(PrototypeNetSerializableAnalyzer.RuleSerializable).WithSpan(7, 21, 7, 33).WithArguments("FooPrototype"));
+    }
+}

Robust.Analyzers.Tests/RTAnalyzerTest.cs

@@ -0,0 +1,17 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Testing;
+
+namespace Robust.Analyzers.Tests;
+
+public sealed class RTAnalyzerTest<TAnalyzer> : CSharpAnalyzerTest<TAnalyzer, DefaultVerifier>
+    where TAnalyzer : DiagnosticAnalyzer, new()
+{
+    protected override ParseOptions CreateParseOptions()
+    {
+        var baseOptions = (CSharpParseOptions) base.CreateParseOptions();
+        return baseOptions.WithPreprocessorSymbols("ROBUST_ANALYZERS_TEST");
+    }
+}

Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj

@@ -17,6 +17,10 @@
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\ObsoleteInheritanceAttribute.cs" LogicalName="Robust.Shared.Analyzers.ObsoleteInheritanceAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\GameObjects\EventBusAttributes.cs" LogicalName="Robust.Shared.GameObjects.EventBusAttributes.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Serialization\NetSerializableAttribute.cs" LogicalName="Robust.Shared.Serialization.NetSerializableAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Prototypes\Attributes.cs" LogicalName="Robust.Shared.Prototypes.Attributes.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Prototypes\IPrototype.cs" LogicalName="Robust.Shared.Prototypes.IPrototype.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Serialization\Manager\Attributes\DataFieldAttribute.cs" LogicalName="Robust.Shared.Serialization.Manager.Attributes.DataFieldAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <PropertyGroup>

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -18,10 +18,11 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private const string ImplicitDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.ImplicitDataDefinitionForInheritorsAttribute";
     private const string DataFieldBaseNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataFieldBaseAttribute";
     private const string ViewVariablesNamespace = "Robust.Shared.ViewVariables.ViewVariablesAttribute";
+    private const string NotYamlSerializableName = "Robust.Shared.Serialization.Manager.Attributes.NotYamlSerializableAttribute";
     private const string DataFieldAttributeName = "DataField";
     private const string ViewVariablesAttributeName = "ViewVariables";
 
-    private static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
+    public static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
         Diagnostics.IdDataDefinitionPartial,
         "Type must be partial",
         "Type {0} is a DataDefinition but is not partial",
@@ -31,7 +32,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to mark any type that is a data definition as partial."
     );
 
-    private static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
+    public static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
         Diagnostics.IdNestedDataDefinitionPartial,
         "Type must be partial",
         "Type {0} contains nested data definition {1} but is not partial",
@@ -61,7 +62,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to add a setter."
     );
 
-    private static readonly DiagnosticDescriptor DataFieldRedundantTagRule = new(
+    public static readonly DiagnosticDescriptor DataFieldRedundantTagRule = new(
         Diagnostics.IdDataFieldRedundantTag,
         "Data field has redundant tag specified",
         "Data field {0} in data definition {1} has an explicitly set tag that matches autogenerated tag",
@@ -81,9 +82,19 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to remove the ViewVariables attribute."
     );
 
+    public static readonly DiagnosticDescriptor DataFieldYamlSerializableRule = new(
+        Diagnostics.IdDataFieldYamlSerializable,
+        "Data field type is not YAML serializable",
+        "Data field {0} in data definition {1} is type {2}, which is not YAML serializable",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        "Make sure to use a type that is YAML serializable."
+    );
+
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
         DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
-        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule
+        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule, DataFieldYamlSerializableRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -91,23 +102,31 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
 
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.ClassDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.StructDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordStructDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.InterfaceDeclaration);
+        context.RegisterSymbolStartAction(symbolContext =>
+        {
+            if (symbolContext.Symbol is not INamedTypeSymbol typeSymbol)
+                return;
 
-        context.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
+            if (!IsDataDefinition(typeSymbol))
+                return;
+
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.ClassDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.StructDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordStructDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.InterfaceDeclaration);
+
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
+            symbolContext.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
+        }, SymbolKind.NamedType);
     }
 
-    private void AnalyzeDataDefinition(SyntaxNodeAnalysisContext context)
+    private static void AnalyzeDataDefinition(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not TypeDeclarationSyntax declaration)
             return;
 
-        var type = context.SemanticModel.GetDeclaredSymbol(declaration)!;
-        if (!IsDataDefinition(type))
+        if (context.ContainingSymbol is not INamedTypeSymbol type)
             return;
 
         if (!IsPartial(declaration))
@@ -118,7 +137,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         var containingType = type.ContainingType;
         while (containingType != null)
         {
-            var containingTypeDeclaration = (TypeDeclarationSyntax) containingType.DeclaringSyntaxReferences[0].GetSyntax();
+            var containingTypeDeclaration = (TypeDeclarationSyntax)containingType.DeclaringSyntaxReferences[0].GetSyntax();
             if (!IsPartial(containingTypeDeclaration))
             {
                 context.ReportDiagnostic(Diagnostic.Create(NestedDataDefinitionPartialRule, containingTypeDeclaration.Keyword.GetLocation(), containingType.Name, type.Name));
@@ -128,32 +147,31 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         }
     }
 
-    private void AnalyzeDataField(SyntaxNodeAnalysisContext context)
+    private static void AnalyzeDataField(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not FieldDeclarationSyntax field)
             return;
 
-        var typeDeclaration = field.FirstAncestorOrSelf<TypeDeclarationSyntax>();
-        if (typeDeclaration == null)
-            return;
-
-        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
-        if (!IsDataDefinition(type))
+        if (context.ContainingSymbol?.ContainingType is not INamedTypeSymbol type)
             return;
 
         foreach (var variable in field.Declaration.Variables)
         {
             var fieldSymbol = context.SemanticModel.GetDeclaredSymbol(variable);
+
             if (fieldSymbol == null)
                 continue;
 
+            if (!IsDataField(fieldSymbol, out _, out var datafieldAttribute))
+                continue;
+
             if (IsReadOnlyDataField(type, fieldSymbol))
             {
                 TryGetModifierLocation(field, SyntaxKind.ReadOnlyKeyword, out var location);
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, location, fieldSymbol.Name, type.Name));
             }
 
-            if (HasRedundantTag(fieldSymbol))
+            if (HasRedundantTag(fieldSymbol, datafieldAttribute))
             {
                 TryGetAttributeLocation(field, DataFieldAttributeName, out var location);
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, fieldSymbol.Name, type.Name));
@@ -164,33 +182,49 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
                 TryGetAttributeLocation(field, ViewVariablesAttributeName, out var location);
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, fieldSymbol.Name, type.Name));
             }
+
+            if (context.SemanticModel.GetSymbolInfo(field.Declaration.Type).Symbol is not ITypeSymbol fieldTypeSymbol)
+                continue;
+
+            if (IsNotYamlSerializable(fieldSymbol, fieldTypeSymbol))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldYamlSerializableRule,
+                    (context.Node as FieldDeclarationSyntax)?.Declaration.Type.GetLocation(),
+                    fieldSymbol.Name,
+                    type.Name,
+                    fieldTypeSymbol.MetadataName
+                ));
+            }
         }
     }
 
-    private void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
+    private static void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not PropertyDeclarationSyntax property)
             return;
 
-        var typeDeclaration = property.FirstAncestorOrSelf<TypeDeclarationSyntax>();
-        if (typeDeclaration == null)
+        if (context.ContainingSymbol is not IPropertySymbol propertySymbol)
             return;
 
-        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
-        if (!IsDataDefinition(type) || type.IsRecord || type.IsValueType)
+        if (propertySymbol.ContainingType is not INamedTypeSymbol type)
+            return;
+
+        if (type.IsRecord || type.IsValueType)
             return;
 
-        var propertySymbol = context.SemanticModel.GetDeclaredSymbol(property);
         if (propertySymbol == null)
             return;
 
+        if (!IsDataField(propertySymbol, out _, out var datafieldAttribute))
+            return;
+
         if (IsReadOnlyDataField(type, propertySymbol))
         {
             var location = property.AccessorList != null ? property.AccessorList.GetLocation() : property.GetLocation();
             context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, location, propertySymbol.Name, type.Name));
         }
 
-        if (HasRedundantTag(propertySymbol))
+        if (HasRedundantTag(propertySymbol, datafieldAttribute))
         {
             TryGetAttributeLocation(property, DataFieldAttributeName, out var location);
             context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, propertySymbol.Name, type.Name));
@@ -201,13 +235,23 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
             TryGetAttributeLocation(property, ViewVariablesAttributeName, out var location);
             context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, propertySymbol.Name, type.Name));
         }
+
+        if (context.SemanticModel.GetSymbolInfo(property.Type).Symbol is not ITypeSymbol propertyTypeSymbol)
+            return;
+
+        if (IsNotYamlSerializable(propertySymbol, propertyTypeSymbol))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldYamlSerializableRule,
+                (context.Node as PropertyDeclarationSyntax)?.Type.GetLocation(),
+                propertySymbol.Name,
+                type.Name,
+                propertyTypeSymbol.Name
+            ));
+        }
     }
 
     private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
     {
-        if (!IsDataField(field, out _, out _))
-            return false;
-
         return IsReadOnlyMember(type, field);
     }
 
@@ -332,17 +376,14 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
-    private static bool HasRedundantTag(ISymbol symbol)
+    private static bool HasRedundantTag(ISymbol symbol, AttributeData datafieldAttribute)
     {
-        if (!IsDataField(symbol, out var _, out var attribute))
-            return false;
-
         // No args, no problem
-        if (attribute.ConstructorArguments.Length == 0)
+        if (datafieldAttribute.ConstructorArguments.Length == 0)
             return false;
 
         // If a tag is explicitly specified, it will be the first argument...
-        var tagArgument = attribute.ConstructorArguments[0];
+        var tagArgument = datafieldAttribute.ConstructorArguments[0];
         // ...but the first arg could also something else, since tag is optional
         // so we make sure that it's a string
         if (tagArgument.Value is not string explicitName)
@@ -357,9 +398,6 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 
     private static bool HasVVReadWrite(ISymbol symbol)
     {
-        if (!IsDataField(symbol, out _, out _))
-            return false;
-
         // Make sure it has ViewVariablesAttribute
         AttributeData? viewVariablesAttribute = null;
         foreach (var attr in symbol.GetAttributes())
@@ -383,6 +421,11 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return (VVAccess)accessByte == VVAccess.ReadWrite;
     }
 
+    private static bool IsNotYamlSerializable(ISymbol field, ITypeSymbol type)
+    {
+        return HasAttribute(type, NotYamlSerializableName);
+    }
+
     private static bool IsImplicitDataDefinition(ITypeSymbol type)
     {
         if (HasAttribute(type, ImplicitDataDefinitionNamespace))

Robust.Analyzers/PrototypeInstantiationAnalyzer.cs

@@ -0,0 +1,48 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PrototypeInstantiationAnalyzer : DiagnosticAnalyzer
+{
+    private const string PrototypeInterfaceType = "Robust.Shared.Prototypes.IPrototype";
+
+    public static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdPrototypeInstantiation,
+        "Do not instantiate prototypes directly",
+        "Do not instantiate prototypes directly. Prototypes should always be instantiated by the prototype manager.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterCompilationStartAction(static ctx =>
+        {
+            var prototypeInterface = ctx.Compilation.GetTypeByMetadataName(PrototypeInterfaceType);
+            if (prototypeInterface == null)
+                return;
+
+            ctx.RegisterOperationAction(symContext => Check(prototypeInterface, symContext), OperationKind.ObjectCreation);
+        });
+    }
+
+    private static void Check(INamedTypeSymbol prototypeInterface, OperationAnalysisContext ctx)
+    {
+        if (ctx.Operation is not IObjectCreationOperation { Type: { } resultType } creationOp)
+            return;
+
+        if (!TypeSymbolHelper.ImplementsInterface(resultType, prototypeInterface))
+            return;
+
+        ctx.ReportDiagnostic(Diagnostic.Create(Rule, creationOp.Syntax.GetLocation()));
+    }
+}

Robust.Analyzers/PrototypeNetSerializableAnalyzer.cs

@@ -0,0 +1,76 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PrototypeNetSerializableAnalyzer : DiagnosticAnalyzer
+{
+    private const string PrototypeInterfaceType = "Robust.Shared.Prototypes.IPrototype";
+    private const string NetSerializableAttributeType = "Robust.Shared.Serialization.NetSerializableAttribute";
+
+    public static readonly DiagnosticDescriptor RuleNetSerializable = new(
+        Diagnostics.IdPrototypeNetSerializable,
+        "Prototypes should not be [NetSerializable]",
+        "Type {0} is a prototype and marked as [NetSerializable]. Prototypes should not be directly sent over the network, send their IDs instead.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+
+    public static readonly DiagnosticDescriptor RuleSerializable = new(
+        Diagnostics.IdPrototypeSerializable,
+        "Prototypes should not be [Serializable]",
+        "Type {0} is a prototype and marked as [Serializable]. Prototypes should not be directly sent over the network, send their IDs instead.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [
+        RuleNetSerializable,
+        RuleSerializable
+    ];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+
+        context.RegisterCompilationStartAction(static ctx =>
+        {
+            var prototypeInterface = ctx.Compilation.GetTypeByMetadataName(PrototypeInterfaceType);
+            var netSerializableAttribute = ctx.Compilation.GetTypeByMetadataName(NetSerializableAttributeType);
+
+            if (prototypeInterface == null || netSerializableAttribute == null)
+                return;
+
+            ctx.RegisterSymbolAction(symbolContext => CheckClass(prototypeInterface, netSerializableAttribute, symbolContext), SymbolKind.NamedType);
+        });
+    }
+
+    private static void CheckClass(
+        INamedTypeSymbol prototypeInterface,
+        INamedTypeSymbol netSerializableAttribute,
+        SymbolAnalysisContext symbolContext)
+    {
+        if (symbolContext.Symbol is not INamedTypeSymbol symbol)
+            return;
+
+        if (!TypeSymbolHelper.ImplementsInterface(symbol, prototypeInterface))
+            return;
+
+        if (AttributeHelper.HasAttribute(symbol, netSerializableAttribute, out _))
+        {
+            symbolContext.ReportDiagnostic(
+                Diagnostic.Create(RuleNetSerializable, symbol.Locations[0], symbol.ToDisplayString()));
+        }
+
+        if (symbol.IsSerializable)
+        {
+            symbolContext.ReportDiagnostic(
+                Diagnostic.Create(RuleSerializable, symbol.Locations[0], symbol.ToDisplayString()));
+        }
+    }
+}

Robust.Client.WebView/Cef/Program.cs

@@ -6,7 +6,7 @@ using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
 {
-    public static class Program
+    internal 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)

Robust.Client.WebView/Cef/WebViewManagerCef.Control.cs

@@ -162,9 +162,10 @@ namespace Robust.Client.WebView.Cef
                 }
             }
 
+            public bool IsOpen => _data != null;
             public bool IsLoading => _data?.Browser.IsLoading ?? false;
 
-            public void EnteredTree()
+            public void StartBrowser()
             {
                 DebugTools.AssertNull(_data);
 
@@ -195,7 +196,7 @@ namespace Robust.Client.WebView.Cef
                 _data = new LiveData(texture, client, browser, renderer);
             }
 
-            public void ExitedTree()
+            public void CloseBrowser()
             {
                 DebugTools.AssertNotNull(_data);
 

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -5,6 +5,7 @@ using System.Net;
 using System.Reflection;
 using System.Text;
 using Robust.Client.Console;
+using Robust.Client.Utility;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
@@ -24,6 +25,7 @@ namespace Robust.Client.WebView.Cef
 
         [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IGameControllerInternal _gameController = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
@@ -61,7 +63,10 @@ namespace Robust.Client.WebView.Cef
 
             var cachePath = "";
             if (_resourceManager.UserData is WritableDirProvider userData)
-                cachePath = userData.GetFullPath(new ResPath("/cef_cache"));
+            {
+                var rootDir = UserDataDir.GetRootUserDataDir(_gameController);
+                cachePath = Path.Combine(rootDir, "cef_cache", "0");
+            }
 
             var settings = new CefSettings()
             {

Robust.Client.WebView/Headless/WebViewManagerHeadless.cs

@@ -81,11 +81,13 @@ namespace Robust.Client.WebView.Headless
 
         private sealed class WebViewControlImplDummy : DummyBase, IWebViewControlImpl
         {
-            public void EnteredTree()
+            public bool IsOpen => false;
+
+            public void StartBrowser()
             {
             }
 
-            public void ExitedTree()
+            public void CloseBrowser()
             {
             }
 

Robust.Client.WebView/IWebViewControlImpl.cs

@@ -9,8 +9,10 @@ namespace Robust.Client.WebView
     /// </summary>
     internal interface IWebViewControlImpl : IWebViewControl
     {
-        void EnteredTree();
-        void ExitedTree();
+        public bool IsOpen { get; }
+
+        void StartBrowser();
+        void CloseBrowser();
         void MouseMove(GUIMouseMoveEventArgs args);
         void MouseExited();
         void MouseWheel(GUIMouseWheelEventArgs args);

Robust.Client.WebView/WebViewControl.cs

@@ -14,6 +14,7 @@ namespace Robust.Client.WebView
         [Dependency] private readonly IWebViewManagerInternal _webViewManager = default!;
 
         private readonly IWebViewControlImpl _controlImpl;
+        private bool _alwaysActive;
 
         [ViewVariables(VVAccess.ReadWrite)]
         public string Url
@@ -22,6 +23,21 @@ namespace Robust.Client.WebView
             set => _controlImpl.Url = value;
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool AlwaysActive
+        {
+            get => _alwaysActive;
+            set
+            {
+                _alwaysActive = value;
+
+                if (_alwaysActive && !_controlImpl.IsOpen)
+                    _controlImpl.StartBrowser();
+                else if (!_alwaysActive && _controlImpl.IsOpen && !IsInsideTree)
+                    _controlImpl.CloseBrowser();
+            }
+        }
+
         [ViewVariables] public bool IsLoading => _controlImpl.IsLoading;
 
         public WebViewControl()
@@ -39,14 +55,16 @@ namespace Robust.Client.WebView
         {
             base.EnteredTree();
 
-            _controlImpl.EnteredTree();
+            if (!_controlImpl.IsOpen)
+                _controlImpl.StartBrowser();
         }
 
         protected override void ExitedTree()
         {
             base.ExitedTree();
 
-            _controlImpl.ExitedTree();
+            if (!_alwaysActive)
+                _controlImpl.CloseBrowser();
         }
 
         protected internal override void MouseMove(GUIMouseMoveEventArgs args)

Robust.Client/Animations/AnimationTrackProperty.cs

@@ -3,8 +3,6 @@ using System.Collections.Generic;
 using System.Numerics;
 using Robust.Shared.Animations;
 using Robust.Shared.Maths;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Animations
 {
@@ -13,7 +11,7 @@ namespace Robust.Client.Animations
     /// </summary>
     public abstract class AnimationTrackProperty : AnimationTrack
     {
-        public List<KeyFrame> KeyFrames { get; protected set; } = new();
+        public List<KeyFrame> KeyFrames { get; set; } = new();
 
         /// <summary>
         ///     How to interpolate values when between two keyframes.
@@ -122,9 +120,9 @@ namespace Robust.Client.Animations
                 case Vector2 vector2:
                     return Vector2Helpers.InterpolateCubic((Vector2) preA, vector2, (Vector2) b, (Vector2) postB, t);
                 case Vector3 vector3:
-                    return Vector3.InterpolateCubic((Vector3) preA, vector3, (Vector3) b, (Vector3) postB, t);
+                    return VectorHelpers.InterpolateCubic((Vector3) preA, vector3, (Vector3) b, (Vector3) postB, t);
                 case Vector4 vector4:
-                    return Vector4.InterpolateCubic((Vector4) preA, vector4, (Vector4) b, (Vector4) postB, t);
+                    return VectorHelpers.InterpolateCubic((Vector4) preA, vector4, (Vector4) b, (Vector4) postB, t);
                 case float f:
                     return MathHelper.InterpolateCubic((float) preA, f, (float) b, (float) postB, t);
                 case double d:

Robust.Client/Audio/AudioManager.cs

@@ -57,8 +57,8 @@ internal sealed partial class AudioManager : IAudioInternal
         _checkAlError();
 
         // Load up AL context extensions.
-        var s = ALC.GetString(ALDevice.Null, AlcGetString.Extensions) ?? "";
-        foreach (var extension in s.Split(' '))
+        var s = ALC.GetString(_openALDevice, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' ', StringSplitOptions.RemoveEmptyEntries))
         {
             _alContextExtensions.Add(extension);
         }

Robust.Client/Audio/AudioSystem.cs

@@ -582,7 +582,7 @@ public sealed partial class AudioSystem : SharedAudioSystem
     {
         if (TerminatingOrDeleted(entity))
         {
-            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(entity)}");
+            LogAudioPlaybackOnInvalidEntity(specifier, entity);
             return null;
         }
 
@@ -626,7 +626,7 @@ public sealed partial class AudioSystem : SharedAudioSystem
     {
         if (TerminatingOrDeleted(coordinates.EntityId))
         {
-            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(coordinates.EntityId)}");
+            LogAudioPlaybackOnInvalidEntity(specifier, coordinates.EntityId);
             return null;
         }
 
@@ -753,6 +753,12 @@ public sealed partial class AudioSystem : SharedAudioSystem
         return _resourceCache.GetResource<AudioResource>(filename).AudioStream.Length;
     }
 
+    private void LogAudioPlaybackOnInvalidEntity(ResolvedSoundSpecifier? specifier, EntityUid entityId)
+    {
+        var soundInfo = specifier?.ToString() ?? "unknown sound";
+        Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(entityId)}. Sound: {soundInfo}. Trace: {Environment.StackTrace}");
+    }
+
     #region Jobs
 
     private record struct UpdateAudioJob : IParallelRobustJob

Robust.Client/Audio/Effects/AudioEffect.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Numerics;
 using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Effects;

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -6,6 +6,7 @@ using Robust.Shared.Audio.Midi;
 using Robust.Shared.Audio.Sources;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.Audio.Midi;
 
@@ -156,8 +157,13 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     Loads a new soundfont into the renderer.
     /// </summary>
+    [Obsolete("Use LoadSoundfontResource or LoadSoundfontUser instead")]
     void LoadSoundfont(string filename, bool resetPresets = false);
 
+    void LoadSoundfontResource(ResPath path, bool resetPresets = false);
+
+    void LoadSoundfontUser(ResPath path, bool resetPresets = false);
+
     /// <summary>
     ///     Invoked whenever a new midi event is registered.
     /// </summary>

Robust.Client/Audio/Midi/MidiManager.SoundFontLoad.cs

@@ -0,0 +1,262 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using NFluidsynth;
+using Robust.Shared.ContentPack;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio.Midi;
+
+internal sealed partial class MidiManager
+{
+    // For loading sound fonts, we have to use a callback model where we can only parse a string.
+    // This API, frankly, fucking sucks.
+    //
+    // These prefixes are used to separate the various places a file *can* be loaded from.
+    //
+    // We cannot prevent Fluidsynth from trying to load prefixed paths itself if they are invalid
+    // So if content specifies "/foobar.sf2" to be loaded and it doesn't exist,
+    // Fluidsynth *will* try to fopen("RES:/foobar.sf2"). For this reason I'm putting in some nonsense characters
+    // that will pass through Fluidsynth fine, but make sure the filename is *never* a practically valid OS path.
+    //
+    // NOTE: Raw disk paths *cannot* be prefixed as Fluidsynth needs to load those itself.
+    // Specifically, their .dls loader doesn't respect file callbacks.
+    // If you're curious why this is: it's two-fold:
+    // * The Fluidsynth C code for the .dls loader just doesn't use the file callbacks, period.
+    // * Even if it did, we're not specifying those file callbacks, as they're per loader,
+    //   and we're only adding a *new* sound font loader with file callbacks, not modifying the existing ones.
+    //   The loader for .sfX format and .dls format are different loader objects in Fluidsynth.
+    internal const string PrefixCommon = "!/ -?\x0001";
+    internal const string PrefixLegacy = PrefixCommon + "LEGACY";
+    internal const string PrefixUser = PrefixCommon + "USER";
+    internal const string PrefixResources = PrefixCommon + "RES";
+
+    private void LoadSoundFontSetup(MidiRenderer renderer)
+    {
+        _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
+        // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
+        renderer.LoadSoundfontResource(FallbackSoundfont);
+
+        // Load system-specific soundfonts.
+        if (OperatingSystem.IsLinux())
+        {
+            foreach (var filepath in LinuxSoundfonts)
+            {
+                if (!File.Exists(filepath) || !SoundFont.IsSoundFont(filepath))
+                    continue;
+
+                try
+                {
+                    _midiSawmill.Debug($"Loading OS soundfont {filepath}");
+                    renderer.LoadSoundfontDisk(filepath);
+                }
+                catch (Exception)
+                {
+                    continue;
+                }
+
+                break;
+            }
+        }
+        else if (OperatingSystem.IsMacOS())
+        {
+            if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
+            {
+                _midiSawmill.Debug($"Loading OS soundfont {OsxSoundfont}");
+                renderer.LoadSoundfontDisk(OsxSoundfont);
+            }
+        }
+        else if (OperatingSystem.IsWindows())
+        {
+            if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
+            {
+                _midiSawmill.Debug($"Loading OS soundfont {WindowsSoundfont}");
+                renderer.LoadSoundfontDisk(WindowsSoundfont);
+            }
+        }
+
+        // Maybe load soundfont specified in environment variable.
+        // Load it here so it can override system soundfonts but not content or user data soundfonts.
+        if (Environment.GetEnvironmentVariable(SoundfontEnvironmentVariable) is { } soundfontOverride)
+        {
+            // Just to avoid funny shit: avoid people smuggling a prefix in here.
+            // I wish I could separate this properly...
+            var (prefix, _) = SplitPrefix(soundfontOverride);
+            if (IsValidPrefix(prefix))
+            {
+                _midiSawmill.Error($"Not respecting {SoundfontEnvironmentVariable} env variable: invalid file path");
+            }
+            else if (File.Exists(soundfontOverride) && SoundFont.IsSoundFont(soundfontOverride))
+            {
+                _midiSawmill.Debug($"Loading environment variable soundfont {soundfontOverride}");
+                renderer.LoadSoundfontDisk(soundfontOverride);
+            }
+        }
+
+        // Load content-specific custom soundfonts, which should override the system/fallback soundfont.
+        _midiSawmill.Debug($"Loading soundfonts from content directory {ContentCustomSoundfontDirectory}");
+        foreach (var file in _resourceManager.ContentFindFiles(ContentCustomSoundfontDirectory))
+        {
+            if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
+            _midiSawmill.Debug($"Loading content soundfont {file}");
+            renderer.LoadSoundfontResource(file);
+        }
+
+        // Load every soundfont from the user data directory last, since those may override any other soundfont.
+        _midiSawmill.Debug($"Loading soundfonts from user data directory {CustomSoundfontDirectory}");
+        var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}*").Item1;
+        foreach (var file in enumerator)
+        {
+            if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
+            _midiSawmill.Debug($"Loading user soundfont {file}");
+            renderer.LoadSoundfontUser(file);
+        }
+    }
+
+    internal static string PrefixPath(string prefix, string value)
+    {
+        return $"{prefix}:{value}";
+    }
+
+    internal static (string prefix, string? value) SplitPrefix(string filename)
+    {
+        var filenameSplit = filename.Split(':', 2);
+        if (filenameSplit.Length == 1)
+            return (filenameSplit[0], null);
+
+        return (filenameSplit[0], filenameSplit[1]);
+    }
+
+    internal static bool IsValidPrefix(string prefix)
+    {
+        return prefix is PrefixLegacy or PrefixUser or PrefixResources;
+    }
+
+    /// <summary>
+    ///     This class is used to load soundfonts.
+    /// </summary>
+    private sealed class ResourceLoaderCallbacks : SoundFontLoaderCallbacks
+    {
+        private readonly MidiManager _parent;
+        private readonly Dictionary<int, Stream> _openStreams = new();
+        private int _nextStreamId = 1;
+
+        public ResourceLoaderCallbacks(MidiManager parent)
+        {
+            _parent = parent;
+        }
+
+        public override IntPtr Open(string filename)
+        {
+            if (string.IsNullOrEmpty(filename))
+            {
+                return IntPtr.Zero;
+            }
+
+            Stream stream;
+            try
+            {
+                stream = OpenCore(filename);
+            }
+            catch (Exception e)
+            {
+                _parent._midiSawmill.Error($"Error while opening sound font: {e}");
+                return IntPtr.Zero;
+            }
+
+            var id = _nextStreamId++;
+
+            _openStreams.Add(id, stream);
+
+            return (IntPtr) id;
+        }
+
+        private Stream OpenCore(string filename)
+        {
+            var (prefix, value) = SplitPrefix(filename);
+
+            if (!IsValidPrefix(prefix) || value == null)
+                return File.OpenRead(filename);
+
+            var resourceCache = _parent._resourceManager;
+            var resourcePath = new ResPath(value);
+
+            switch (prefix)
+            {
+                case PrefixUser:
+                    return resourceCache.UserData.OpenRead(resourcePath);
+                case PrefixResources:
+                    return resourceCache.ContentFileRead(resourcePath);
+                case PrefixLegacy:
+                    // Try resources first, then try user data.
+                    if (resourceCache.TryContentFileRead(resourcePath, out var stream))
+                        return stream;
+
+                    return resourceCache.UserData.OpenRead(resourcePath);
+                default:
+                    throw new UnreachableException("Invalid prefix specified!");
+            }
+        }
+
+        public override unsafe int Read(IntPtr buf, long count, IntPtr sfHandle)
+        {
+            var length = (int) count;
+            var span = new Span<byte>(buf.ToPointer(), length);
+            var stream = _openStreams[(int) sfHandle];
+
+            // Fluidsynth's docs state that this method should leave the buffer unmodified if it fails. (returns -1)
+            try
+            {
+                // Fluidsynth does a LOT of tiny allocations (frankly, way too much).
+                if (count < 1024)
+                {
+                    // ReSharper disable once SuggestVarOrType_Elsewhere
+                    Span<byte> buffer = stackalloc byte[(int)count];
+
+                    stream.ReadExact(buffer);
+
+                    buffer.CopyTo(span);
+                }
+                else
+                {
+                    var buffer = stream.ReadExact(length);
+
+                    buffer.CopyTo(span);
+                }
+            }
+            catch (EndOfStreamException)
+            {
+                return -1;
+            }
+
+            return 0;
+        }
+
+        public override int Seek(IntPtr sfHandle, long offset, SeekOrigin origin)
+        {
+            var stream = _openStreams[(int) sfHandle];
+
+            stream.Seek(offset, origin);
+
+            return 0;
+        }
+
+        public override long Tell(IntPtr sfHandle)
+        {
+            var stream = _openStreams[(int) sfHandle];
+
+            return (long) stream.Position;
+        }
+
+        public override int Close(IntPtr sfHandle)
+        {
+            if (!_openStreams.Remove((int) sfHandle, out var stream))
+                return -1;
+
+            stream.Dispose();
+            return 0;
+
+        }
+    }
+}

Robust.Client/Audio/Midi/MidiManager.cs

@@ -119,7 +119,7 @@ internal sealed partial class MidiManager : IMidiManager
     private const string OsxSoundfont =
         "/System/Library/Components/CoreAudio.component/Contents/Resources/gs_instruments.dls";
 
-    private const string FallbackSoundfont = "/Midi/fallback.sf2";
+    private static readonly ResPath FallbackSoundfont = new ResPath("/Midi/fallback.sf2");
 
     private const string ContentCustomSoundfontDirectory = "/Audio/MidiCustom/";
 
@@ -265,81 +265,7 @@ internal sealed partial class MidiManager : IMidiManager
 
             var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _audio, _taskManager, _midiSawmill);
 
-            _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
-            // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
-            renderer.LoadSoundfont(FallbackSoundfont);
-
-            // Load system-specific soundfonts.
-            if (OperatingSystem.IsLinux())
-            {
-                foreach (var filepath in LinuxSoundfonts)
-                {
-                    if (!File.Exists(filepath) || !SoundFont.IsSoundFont(filepath))
-                        continue;
-
-                    try
-                    {
-                        _midiSawmill.Debug($"Loading OS soundfont {filepath}");
-                        renderer.LoadSoundfont(filepath);
-                    }
-                    catch (Exception)
-                    {
-                        continue;
-                    }
-
-                    break;
-                }
-            }
-            else if (OperatingSystem.IsMacOS())
-            {
-                if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
-                {
-                    _midiSawmill.Debug($"Loading OS soundfont {OsxSoundfont}");
-                    renderer.LoadSoundfont(OsxSoundfont);
-                }
-            }
-            else if (OperatingSystem.IsWindows())
-            {
-                if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
-                {
-                    _midiSawmill.Debug($"Loading OS soundfont {WindowsSoundfont}");
-                    renderer.LoadSoundfont(WindowsSoundfont);
-                }
-            }
-
-            // Maybe load soundfont specified in environment variable.
-            // Load it here so it can override system soundfonts but not content or user data soundfonts.
-            if (Environment.GetEnvironmentVariable(SoundfontEnvironmentVariable) is {} soundfontOverride)
-            {
-                if (File.Exists(soundfontOverride) && SoundFont.IsSoundFont(soundfontOverride))
-                {
-                    _midiSawmill.Debug($"Loading environment variable soundfont {soundfontOverride}");
-                    renderer.LoadSoundfont(soundfontOverride);
-                }
-            }
-
-            // Load content-specific custom soundfonts, which should override the system/fallback soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from content directory {ContentCustomSoundfontDirectory}");
-            foreach (var file in _resourceManager.ContentFindFiles(ContentCustomSoundfontDirectory))
-            {
-                if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading content soundfont {file}");
-                renderer.LoadSoundfont(file.ToString());
-            }
-
-            var userDataPath = _resourceManager.UserData.RootDir == null
-                ? CustomSoundfontDirectory
-                : new ResPath(_resourceManager.UserData.RootDir) / CustomSoundfontDirectory.ToRelativePath();
-
-            // Load every soundfont from the user data directory last, since those may override any other soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from user data directory {userDataPath}");
-            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}*").Item1;
-            foreach (var file in enumerator)
-            {
-                if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading user soundfont {file}");
-                renderer.LoadSoundfont(file.ToString());
-            }
+            LoadSoundFontSetup(renderer);
 
             renderer.Source.Gain = _gain;
 
@@ -572,130 +498,6 @@ internal sealed partial class MidiManager : IMidiManager
             midiEvent.Velocity);
     }
 
-    /// <summary>
-    ///     This class is used to load soundfonts.
-    /// </summary>
-    private sealed class ResourceLoaderCallbacks : SoundFontLoaderCallbacks
-    {
-        private readonly MidiManager _parent;
-        private readonly Dictionary<int, Stream> _openStreams = new();
-        private int _nextStreamId = 1;
-
-        public ResourceLoaderCallbacks(MidiManager parent)
-        {
-            _parent = parent;
-        }
-
-        public override IntPtr Open(string filename)
-        {
-            if (string.IsNullOrEmpty(filename))
-            {
-                return IntPtr.Zero;
-            }
-
-            Stream? stream;
-            var resourceCache = _parent._resourceManager;
-            var resourcePath = new ResPath(filename);
-
-            if (resourcePath.IsRooted)
-            {
-                // is it in content?
-                if (resourceCache.ContentFileExists(filename))
-                {
-                    if (!resourceCache.TryContentFileRead(filename, out stream))
-                        return IntPtr.Zero;
-                }
-                // is it in userdata?
-                else if (resourceCache.UserData.Exists(resourcePath))
-                {
-                    stream = resourceCache.UserData.OpenRead(resourcePath);
-                }
-                else if (File.Exists(filename))
-                {
-                    stream = File.OpenRead(filename);
-                }
-                else
-                {
-                    return IntPtr.Zero;
-                }
-            }
-            else if (File.Exists(filename))
-            {
-                stream = File.OpenRead(filename);
-            }
-            else
-            {
-                return IntPtr.Zero;
-            }
-
-            var id = _nextStreamId++;
-
-            _openStreams.Add(id, stream);
-
-            return (IntPtr) id;
-        }
-
-        public override unsafe int Read(IntPtr buf, long count, IntPtr sfHandle)
-        {
-            var length = (int) count;
-            var span = new Span<byte>(buf.ToPointer(), length);
-            var stream = _openStreams[(int) sfHandle];
-
-            // Fluidsynth's docs state that this method should leave the buffer unmodified if it fails. (returns -1)
-            try
-            {
-                // Fluidsynth does a LOT of tiny allocations (frankly, way too much).
-                if (count < 1024)
-                {
-                    // ReSharper disable once SuggestVarOrType_Elsewhere
-                    Span<byte> buffer = stackalloc byte[(int)count];
-
-                    stream.ReadExact(buffer);
-
-                    buffer.CopyTo(span);
-                }
-                else
-                {
-                    var buffer = stream.ReadExact(length);
-
-                    buffer.CopyTo(span);
-                }
-            }
-            catch (EndOfStreamException)
-            {
-                return -1;
-            }
-
-            return 0;
-        }
-
-        public override int Seek(IntPtr sfHandle, long offset, SeekOrigin origin)
-        {
-            var stream = _openStreams[(int) sfHandle];
-
-            stream.Seek(offset, origin);
-
-            return 0;
-        }
-
-        public override long Tell(IntPtr sfHandle)
-        {
-            var stream = _openStreams[(int) sfHandle];
-
-            return (long) stream.Position;
-        }
-
-        public override int Close(IntPtr sfHandle)
-        {
-            if (!_openStreams.Remove((int) sfHandle, out var stream))
-                return -1;
-
-            stream.Dispose();
-            return 0;
-
-        }
-    }
-
     #region Jobs
 
     private record struct MidiUpdateJob : IParallelRobustJob

Robust.Client/Audio/Midi/MidiRenderer.SoundFontLoad.cs

@@ -0,0 +1,45 @@
+using System;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio.Midi;
+
+internal sealed partial class MidiRenderer
+{
+    [Obsolete("Use LoadSoundfontResource or LoadSoundfontUser instead")]
+    public void LoadSoundfont(string filename, bool resetPresets = true)
+    {
+        LoadSoundfontCore(
+            MidiManager.PrefixPath(MidiManager.PrefixLegacy, filename),
+            resetPresets);
+    }
+
+    public void LoadSoundfontResource(ResPath path, bool resetPresets = false)
+    {
+        LoadSoundfontCore(
+            MidiManager.PrefixPath(MidiManager.PrefixResources, path.ToString()),
+            resetPresets);
+    }
+
+    public void LoadSoundfontUser(ResPath path, bool resetPresets = false)
+    {
+        LoadSoundfontCore(
+            MidiManager.PrefixPath(MidiManager.PrefixUser, path.ToString()),
+            resetPresets);
+    }
+
+    internal void LoadSoundfontDisk(string path, bool resetPresets = false)
+    {
+        LoadSoundfontCore(
+            path,
+            resetPresets);
+    }
+
+    private void LoadSoundfontCore(string filenameString, bool resetPresets)
+    {
+        lock (_playerStateLock)
+        {
+            _synth.LoadSoundFont(filenameString, resetPresets);
+            MidiSoundfont = 1;
+        }
+    }
+}

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -16,7 +16,7 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Audio.Midi;
 
-internal sealed class MidiRenderer : IMidiRenderer
+internal sealed partial class MidiRenderer : IMidiRenderer
 {
     private readonly IMidiManager _midiManager;
     private readonly ITaskManager _taskManager;
@@ -435,15 +435,6 @@ internal sealed class MidiRenderer : IMidiRenderer
         _sequencer.RemoveEvents(SequencerClientId.Wildcard, SequencerClientId.Wildcard, -1);
     }
 
-    public void LoadSoundfont(string filename, bool resetPresets = true)
-    {
-        lock (_playerStateLock)
-        {
-            _synth.LoadSoundFont(filename, resetPresets);
-            MidiSoundfont = 1;
-        }
-    }
-
     void IMidiRenderer.Render()
     {
         Render();
@@ -584,18 +575,28 @@ internal sealed class MidiRenderer : IMidiRenderer
                     case RobustMidiCommand.NoteOff:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = 0;
                         _synth.NoteOff(midiEvent.Channel, midiEvent.Key);
-                        break;
 
+                        break;
                     case RobustMidiCommand.NoteOn:
+                        // Velocity 0 *can* represent a NoteOff event.
+                        var velocity = midiEvent.Velocity;
+                        if (velocity == 0)
+                        {
+                            _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = 0;
+                            _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
+
+                            break;
+                        }
+
                         if (FilteredChannels[midiEvent.Channel])
                             break;
 
-                        var velocity = VelocityOverride ?? midiEvent.Velocity;
+                        velocity = VelocityOverride ?? midiEvent.Velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
                         _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
-                        break;
 
+                        break;
                     case RobustMidiCommand.AfterTouch:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = midiEvent.Value;
                         _synth.KeyPressure(midiEvent.Channel, midiEvent.Key, midiEvent.Value);

Robust.Client/ClientIoC.cs

@@ -144,6 +144,7 @@ namespace Robust.Client
             deps.Register<IViewVariablesManager, ClientViewVariablesManager>();
             deps.Register<IClientViewVariablesManager, ClientViewVariablesManager>();
             deps.Register<IClientViewVariablesManagerInternal, ClientViewVariablesManager>();
+            deps.Register<IViewVariableControlFactory, ViewVariableControlFactory>();
             deps.Register<IClientConGroupController, ClientConGroupController>();
             deps.Register<IScriptClient, ScriptClient>();
             deps.Register<IRobustSerializer, ClientRobustSerializer>();

Robust.Client/ComponentTrees/SpriteTreeSystem.cs

@@ -2,6 +2,7 @@ using System.Numerics;
 using Robust.Client.GameObjects;
 using Robust.Shared.ComponentTrees;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 
@@ -9,25 +10,7 @@ namespace Robust.Client.ComponentTrees;
 
 public sealed class SpriteTreeSystem : ComponentTreeSystem<SpriteTreeComponent, SpriteComponent>
 {
-    public override void Initialize()
-    {
-        base.Initialize();
-        SubscribeLocalEvent<SpriteComponent, QueueSpriteTreeUpdateEvent>(OnQueueUpdate);
-    }
-
-    private void OnQueueUpdate(EntityUid uid, SpriteComponent component, ref QueueSpriteTreeUpdateEvent args)
-        => QueueTreeUpdate(uid, component, args.Xform);
-
-    // TODO remove this when finally ECSing sprite components
-    [ByRefEvent]
-    internal readonly struct QueueSpriteTreeUpdateEvent
-    {
-        public readonly TransformComponent Xform;
-        public QueueSpriteTreeUpdateEvent(TransformComponent xform)
-        {
-            Xform = xform;
-        }
-    }
+    [Dependency] private readonly SpriteSystem _sprite = default!;
 
     #region Component Tree Overrides
     protected override bool DoFrameUpdate => true;
@@ -36,6 +19,11 @@ public sealed class SpriteTreeSystem : ComponentTreeSystem<SpriteTreeComponent,
     protected override int InitialCapacity => 1024;
 
     protected override Box2 ExtractAabb(in ComponentTreeEntry<SpriteComponent> entry, Vector2 pos, Angle rot)
-        => entry.Component.CalculateRotatedBoundingBox(pos, rot, default).CalcBoundingBox();
+    {
+        // TODO SPRITE optimize this
+        // Because the just take the BB of the rotated BB, I'm pretty sure we do a lot of unnecessary maths.
+        return _sprite.CalculateBounds((entry.Uid, entry.Component), pos, rot, default).CalcBoundingBox();
+    }
+
     #endregion
 }

Robust.Client/Console/ClientConsoleHost.cs

@@ -191,8 +191,16 @@ namespace Robust.Client.Console
             var shell = new ConsoleShell(this, session ?? _player.LocalSession, session == null);
             var cmdArgs = args.ToArray();
 
-            AnyCommandExecuted?.Invoke(shell, commandName, command, cmdArgs);
-            cmd.Execute(shell, command, cmdArgs);
+            try
+            {
+                AnyCommandExecuted?.Invoke(shell, commandName, command, cmdArgs);
+                cmd.Execute(shell, command, cmdArgs);
+            }
+            catch (Exception e)
+            {
+                _conLogger.Error($"ExecuteError - {command}:\n{e}");
+                shell.WriteError($"There was an error while executing the command: {e}");
+            }
         }
 
         private bool CanExecute(string cmdName)

Robust.Client/Console/Completions.cs

@@ -85,7 +85,7 @@ namespace Robust.Client.Console
                 MouseFilter = MouseFilterMode.Stop;
                 Result = result;
                 var compl = new FormattedMessage();
-                var dim = Color.FromHsl((0f, 0f, 0.8f, 1f));
+                var dim = Color.FromHsl(new Vector4(0f, 0f, 0.8f, 1f));
 
                 // warning: ew ahead
                 string basen = "default";

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -82,7 +82,7 @@ namespace Robust.Client.Debugging
 
             foreach (var ent in _mapSystem.GetAnchoredEntities(gridUid, grid, spot))
             {
-                if (EntityManager.TryGetComponent<MetaDataComponent>(ent, out var meta))
+                if (TryComp(ent, out MetaDataComponent? meta))
                 {
                     text.AppendLine($"uid: {ent}, {meta.EntityName}");
                 }

Robust.Client/GameController/GameController.cs

@@ -160,6 +160,7 @@ namespace Robust.Client
             }
 
             _serializationManager.Initialize();
+            _loc.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
@@ -182,7 +183,6 @@ namespace Robust.Client
             _serializer.Initialize();
             _inputManager.Initialize();
             _console.Initialize();
-            _loc.Initialize();
 
             // Make sure this is done before we try to load prototypes,
             // avoid any possibility of race conditions causing the check to not finish
@@ -387,7 +387,7 @@ namespace Robust.Client
 
             _prof.Initialize();
 
-            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
+            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null, hideUserDataDir: true);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -296,7 +296,7 @@ namespace Robust.Client.GameObjects
         public override void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
         {
             if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityDeleted
+                || ent.Comp1.EntityLifeStage >= EntityLifeStage.Terminating
                 || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
             {
                 return;
@@ -322,7 +322,7 @@ namespace Robust.Client.GameObjects
         {
             if (IsQueuedForDeletion(ent.Owner)
                 || !MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityDeleted
+                || ent.Comp1.EntityLifeStage >= EntityLifeStage.Terminating
                 || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
             {
                 return;

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

@@ -1,9 +1,11 @@
-using Robust.Shared.GameObjects;
+using System;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
 namespace Robust.Client.GameObjects
 {
+    [Obsolete]
     public partial interface IRenderableComponent : IComponent
     {
         int DrawDepth { get; set; }

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

@@ -1,6 +1,5 @@
 using System.Numerics;
 using Robust.Client.Graphics;
-using Robust.Shared.Graphics;
 using Robust.Shared.Graphics.RSI;
 using Robust.Shared.Maths;
 

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

@@ -24,9 +24,7 @@ namespace Robust.Client.GameObjects
 
     public sealed class SpriteBoundsSystem : EntitySystem
     {
-        [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
-        [Dependency] private readonly SpriteTreeSystem _spriteTree = default!;
 
         private SpriteBoundsOverlay? _overlay;
 
@@ -42,7 +40,7 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     DebugTools.AssertNull(_overlay);
-                    _overlay = new SpriteBoundsOverlay(_spriteTree, _xformSystem);
+                    _overlay = new SpriteBoundsOverlay(EntityManager);
                     _overlayManager.AddOverlay(_overlay);
                 }
                 else
@@ -57,18 +55,13 @@ namespace Robust.Client.GameObjects
         private bool _enabled;
     }
 
-    public sealed class SpriteBoundsOverlay : Overlay
+    public sealed class SpriteBoundsOverlay(IEntityManager entMan) : Overlay
     {
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        private readonly SharedTransformSystem _xformSystem;
-        private SpriteTreeSystem _renderTree;
-
-        public SpriteBoundsOverlay(SpriteTreeSystem renderTree, SharedTransformSystem xformSystem)
-        {
-            _renderTree = renderTree;
-            _xformSystem = xformSystem;
-        }
+        private readonly SharedTransformSystem _xformSystem = entMan.System<SharedTransformSystem>();
+        private readonly SpriteSystem _spriteSystem = entMan.System<SpriteSystem>();
+        private readonly SpriteTreeSystem _renderTree = entMan.System<SpriteTreeSystem>();
 
         protected internal override void Draw(in OverlayDrawArgs args)
         {
@@ -76,10 +69,11 @@ namespace Robust.Client.GameObjects
             var currentMap = args.MapId;
             var viewport = args.WorldBounds;
 
-            foreach (var (sprite, xform) in _renderTree.QueryAabb(currentMap, viewport))
+            foreach (var entry in _renderTree.QueryAabb(currentMap, viewport))
             {
+                var (sprite, xform) = entry;
                 var (worldPos, worldRot) = _xformSystem.GetWorldPositionRotation(xform);
-                var bounds = sprite.CalculateRotatedBoundingBox(worldPos, worldRot, args.Viewport.Eye?.Rotation ?? default);
+                var bounds = _spriteSystem.CalculateBounds((entry.Uid, sprite), worldPos, worldRot, args.Viewport.Eye?.Rotation ?? default);
 
                 // Get scaled down bounds used to indicate the "south" of a sprite.
                 var localBound = bounds.Box;

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -14,7 +14,9 @@ namespace Robust.Client.GameObjects
         private EntityQuery<AnimationPlayerComponent> _playerQuery;
         private EntityQuery<MetaDataComponent> _metaQuery;
 
+#pragma warning disable CS0414
         [Dependency] private readonly IComponentFactory _compFact = default!;
+#pragma warning restore CS0414
 
         public override void Initialize()
         {
@@ -95,7 +97,7 @@ namespace Robust.Client.GameObjects
         [Obsolete("Use Play(EntityUid<AnimationPlayerComponent> ent, Animation animation, string key) instead")]
         public void Play(EntityUid uid, AnimationPlayerComponent? component, Animation animation, string key)
         {
-            component ??= EntityManager.EnsureComponent<AnimationPlayerComponent>(uid);
+            component ??= EnsureComp<AnimationPlayerComponent>(uid);
             Play(new Entity<AnimationPlayerComponent>(uid, component), animation, key);
         }
 
@@ -156,7 +158,7 @@ namespace Robust.Client.GameObjects
 
         public bool HasRunningAnimation(EntityUid uid, string key)
         {
-            return EntityManager.TryGetComponent(uid, out AnimationPlayerComponent? component) &&
+            return TryComp(uid, out AnimationPlayerComponent? component) &&
                    component.PlayingAnimations.ContainsKey(key);
         }
 

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -1,15 +1,14 @@
-using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Robust.Shared.Collections;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
-using Robust.Shared.Utility;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using Robust.Shared.Serialization;
+using Robust.Shared.Utility;
 using static Robust.Shared.Containers.ContainerManagerComponent;
 
 namespace Robust.Client.GameObjects
@@ -58,7 +57,7 @@ namespace Robust.Client.GameObjects
             if (!RemoveExpectedEntity(meta.NetEntity, out var container))
                 return;
 
-            Insert((uid, TransformQuery.GetComponent(uid), MetaQuery.GetComponent(uid), null), container);
+            Insert((uid, TransformQuery.GetComponent(uid), MetaQuery.GetComponent(uid), null), container, force: true);
         }
 
         public override void ShutdownContainer(BaseContainer container)
@@ -232,7 +231,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            Insert(message.Entity, container);
+            Insert(message.Entity, container, force: true);
         }
 
         public void AddExpectedEntity(NetEntity netEntity, BaseContainer container)

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -223,12 +223,12 @@ namespace Robust.Client.GameObjects
 
         private void SetEntityContextActive(IInputManager inputMan, EntityUid entity)
         {
-            if(entity == default || !EntityManager.EntityExists(entity))
+            if(entity == default || !Exists(entity))
                 throw new ArgumentNullException(nameof(entity));
 
-            if (!EntityManager.TryGetComponent(entity, out InputComponent? inputComp))
+            if (!TryComp(entity, out InputComponent? inputComp))
             {
-                _sawmillInputContext.Debug($"AttachedEnt has no InputComponent: entId={entity}, entProto={EntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype}. Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                _sawmillInputContext.Debug($"AttachedEnt has no InputComponent: entId={entity}, entProto={Comp<MetaDataComponent>(entity).EntityPrototype}. Setting default \"{InputContextContainer.DefaultContextName}\" context...");
                 inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
                 return;
             }
@@ -239,7 +239,7 @@ namespace Robust.Client.GameObjects
             }
             else
             {
-                _sawmillInputContext.Error($"Unknown context: entId={entity}, entProto={EntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                _sawmillInputContext.Error($"Unknown context: entId={entity}, entProto={Comp<MetaDataComponent>(entity).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
                 inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
             }
         }

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -16,6 +16,7 @@ namespace Robust.Client.GameObjects
         public override void Initialize()
         {
             base.Initialize();
+            SubscribeLocalEvent<PointLightComponent, ComponentGetState>(OnLightGetState);
             SubscribeLocalEvent<PointLightComponent, ComponentInit>(HandleInit);
             SubscribeLocalEvent<PointLightComponent, ComponentHandleState>(OnLightHandleState);
         }

Robust.Client/GameObjects/EntitySystems/ShowPlayerVelocityDebugSystem.cs

@@ -51,7 +51,7 @@ public sealed class ShowPlayerVelocityDebugSystem : EntitySystem
 
         var player = _playerManager.LocalEntity;
 
-        if (player == null || !EntityManager.TryGetComponent(player.Value, out PhysicsComponent? body))
+        if (player == null || !TryComp(player.Value, out PhysicsComponent? body))
         {
             _label.Visible = false;
             return;

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Bounds.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Linq;
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Graphics.RSI;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using static Robust.Client.GameObjects.SpriteComponent;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains code related to updating a sprites bounding boxes and its position in the sprite tree.
+public sealed partial class SpriteSystem
+{
+    /// <summary>
+    /// Get a sprite's local bounding box. The returned bounds do factor in the sprite's scale but not the rotation or
+    /// offset.
+    /// </summary>
+    public Box2 GetLocalBounds(Entity<SpriteComponent> sprite)
+    {
+        if (!sprite.Comp.BoundsDirty)
+        {
+            DebugTools.Assert(sprite.Comp.Layers.All(x => !x.BoundsDirty || !x.Drawn));
+            return sprite.Comp._bounds;
+        }
+
+        var bounds = new Box2();
+        foreach (var layer in sprite.Comp.Layers)
+        {
+            if (layer.Drawn)
+                bounds = bounds.Union(GetLocalBounds(layer));
+        }
+
+        sprite.Comp._bounds = bounds.Scale(sprite.Comp.Scale);
+        sprite.Comp.BoundsDirty = false;
+        return sprite.Comp._bounds;
+    }
+
+    /// <summary>
+    /// Get a layer's local bounding box relative to its owning sprite. Unlike the sprite variant of this method, this
+    /// does account for the layer's rotation and offset.
+    /// </summary>
+    public Box2 GetLocalBounds(Layer layer)
+    {
+        if (!layer.BoundsDirty)
+        {
+            DebugTools.Assert(layer.Bounds.EqualsApprox(CalculateLocalBounds(layer)));
+            return layer.Bounds;
+        }
+
+        layer.Bounds = CalculateLocalBounds(layer);
+        layer.BoundsDirty = false;
+        return layer.Bounds;
+    }
+
+    internal Box2 CalculateLocalBounds(Layer layer)
+    {
+        var textureSize = (Vector2) layer.PixelSize / EyeManager.PixelsPerMeter;
+        var longestSide = MathF.Max(textureSize.X, textureSize.Y);
+        var longestRotatedSide = Math.Max(longestSide, (textureSize.X + textureSize.Y) / MathF.Sqrt(2));
+
+        Vector2 size;
+        var sprite = layer.Owner.Comp;
+
+        // If this layer has any form of arbitrary rotation, return a bounding box big enough to cover
+        // any possible rotation.
+        if (layer._rotation != 0)
+        {
+            size = new Vector2(longestRotatedSide, longestRotatedSide);
+            return Box2.CenteredAround(layer.Offset, size * layer._scale);
+        }
+
+        var snapToCardinals = sprite.SnapCardinals;
+        if (sprite.GranularLayersRendering && layer.RenderingStrategy != LayerRenderingStrategy.UseSpriteStrategy)
+        {
+            snapToCardinals = layer.RenderingStrategy == LayerRenderingStrategy.SnapToCardinals;
+        }
+
+        if (snapToCardinals)
+        {
+            // Snapping to cardinals only makes sense for 1-directional layers/sprites
+            DebugTools.Assert(layer._actualState == null || layer._actualState.RsiDirections == RsiDirectionType.Dir1);
+
+            // We won't know the actual direction it snaps to, so we ahve to assume the box is given by the longest side.
+            size = new Vector2(longestSide, longestSide);
+            return Box2.CenteredAround(layer.Offset, size * layer._scale);
+        }
+
+        // Build the bounding box based on how many directions the sprite has
+        size = (layer._actualState?.RsiDirections) switch
+        {
+            RsiDirectionType.Dir4 => new Vector2(longestSide, longestSide),
+            RsiDirectionType.Dir8 => new Vector2(longestRotatedSide, longestRotatedSide),
+            _ => textureSize
+        };
+
+        return Box2.CenteredAround(layer.Offset, size * layer._scale);
+    }
+
+    /// <summary>
+    /// Gets a sprite's bounding box in world coordinates.
+    /// </summary>
+    public Box2Rotated CalculateBounds(Entity<SpriteComponent> sprite, Vector2 worldPos, Angle worldRot, Angle eyeRot)
+    {
+        // fast check for invisible sprites
+        if (!sprite.Comp.Visible || sprite.Comp.Layers.Count == 0)
+            return new Box2Rotated(new Box2(worldPos, worldPos), Angle.Zero, worldPos);
+
+        // We need to modify world rotation so that it lies between 0 and 2pi.
+        // This matters for 4 or 8 directional sprites deciding which quadrant (octant?) they lie in.
+        // the 0->2pi convention is set by the sprite-rendering code that selects the layers.
+        // See RenderInternal().
+
+        worldRot = worldRot.Reduced();
+        if (worldRot.Theta < 0)
+            worldRot = new Angle(worldRot.Theta + Math.Tau);
+
+        // Next, what we do is take the box2 and apply the sprite's transform, and then the entity's transform. We
+        // could do this via Matrix3.TransformBox, but that only yields bounding boxes. So instead we manually
+        // transform our box by the combination of these matrices:
+
+        var finalRotation = sprite.Comp.NoRotation
+            ? sprite.Comp.Rotation - eyeRot
+            : sprite.Comp.Rotation + worldRot;
+
+        var bounds = GetLocalBounds(sprite);
+
+        // slightly faster path if offset == 0 (true for 99.9% of sprites)
+        if (sprite.Comp.Offset == Vector2.Zero)
+            return new Box2Rotated(bounds.Translated(worldPos), finalRotation, worldPos);
+
+        var adjustedOffset = sprite.Comp.NoRotation
+            ? (-eyeRot).RotateVec(sprite.Comp.Offset)
+            : worldRot.RotateVec(sprite.Comp.Offset);
+
+        var position = adjustedOffset + worldPos;
+        return new Box2Rotated(bounds.Translated(position), finalRotation, position);
+    }
+
+    private void DirtyBounds(Entity<SpriteComponent> sprite)
+    {
+        sprite.Comp.BoundsDirty = true;
+        foreach (var layer in sprite.Comp.Layers)
+        {
+            layer.BoundsDirty = true;
+        }
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Component.cs

@@ -1,4 +1,8 @@
-using System.Linq;
+using System;
+using System.Collections.Generic;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects;
 
@@ -41,4 +45,66 @@ public sealed partial class SpriteSystem
         layer.AnimationTimeLeft = (float) -(time % state.TotalDelay);
         layer.AnimationFrame = 0;
     }
+
+    public void CopySprite(Entity<SpriteComponent?> source, Entity<SpriteComponent?> target)
+    {
+        if (!Resolve(source.Owner, ref source.Comp))
+            return;
+
+        if (!Resolve(target.Owner, ref target.Comp))
+            return;
+
+        target.Comp._baseRsi = source.Comp._baseRsi;
+        target.Comp._bounds = source.Comp._bounds;
+        target.Comp._visible = source.Comp._visible;
+        target.Comp.color = source.Comp.color;
+        target.Comp.offset = source.Comp.offset;
+        target.Comp.rotation = source.Comp.rotation;
+        target.Comp.scale = source.Comp.scale;
+        target.Comp.LocalMatrix = Matrix3Helpers.CreateTransform(
+            in target.Comp.offset,
+            in target.Comp.rotation,
+            in target
+            .Comp.scale);
+
+        target.Comp.drawDepth = source.Comp.drawDepth;
+        target.Comp.NoRotation = source.Comp.NoRotation;
+        target.Comp.DirectionOverride = source.Comp.DirectionOverride;
+        target.Comp.EnableDirectionOverride = source.Comp.EnableDirectionOverride;
+        target.Comp.Layers = new List<SpriteComponent.Layer>(source.Comp.Layers.Count);
+        foreach (var otherLayer in source.Comp.Layers)
+        {
+            var layer = new SpriteComponent.Layer(otherLayer, target.Comp);
+            layer.Index = target.Comp.Layers.Count;
+            layer.Owner = target!;
+            target.Comp.Layers.Add(layer);
+        }
+
+        target.Comp.IsInert = source.Comp.IsInert;
+        target.Comp.LayerMap = source.Comp.LayerMap.ShallowClone();
+        target.Comp.PostShader = source.Comp.PostShader is {Mutable: true}
+            ? source.Comp.PostShader.Duplicate()
+            : source.Comp.PostShader;
+
+        target.Comp.RenderOrder = source.Comp.RenderOrder;
+        target.Comp.GranularLayersRendering = source.Comp.GranularLayersRendering;
+
+        DirtyBounds(target!);
+        _tree.QueueTreeUpdate(target!);
+    }
+
+    /// <summary>
+    /// Adds a sprite to a queue that will update <see cref="SpriteComponent.IsInert"/> next frame.
+    /// </summary>
+    public void QueueUpdateIsInert(Entity<SpriteComponent> sprite)
+    {
+        if (sprite.Comp._inertUpdateQueued)
+            return;
+
+        sprite.Comp._inertUpdateQueued = true;
+        _inertUpdateQueue.Enqueue(sprite);
+    }
+
+    [Obsolete("Use QueueUpdateIsInert")]
+    public void QueueUpdateInert(EntityUid uid, SpriteComponent sprite) => QueueUpdateIsInert(new (uid, sprite));
 }

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Helpers.cs

@@ -1,11 +1,208 @@
+using System;
+using System.Collections.Generic;
 using System.Numerics;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects;
 
+// This partial class contains various public helper methods, including methods for extracting textures/icons from
+// sprite specifiers and entity prototypes.
 public sealed partial class SpriteSystem
 {
+    private readonly Dictionary<string, IRsiStateLike> _cachedPrototypeIcons = new();
+
+    public Texture Frame0(EntityPrototype prototype)
+    {
+        return GetPrototypeIcon(prototype).Default;
+    }
+
+    public Texture Frame0(SpriteSpecifier specifier)
+    {
+        return RsiStateLike(specifier).Default;
+    }
+
+    public IRsiStateLike RsiStateLike(SpriteSpecifier specifier)
+    {
+        switch (specifier)
+        {
+            case SpriteSpecifier.Texture tex:
+                return GetTexture(tex);
+
+            case SpriteSpecifier.Rsi rsi:
+                return GetState(rsi);
+
+            case SpriteSpecifier.EntityPrototype prototypeIcon:
+                return GetPrototypeIcon(prototypeIcon.EntityPrototypeId);
+
+            default:
+                throw new NotSupportedException();
+        }
+    }
+
+    public Texture GetIcon(IconComponent icon)
+    {
+        return GetState(icon.Icon).Frame0;
+    }
+
+    /// <summary>
+    ///     Returns an icon for a given <see cref="EntityPrototype"/> ID, or a fallback in case of an error.
+    ///     This method caches the result based on the prototype identifier.
+    /// </summary>
+    public IRsiStateLike GetPrototypeIcon(string prototype)
+    {
+        if (!_proto.TryIndex<EntityPrototype>(prototype, out var entityPrototype))
+        {
+            // The specified prototype doesn't exist, return the fallback "error" sprite.
+            _sawmill.Error("Failed to load PrototypeIcon {0}", prototype);
+            return GetFallbackState();
+        }
+
+        return GetPrototypeIcon(entityPrototype);
+    }
+
+    /// <summary>
+    ///     Returns an icon for a given <see cref="EntityPrototype"/> ID, or a fallback in case of an error.
+    ///     This method does NOT cache the result.
+    /// </summary>
+    public IRsiStateLike GetPrototypeIcon(EntityPrototype prototype)
+    {
+        // This method may spawn & delete an entity to get an accruate RSI state, hence we cache the results
+        if (_cachedPrototypeIcons.TryGetValue(prototype.ID, out var cachedResult))
+            return cachedResult;
+
+        return _cachedPrototypeIcons[prototype.ID] = GetPrototypeIconInternal(prototype);
+    }
+
+    private IRsiStateLike GetPrototypeIconInternal(EntityPrototype prototype)
+    {
+        // IconComponent takes precedence. If it has a valid icon, return that. Otherwise, continue as normal.
+        if (prototype.TryGetComponent(out IconComponent? icon, _factory))
+            return GetIcon(icon);
+
+        // If the prototype doesn't have a SpriteComponent, then there's nothing we can do but return the fallback.
+        if (!prototype.Components.ContainsKey("Sprite"))
+        {
+            return GetFallbackState();
+        }
+
+        // Finally, we use spawn a dummy entity to get its icon.
+        var dummy = Spawn(prototype.ID, MapCoordinates.Nullspace);
+        var spriteComponent = EnsureComp<SpriteComponent>(dummy);
+        var result = spriteComponent.Icon ?? GetFallbackState();
+        Del(dummy);
+
+        return result;
+    }
+
+    public IEnumerable<IDirectionalTextureProvider> GetPrototypeTextures(EntityPrototype proto) =>
+        GetPrototypeTextures(proto, out _);
+
+    public IEnumerable<IDirectionalTextureProvider> GetPrototypeTextures(EntityPrototype proto, out bool noRot)
+    {
+        var results = new List<IDirectionalTextureProvider>();
+        noRot = false;
+
+        if (proto.TryGetComponent(out IconComponent? icon, _factory))
+        {
+            results.Add(GetIcon(icon));
+            return results;
+        }
+
+        if (!proto.Components.ContainsKey("Sprite"))
+        {
+            results.Add(_resourceCache.GetFallback<TextureResource>().Texture);
+            return results;
+        }
+
+        var dummy = Spawn(proto.ID, MapCoordinates.Nullspace);
+        var spriteComponent = EnsureComp<SpriteComponent>(dummy);
+
+        // TODO SPRITE is this needed?
+        // And if it is, shouldn't GetPrototypeIconInternal also use this?
+        _appearance.OnChangeData(dummy, spriteComponent);
+
+        foreach (var layer in spriteComponent.AllLayers)
+        {
+            if (!layer.Visible)
+                continue;
+
+            if (layer.Texture != null)
+            {
+                results.Add(layer.Texture);
+                continue;
+            }
+
+            if (!layer.RsiState.IsValid)
+                continue;
+
+            var rsi = layer.Rsi ?? spriteComponent.BaseRSI;
+            if (rsi == null || !rsi.TryGetState(layer.RsiState, out var state))
+                continue;
+
+            results.Add(state);
+        }
+
+        noRot = spriteComponent.NoRotation;
+        Del(dummy);
+
+        if (results.Count == 0)
+            results.Add(_resourceCache.GetFallback<TextureResource>().Texture);
+
+        return results;
+    }
+
+    [Pure]
+    public RSI.State GetFallbackState()
+    {
+        return _resourceCache.GetFallback<RSIResource>().RSI["error"];
+    }
+
+    public Texture GetFallbackTexture()
+    {
+        return _resourceCache.GetFallback<TextureResource>().Texture;
+    }
+
+    [Pure]
+    public RSI.State GetState(SpriteSpecifier.Rsi rsiSpecifier)
+    {
+        if (_resourceCache.TryGetResource<RSIResource>(
+                TextureRoot / rsiSpecifier.RsiPath,
+                out var theRsi) &&
+            theRsi.RSI.TryGetState(rsiSpecifier.RsiState, out var state))
+        {
+            return state;
+        }
+
+        _sawmill.Error("Failed to load RSI {0}", rsiSpecifier.RsiPath);
+        return GetFallbackState();
+    }
+
+    public Texture GetTexture(SpriteSpecifier.Texture texSpecifier)
+    {
+        return _resourceCache
+            .GetResource<TextureResource>(TextureRoot / texSpecifier.TexturePath)
+            .Texture;
+    }
+
+    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
+    {
+        if (!args.TryGetModified<EntityPrototype>(out var modified))
+            return;
+
+        // Remove all changed prototypes from the cache, if they're there.
+        foreach (var prototype in modified)
+        {
+            // Let's be lazy and not regenerate them until something needs them again.
+            _cachedPrototypeIcons.Remove(prototype);
+        }
+    }
+
     /// <summary>
     /// Gets an entity's sprite position in world terms.
     /// </summary>

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Layer.cs

@@ -0,0 +1,257 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Utility;
+using static Robust.Client.GameObjects.SpriteComponent;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains various public methods for managing a sprite's layers.
+// This setter methods for modifying a layer's properties are in a separate file.
+public sealed partial class SpriteSystem
+{
+    public bool LayerExists(Entity<SpriteComponent?> sprite, int index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return false;
+
+        return index > 0 && index < sprite.Comp.Layers.Count;
+    }
+
+    public bool TryGetLayer(
+        Entity<SpriteComponent?> sprite,
+        int index,
+        [NotNullWhen(true)] out Layer? layer,
+        bool logMissing)
+    {
+        layer = null;
+
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (index >= 0 && index < sprite.Comp.Layers.Count)
+        {
+            layer = sprite.Comp.Layers[index];
+            DebugTools.AssertEqual(layer.Owner, sprite!);
+            DebugTools.AssertEqual(layer.Index, index);
+            return true;
+        }
+
+        if (logMissing)
+            Log.Error($"Layer index '{index}' on entity {ToPrettyString(sprite)} does not exist! Trace:\n{Environment.StackTrace}");
+
+        return false;
+    }
+
+    public bool RemoveLayer(Entity<SpriteComponent?> sprite, int index, bool logMissing = true)
+    {
+        return RemoveLayer(sprite.Owner, index, out _, logMissing);
+    }
+
+    public bool RemoveLayer(
+        Entity<SpriteComponent?> sprite,
+        int index,
+        [NotNullWhen(true)] out Layer? layer,
+        bool logMissing = true)
+    {
+        layer = null;
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (!TryGetLayer(sprite, index, out layer, logMissing))
+            return false;
+
+        sprite.Comp.Layers.RemoveAt(index);
+
+        foreach (var otherLayer in sprite.Comp.Layers[index..])
+        {
+            otherLayer.Index--;
+        }
+
+        // TODO SPRITE track inverse-mapping?
+        foreach (var (key, value) in sprite.Comp.LayerMap)
+        {
+            if (value == index)
+                sprite.Comp.LayerMap.Remove(key);
+            else if (value > index)
+            {
+                sprite.Comp.LayerMap[key]--;
+            }
+        }
+
+        layer.Owner = default;
+        layer.Index = -1;
+
+#if DEBUG
+        foreach (var otherLayer in sprite.Comp.Layers)
+        {
+            DebugTools.AssertEqual(otherLayer, sprite.Comp.Layers[otherLayer.Index]);
+        }
+#endif
+
+        sprite.Comp.BoundsDirty = true;
+        _tree.QueueTreeUpdate(sprite!);
+        QueueUpdateIsInert(sprite!);
+        return true;
+    }
+
+    #region AddLayer
+
+    /// <summary>
+    /// Add the given sprite layer. If an index is specified, this will insert the layer with the given index, resulting
+    /// in all other layers being reshuffled.
+    /// </summary>
+    public int AddLayer(Entity<SpriteComponent?> sprite, Layer layer, int? index = null)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+        {
+            layer.Index = -1;
+            layer.Owner = default;
+            return -1;
+        }
+
+        layer.Owner = sprite!;
+
+        if (index is { } i && i != sprite.Comp.Layers.Count)
+        {
+            foreach (var otherLayer in sprite.Comp.Layers[i..])
+            {
+                otherLayer.Index++;
+            }
+
+            // TODO SPRITE track inverse-mapping?
+            sprite.Comp.Layers.Insert(i, layer);
+            layer.Index = i;
+
+            foreach (var (key, value) in sprite.Comp.LayerMap)
+            {
+                if (value >= i)
+                    sprite.Comp.LayerMap[key]++;
+            }
+        }
+        else
+        {
+            layer.Index = sprite.Comp.Layers.Count;
+            sprite.Comp.Layers.Add(layer);
+        }
+
+#if DEBUG
+        foreach (var otherLayer in sprite.Comp.Layers)
+        {
+            DebugTools.AssertEqual(otherLayer, sprite.Comp.Layers[otherLayer.Index]);
+        }
+#endif
+
+        layer.BoundsDirty = true;
+        if (!layer.Blank)
+        {
+            sprite.Comp.BoundsDirty = true;
+            _tree.QueueTreeUpdate(sprite!);
+            QueueUpdateIsInert(sprite!);
+        }
+        return layer.Index;
+    }
+
+    /// <summary>
+    /// Add a layer corresponding to the given RSI state.
+    /// </summary>
+    /// <param name="sprite">The sprite</param>
+    /// <param name="stateId">The RSI state</param>
+    /// <param name="rsi">The RSI to use. If not specified, it will default to using <see cref="SpriteComponent.BaseRSI"/></param>
+    /// <param name="index">The layer index to use for the new sprite.</param>
+    /// <returns></returns>
+    public int AddRsiLayer(Entity<SpriteComponent?> sprite, RSI.StateId stateId, RSI? rsi = null, int? index = null)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        var layer = AddBlankLayer(sprite!, index);
+
+        if (rsi != null)
+            LayerSetRsi(layer, rsi, stateId);
+        else
+            LayerSetRsiState(layer, stateId);
+
+        return layer.Index;
+    }
+
+    /// <summary>
+    /// Add a layer corresponding to the given RSI state.
+    /// </summary>
+    /// <param name="sprite">The sprite</param>
+    /// <param name="state">The RSI state</param>
+    /// <param name="path">The path to the RSI.</param>
+    /// <param name="index">The layer index to use for the new sprite.</param>
+    /// <returns></returns>
+    public int AddRsiLayer(Entity<SpriteComponent?> sprite, RSI.StateId state, ResPath path, int? index = null)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        if (!_resourceCache.TryGetResource<RSIResource>(TextureRoot / path, out var res))
+            Log.Error($"Unable to load RSI '{path}'. Trace:\n{Environment.StackTrace}");
+
+        if (path.Extension != "rsi")
+            Log.Error($"Expected rsi path but got '{path}'?");
+
+        return AddRsiLayer(sprite, state, res?.RSI, index);
+    }
+
+    public int AddTextureLayer(Entity<SpriteComponent?> sprite, ResPath path, int? index = null)
+    {
+        if (_resourceCache.TryGetResource<TextureResource>(TextureRoot / path, out var texture))
+            return AddTextureLayer(sprite, texture?.Texture, index);
+
+        if (path.Extension == "rsi")
+            Log.Error($"Expected texture but got rsi '{path}', did you mean 'sprite:' instead of 'texture:'?");
+
+        Log.Error($"Unable to load texture '{path}'. Trace:\n{Environment.StackTrace}");
+        return AddTextureLayer(sprite, texture?.Texture, index);
+    }
+
+    public int AddTextureLayer(Entity<SpriteComponent?> sprite, Texture? texture, int? index = null)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        var layer = new Layer {Texture = texture};
+        return AddLayer(sprite, layer, index);
+    }
+
+    public int AddLayer(Entity<SpriteComponent?> sprite, SpriteSpecifier specifier, int? newIndex = null)
+    {
+        return specifier switch
+        {
+            SpriteSpecifier.Texture tex => AddTextureLayer(sprite, tex.TexturePath, newIndex),
+            SpriteSpecifier.Rsi rsi => AddRsiLayer(sprite, rsi.RsiState, rsi.RsiPath, newIndex),
+            _ => throw new NotImplementedException()
+        };
+    }
+
+    /// <summary>
+    /// Add a new sprite layer and populate it using the provided layer data.
+    /// </summary>
+    public int AddLayer(Entity<SpriteComponent?> sprite, PrototypeLayerData layerDatum, int? index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        var layer = AddBlankLayer(sprite!, index);
+        LayerSetData(layer, layerDatum);
+        return layer.Index;
+    }
+
+    /// <summary>
+    /// Add a blank sprite layer.
+    /// </summary>
+    public Layer AddBlankLayer(Entity<SpriteComponent> sprite, int? index = null)
+    {
+        var layer = new Layer();
+        AddLayer(sprite!, layer, index);
+        return layer;
+    }
+
+    #endregion
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.LayerGetters.cs

@@ -0,0 +1,150 @@
+using System;
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Graphics.RSI;
+using static Robust.Client.GameObjects.SpriteComponent;
+using static Robust.Client.Graphics.RSI;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains various public methods for reading a layer's properties
+public sealed partial class SpriteSystem
+{
+    #region RsiState
+
+    /// <summary>
+    /// Get the RSI state being used by the current layer. Note that the return value may be an invalid state. E.g.,
+    /// this might be a texture layer that does not use RSIs.
+    /// </summary>
+    public StateId LayerGetRsiState(Entity<SpriteComponent?> sprite, int index)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            return layer.StateId;
+
+        return StateId.Invalid;
+    }
+
+    /// <summary>
+    /// Get the RSI state being used by the current layer. Note that the return value may be an invalid state. E.g.,
+    /// this might be a texture layer that does not use RSIs.
+    /// </summary>
+    public StateId LayerGetRsiState(Entity<SpriteComponent?> sprite, string key, StateId state)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            return layer.StateId;
+
+        return StateId.Invalid;
+    }
+
+    /// <summary>
+    /// Get the RSI state being used by the current layer. Note that the return value may be an invalid state. E.g.,
+    /// this might be a texture layer that does not use RSIs.
+    /// </summary>
+    public StateId LayerGetRsiState(Entity<SpriteComponent?> sprite, Enum key, StateId state)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            return layer.StateId;
+
+        return StateId.Invalid;
+    }
+
+    #endregion
+
+    #region RsiState
+
+    /// <summary>
+    /// Returns the RSI being used by the layer to resolve it's RSI state. If the layer does not specify an RSI, this
+    /// will just be the base RSI of the owning sprite (<see cref="SpriteComponent.BaseRSI"/>).
+    /// </summary>
+    public RSI? LayerGetEffectiveRsi(Entity<SpriteComponent?> sprite, int index)
+    {
+        TryGetLayer(sprite, index, out var layer, true);
+        return layer?.ActualRsi;
+    }
+
+    /// <summary>
+    /// Returns the RSI being used by the layer to resolve it's RSI state. If the layer does not specify an RSI, this
+    /// will just be the base RSI of the owning sprite (<see cref="SpriteComponent.BaseRSI"/>).
+    /// </summary>
+    public RSI? LayerGetEffectiveRsi(Entity<SpriteComponent?> sprite, string key, StateId state)
+    {
+        TryGetLayer(sprite, key, out var layer, true);
+        return layer?.ActualRsi;
+    }
+
+    /// <summary>
+    /// Returns the RSI being used by the layer to resolve it's RSI state. If the layer does not specify an RSI, this
+    /// will just be the base RSI of the owning sprite (<see cref="SpriteComponent.BaseRSI"/>).
+    /// </summary>
+    public RSI? LayerGetEffectiveRsi(Entity<SpriteComponent?> sprite, Enum key, StateId state)
+    {
+        TryGetLayer(sprite, key, out var layer, true);
+        return layer?.ActualRsi;
+    }
+
+    #endregion
+
+    #region Directions
+
+    public RsiDirectionType LayerGetDirections(Entity<SpriteComponent?> sprite, int index)
+    {
+        return TryGetLayer(sprite, index, out var layer, true)
+            ? LayerGetDirections(layer)
+            : RsiDirectionType.Dir1;
+    }
+
+
+    public RsiDirectionType LayerGetDirections(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        return TryGetLayer(sprite, key, out var layer, true)
+            ? LayerGetDirections(layer)
+            : RsiDirectionType.Dir1;
+    }
+
+    public RsiDirectionType LayerGetDirections(Entity<SpriteComponent?> sprite, string key)
+    {
+        return TryGetLayer(sprite, key, out var layer, true)
+            ? LayerGetDirections(layer)
+            : RsiDirectionType.Dir1;
+    }
+
+    public RsiDirectionType LayerGetDirections(Layer layer)
+    {
+        if (!layer.StateId.IsValid)
+            return RsiDirectionType.Dir1;
+
+        // Pull texture from RSI state instead.
+        if (layer.ActualRsi is not {} rsi || !rsi.TryGetState(layer.StateId, out var state))
+            return RsiDirectionType.Dir1;
+
+        return state.RsiDirections;
+    }
+
+    public int LayerGetDirectionCount(Entity<SpriteComponent?> sprite, int index)
+    {
+        return TryGetLayer(sprite, index, out var layer, true) ? LayerGetDirectionCount(layer) : 1;
+    }
+
+    public int LayerGetDirectionCount(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        return TryGetLayer(sprite, key, out var layer, true) ? LayerGetDirectionCount(layer) : 1;
+    }
+
+    public int LayerGetDirectionCount(Entity<SpriteComponent?> sprite, string key)
+    {
+        return TryGetLayer(sprite, key, out var layer, true) ? LayerGetDirectionCount(layer) : 1;
+    }
+
+    public int LayerGetDirectionCount(Layer layer)
+    {
+        return LayerGetDirections(layer) switch
+        {
+            RsiDirectionType.Dir1 => 1,
+            RsiDirectionType.Dir4 => 4,
+            RsiDirectionType.Dir8 => 8,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+    }
+
+    #endregion
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.LayerMap.cs

@@ -0,0 +1,299 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Robust.Shared.GameObjects;
+using static Robust.Client.GameObjects.SpriteComponent;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains various public methods for manipulating layer mappings.
+public sealed partial class SpriteSystem
+{
+    /// <summary>
+    /// Map an enum to a layer index.
+    /// </summary>
+    public void LayerMapSet(Entity<SpriteComponent?> sprite, Enum key, int index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (index < 0 || index >= sprite.Comp.Layers.Count)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        sprite.Comp.LayerMap[key] = index;
+    }
+
+    /// <summary>
+    /// Map string to a layer index. If possible, it is preferred to use an enum key.
+    /// string keys mainly exist to make it easier to define custom layer keys in yaml.
+    /// </summary>
+    public void LayerMapSet(Entity<SpriteComponent?> sprite, string key, int index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (index < 0 || index >= sprite.Comp.Layers.Count)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        sprite.Comp.LayerMap[key] = index;
+    }
+
+    /// <summary>
+    /// Map an enum to a layer index.
+    /// </summary>
+    public void LayerMapAdd(Entity<SpriteComponent?> sprite, Enum key, int index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (index < 0 || index >= sprite.Comp.Layers.Count)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        sprite.Comp.LayerMap.Add(key, index);
+    }
+
+    /// <summary>
+    /// Map a string to a layer index. If possible, it is preferred to use an enum key.
+    /// string keys mainly exist to make it easier to define custom layer keys in yaml.
+    /// </summary>
+    public void LayerMapAdd(Entity<SpriteComponent?> sprite, string key, int index)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (index < 0 || index >= sprite.Comp.Layers.Count)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        sprite.Comp.LayerMap.Add(key, index);
+    }
+
+    /// <summary>
+    /// Remove an enum mapping.
+    /// </summary>
+    public bool LayerMapRemove(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return false;
+
+        return sprite.Comp.LayerMap.Remove(key);
+    }
+
+    /// <summary>
+    /// Remove a string mapping.
+    /// </summary>
+    public bool LayerMapRemove(Entity<SpriteComponent?> sprite, string key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return false;
+
+        return sprite.Comp.LayerMap.Remove(key);
+    }
+
+    /// <summary>
+    /// Remove an enum mapping.
+    /// </summary>
+    public bool LayerMapRemove(Entity<SpriteComponent?> sprite, Enum key, out int index)
+    {
+        if (_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return sprite.Comp.LayerMap.Remove(key, out index);
+
+        index = 0;
+        return false;
+    }
+
+    /// <summary>
+    /// Remove a string mapping.
+    /// </summary>
+    public bool LayerMapRemove(Entity<SpriteComponent?> sprite, string key, out int index)
+    {
+        if (_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return sprite.Comp.LayerMap.Remove(key, out index);
+
+        index = 0;
+        return false;
+    }
+
+    /// <summary>
+    /// Attempt to resolve an enum mapping.
+    /// </summary>
+    public bool LayerMapTryGet(Entity<SpriteComponent?> sprite, Enum key, out int index, bool logMissing)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+        {
+            index = 0;
+            return false;
+        }
+
+        if (sprite.Comp.LayerMap.TryGetValue(key, out index))
+            return true;
+
+        if (logMissing)
+            Log.Error($"Layer with key '{key}' does not exist on entity {ToPrettyString(sprite)}! Trace:\n{Environment.StackTrace}");
+
+        return false;
+    }
+
+    /// <summary>
+    /// Attempt to resolve a string mapping.
+    /// </summary>
+    public bool LayerMapTryGet(Entity<SpriteComponent?> sprite, string key, out int index, bool logMissing)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+        {
+            index = 0;
+            return false;
+        }
+
+        if (sprite.Comp.LayerMap.TryGetValue(key, out index))
+            return true;
+
+        if (logMissing)
+            Log.Error($"Layer with key '{key}' does not exist on entity {ToPrettyString(sprite)}! Trace:\n{Environment.StackTrace}");
+
+        return false;
+    }
+
+    /// <summary>
+    /// Attempt to resolve an enum mapping.
+    /// </summary>
+    public bool TryGetLayer(Entity<SpriteComponent?> sprite, Enum key, [NotNullWhen(true)] out Layer? layer, bool logMissing)
+    {
+        layer = null;
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        return LayerMapTryGet(sprite, key, out var index, logMissing)
+               && TryGetLayer(sprite, index, out layer, logMissing);
+    }
+
+    /// <summary>
+    /// Attempt to resolve a string mapping.
+    /// </summary>
+    public bool TryGetLayer(Entity<SpriteComponent?> sprite, string key, [NotNullWhen(true)] out Layer? layer, bool logMissing)
+    {
+        layer = null;
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        return LayerMapTryGet(sprite, key, out var index, logMissing)
+               && TryGetLayer(sprite, index, out layer, logMissing);
+    }
+
+    public int LayerMapGet(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        return sprite.Comp.LayerMap[key];
+    }
+
+    public int LayerMapGet(Entity<SpriteComponent?> sprite, string key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        return sprite.Comp.LayerMap[key];
+    }
+
+    public bool LayerExists(Entity<SpriteComponent?> sprite, string key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return false;
+
+        return sprite.Comp.LayerMap.TryGetValue(key, out var index)
+               && LayerExists(sprite, index);
+    }
+
+    public bool LayerExists(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return false;
+
+        return sprite.Comp.LayerMap.TryGetValue(key, out var index)
+               && LayerExists(sprite, index);
+    }
+
+    /// <summary>
+    /// Ensures that a layer with the given key exists and return the layer's index.
+    /// If the layer does not yet exist, this will create and add a blank layer.
+    /// </summary>
+    public int LayerMapReserve(Entity<SpriteComponent?> sprite, Enum key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        if (LayerMapTryGet(sprite, key, out var layerIndex, false))
+            return layerIndex;
+
+        var layer = AddBlankLayer(sprite!);
+        LayerMapSet(sprite, key, layer.Index);
+        return layer.Index;
+    }
+
+    /// <inheritdoc cref="LayerMapReserve(Entity{SpriteComponent?},System.Enum)"/>
+    public int LayerMapReserve(Entity<SpriteComponent?> sprite, string key)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return -1;
+
+        if (LayerMapTryGet(sprite, key, out var layerIndex, false))
+            return layerIndex;
+
+        var layer = AddBlankLayer(sprite!);
+        LayerMapSet(sprite, key, layer.Index);
+        return layer.Index;
+    }
+
+    public bool RemoveLayer(Entity<SpriteComponent?> sprite, string key, bool logMissing = true)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (!LayerMapTryGet(sprite, key, out var index, logMissing))
+            return false;
+
+        return RemoveLayer(sprite, index, logMissing);
+    }
+
+    public bool RemoveLayer(Entity<SpriteComponent?> sprite, Enum key, bool logMissing = true)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (!LayerMapTryGet(sprite, key, out var index, logMissing))
+            return false;
+
+        return RemoveLayer(sprite, index, logMissing);
+    }
+
+    public bool RemoveLayer(
+        Entity<SpriteComponent?> sprite,
+        string key,
+        [NotNullWhen(true)] out Layer? layer,
+        bool logMissing = true)
+    {
+        layer = null;
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (!LayerMapTryGet(sprite, key, out var index, logMissing))
+            return false;
+
+        return RemoveLayer(sprite, index, out layer, logMissing);
+    }
+
+    public bool RemoveLayer(
+        Entity<SpriteComponent?> sprite,
+        Enum key,
+        [NotNullWhen(true)] out Layer? layer,
+        bool logMissing = true)
+    {
+        layer = null;
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp, logMissing))
+            return false;
+
+        if (!LayerMapTryGet(sprite, key, out var index, logMissing))
+            return false;
+
+        return RemoveLayer(sprite, index, out layer, logMissing);
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.LayerSetters.cs

@@ -0,0 +1,605 @@
+using System;
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using static Robust.Client.GameObjects.SpriteComponent;
+using static Robust.Client.Graphics.RSI;
+
+#pragma warning disable CS0618 // Type or member is obsolete
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains various public methods for modifying a layer's properties.
+public sealed partial class SpriteSystem
+{
+    #region SetData
+
+    public void LayerSetData(Entity<SpriteComponent?> sprite, int index, PrototypeLayerData data)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetData(layer, data);
+    }
+
+    public void LayerSetData(Entity<SpriteComponent?> sprite, string key, PrototypeLayerData data)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetData(layer, data);
+    }
+
+    public void LayerSetData(Entity<SpriteComponent?> sprite, Enum key, PrototypeLayerData data)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetData(layer, data);
+    }
+
+    public void LayerSetData(Layer layer, PrototypeLayerData data)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+        // TODO SPRITE ECS
+        layer._parent.LayerSetData(layer, data);
+    }
+
+    #endregion
+
+    #region SpriteSpecifier
+
+    public void LayerSetSprite(Entity<SpriteComponent?> sprite, int index, SpriteSpecifier specifier)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetSprite(layer, specifier);
+    }
+
+    public void LayerSetSprite(Entity<SpriteComponent?> sprite, string key, SpriteSpecifier specifier)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetSprite(layer, specifier);
+    }
+
+    public void LayerSetSprite(Entity<SpriteComponent?> sprite, Enum key, SpriteSpecifier specifier)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetSprite(layer, specifier);
+    }
+
+    public void LayerSetSprite(Layer layer, SpriteSpecifier specifier)
+    {
+        switch (specifier)
+        {
+            case SpriteSpecifier.Texture tex:
+                LayerSetTexture(layer, tex.TexturePath);
+                break;
+
+            case SpriteSpecifier.Rsi rsi:
+                LayerSetRsi(layer, rsi.RsiPath, rsi.RsiState);
+                break;
+
+            default:
+                throw new NotImplementedException();
+        }
+    }
+
+    #endregion
+
+    #region Texture
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, int index, Texture? texture)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetTexture(layer, texture);
+    }
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, string key, Texture? texture)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetTexture(layer, texture);
+    }
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, Enum key, Texture? texture)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetTexture(layer, texture);
+    }
+
+    public void LayerSetTexture(Layer layer, Texture? texture)
+    {
+        LayerSetRsiState(layer, StateId.Invalid, refresh: true);
+        layer.Texture = texture;
+    }
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, int index, ResPath path)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetTexture(layer, path);
+    }
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, string key, ResPath path)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetTexture(layer, path);
+    }
+
+    public void LayerSetTexture(Entity<SpriteComponent?> sprite, Enum key, ResPath path)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetTexture(layer, path);
+    }
+
+    private void LayerSetTexture(Layer layer, ResPath path)
+    {
+        if (!_resourceCache.TryGetResource<TextureResource>(TextureRoot / path, out var texture))
+        {
+            if (path.Extension == "rsi")
+                Log.Error($"Expected texture but got rsi '{path}', did you mean 'sprite:' instead of 'texture:'?");
+            Log.Error($"Unable to load texture '{path}'. Trace:\n{Environment.StackTrace}");
+        }
+
+        LayerSetTexture(layer, texture?.Texture);
+    }
+
+    #endregion
+
+    #region RsiState
+
+    public void LayerSetRsiState(Entity<SpriteComponent?> sprite, int index, StateId state)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetRsiState(layer, state);
+    }
+
+    public void LayerSetRsiState(Entity<SpriteComponent?> sprite, string key, StateId state)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsiState(layer, state);
+    }
+
+    public void LayerSetRsiState(Entity<SpriteComponent?> sprite, Enum key, StateId state)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsiState(layer, state);
+    }
+
+    public void LayerSetRsiState(Layer layer, StateId state, bool refresh = false)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer.StateId == state && !refresh)
+            return;
+
+        layer.StateId = state;
+        RefreshCachedState(layer, true, null);
+        _tree.QueueTreeUpdate(layer.Owner);
+        QueueUpdateIsInert(layer.Owner);
+        layer.BoundsDirty = true;
+        layer.Owner.Comp.BoundsDirty = true;
+    }
+
+    #endregion
+
+    #region Rsi
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, int index, RSI? rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, string key, RSI? rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, Enum key, RSI? rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Layer layer, RSI? rsi, StateId? state = null)
+    {
+        layer._rsi = rsi;
+        LayerSetRsiState(layer, state ?? layer.StateId, refresh: true);
+    }
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, int index, ResPath rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, string key, ResPath rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Entity<SpriteComponent?> sprite, Enum key, ResPath rsi, StateId? state = null)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRsi(layer, rsi, state);
+    }
+
+    public void LayerSetRsi(Layer layer, ResPath rsi, StateId? state = null)
+    {
+        if (!_resourceCache.TryGetResource<RSIResource>(TextureRoot / rsi, out var res))
+            Log.Error($"Unable to load RSI '{rsi}' for entity {ToPrettyString(layer.Owner)}. Trace:\n{Environment.StackTrace}");
+
+        LayerSetRsi(layer, res?.RSI, state);
+    }
+
+    #endregion
+
+    #region Scale
+
+    public void LayerSetScale(Entity<SpriteComponent?> sprite, int index, Vector2 value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetScale(layer, value);
+    }
+
+    public void LayerSetScale(Entity<SpriteComponent?> sprite, string key, Vector2 value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetScale(layer, value);
+    }
+
+    public void LayerSetScale(Entity<SpriteComponent?> sprite, Enum key, Vector2 value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetScale(layer, value);
+    }
+
+    public void LayerSetScale(Layer layer, Vector2 value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer._scale.EqualsApprox(value))
+            return;
+
+        if (!ValidateScale(layer.Owner, value))
+            return;
+
+        layer._scale = value;
+        layer.UpdateLocalMatrix();
+        _tree.QueueTreeUpdate(layer.Owner);
+        layer.BoundsDirty = true;
+        layer.Owner.Comp.BoundsDirty = true;
+    }
+
+    #endregion
+
+    #region Rotation
+
+    public void LayerSetRotation(Entity<SpriteComponent?> sprite, int index, Angle value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetRotation(layer, value);
+    }
+
+    public void LayerSetRotation(Entity<SpriteComponent?> sprite, string key, Angle value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRotation(layer, value);
+    }
+
+    public void LayerSetRotation(Entity<SpriteComponent?> sprite, Enum key, Angle value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRotation(layer, value);
+    }
+
+    public void LayerSetRotation(Layer layer, Angle value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer._rotation.EqualsApprox(value))
+            return;
+
+        layer._rotation = value;
+        layer.UpdateLocalMatrix();
+        _tree.QueueTreeUpdate(layer.Owner);
+        layer.BoundsDirty = true;
+        layer.Owner.Comp.BoundsDirty = true;
+    }
+
+    #endregion
+
+    #region Offset
+
+    public void LayerSetOffset(Entity<SpriteComponent?> sprite, int index, Vector2 value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetOffset(layer, value);
+    }
+
+    public void LayerSetOffset(Entity<SpriteComponent?> sprite, string key, Vector2 value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetOffset(layer, value);
+    }
+
+    public void LayerSetOffset(Entity<SpriteComponent?> sprite, Enum key, Vector2 value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetOffset(layer, value);
+    }
+
+    public void LayerSetOffset(Layer layer, Vector2 value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer._offset.EqualsApprox(value))
+            return;
+
+        layer._offset = value;
+        layer.UpdateLocalMatrix();
+        _tree.QueueTreeUpdate(layer.Owner);
+        layer.BoundsDirty = true;
+        layer.Owner.Comp.BoundsDirty = true;
+    }
+
+    #endregion
+
+    #region Visible
+
+    public void LayerSetVisible(Entity<SpriteComponent?> sprite, int index, bool value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetVisible(layer, value);
+    }
+
+    public void LayerSetVisible(Entity<SpriteComponent?> sprite, string key, bool value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetVisible(layer, value);
+    }
+
+    public void LayerSetVisible(Entity<SpriteComponent?> sprite, Enum key, bool value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetVisible(layer, value);
+    }
+
+    public void LayerSetVisible(Layer layer, bool value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer._visible == value)
+            return;
+
+        layer._visible = value;
+        QueueUpdateIsInert(layer.Owner);
+        _tree.QueueTreeUpdate(layer.Owner);
+        layer.Owner.Comp.BoundsDirty = true;
+    }
+
+    #endregion
+
+    #region Color
+
+    public void LayerSetColor(Entity<SpriteComponent?> sprite, int index, Color value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetColor(layer, value);
+    }
+
+    public void LayerSetColor(Entity<SpriteComponent?> sprite, string key, Color value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetColor(layer, value);
+    }
+
+    public void LayerSetColor(Entity<SpriteComponent?> sprite, Enum key, Color value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetColor(layer, value);
+    }
+
+    public void LayerSetColor(Layer layer, Color value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        layer.Color = value;
+    }
+
+    #endregion
+
+    #region DirOffset
+
+    public void LayerSetDirOffset(Entity<SpriteComponent?> sprite, int index, DirectionOffset value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetDirOffset(layer, value);
+    }
+
+    public void LayerSetDirOffset(Entity<SpriteComponent?> sprite, string key, DirectionOffset value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetDirOffset(layer, value);
+    }
+
+    public void LayerSetDirOffset(Entity<SpriteComponent?> sprite, Enum key, DirectionOffset value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetDirOffset(layer, value);
+    }
+
+    public void LayerSetDirOffset(Layer layer, DirectionOffset value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        layer.DirOffset = value;
+    }
+
+    #endregion
+
+    #region AnimationTime
+
+    public void LayerSetAnimationTime(Entity<SpriteComponent?> sprite, int index, float value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetAnimationTime(layer, value);
+    }
+
+    public void LayerSetAnimationTime(Entity<SpriteComponent?> sprite, string key, float value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetAnimationTime(layer, value);
+    }
+
+    public void LayerSetAnimationTime(Entity<SpriteComponent?> sprite, Enum key, float value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetAnimationTime(layer, value);
+    }
+
+    public void LayerSetAnimationTime(Layer layer, float value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (!layer.StateId.IsValid)
+            return;
+
+        if (layer.ActualRsi is not { } rsi)
+            return;
+
+        var state = rsi[layer.StateId];
+        if (value > layer.AnimationTime)
+        {
+            // Handle advancing differently from going backwards.
+            layer.AnimationTimeLeft -= (value - layer.AnimationTime);
+        }
+        else
+        {
+            // Going backwards we re-calculate from zero.
+            // Definitely possible to optimize this for going backwards but I'm too lazy to figure that out.
+            layer.AnimationTimeLeft = -value + state.GetDelay(0);
+            layer.AnimationFrame = 0;
+        }
+
+        layer.AnimationTime = value;
+        layer.AdvanceFrameAnimation(state);
+        layer.SetAnimationTime(value);
+    }
+
+    #endregion
+
+    #region AutoAnimated
+
+    public void LayerSetAutoAnimated(Entity<SpriteComponent?> sprite, int index, bool value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetAutoAnimated(layer, value);
+    }
+
+    public void LayerSetAutoAnimated(Entity<SpriteComponent?> sprite, string key, bool value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetAutoAnimated(layer, value);
+    }
+
+    public void LayerSetAutoAnimated(Entity<SpriteComponent?> sprite, Enum key, bool value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetAutoAnimated(layer, value);
+    }
+
+    public void LayerSetAutoAnimated(Layer layer, bool value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        if (layer._autoAnimated == value)
+            return;
+
+        layer._autoAnimated = value;
+        QueueUpdateIsInert(layer.Owner);
+    }
+
+    #endregion
+
+    #region LayerSetRenderingStrategy
+
+    public void LayerSetRenderingStrategy(Entity<SpriteComponent?> sprite, int index, LayerRenderingStrategy value)
+    {
+        if (TryGetLayer(sprite, index, out var layer, true))
+            LayerSetRenderingStrategy(layer, value);
+    }
+
+    public void LayerSetRenderingStrategy(Entity<SpriteComponent?> sprite, string key, LayerRenderingStrategy value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRenderingStrategy(layer, value);
+    }
+
+    public void LayerSetRenderingStrategy(Entity<SpriteComponent?> sprite, Enum key, LayerRenderingStrategy value)
+    {
+        if (TryGetLayer(sprite, key, out var layer, true))
+            LayerSetRenderingStrategy(layer, value);
+    }
+
+    public void LayerSetRenderingStrategy(Layer layer, LayerRenderingStrategy value)
+    {
+        DebugTools.Assert(layer.Owner != default);
+        DebugTools.AssertNotNull(layer.Owner.Comp);
+        DebugTools.AssertEqual(layer.Owner.Comp.Layers[layer.Index], layer);
+
+        layer.RenderingStrategy = value;
+        layer.BoundsDirty = true;
+        layer.Owner.Comp.BoundsDirty = true;
+        _tree.QueueTreeUpdate(layer.Owner);
+    }
+
+    #endregion
+
+    /// <summary>
+    /// Refreshes an RSI layer's cached RSI state.
+    /// </summary>
+    private void RefreshCachedState(Layer layer, bool logErrors, RSI.State? fallback)
+    {
+        if (!layer.StateId.IsValid)
+        {
+            layer._actualState = null;
+        }
+        else if (layer.ActualRsi is not { } rsi)
+        {
+            layer._actualState = fallback ?? GetFallbackState();
+            if (logErrors)
+                Log.Error(
+                    $"{ToPrettyString(layer.Owner)} has no RSI to pull new state from! Trace:\n{Environment.StackTrace}");
+        }
+        else if (!rsi.TryGetState(layer.StateId, out layer._actualState))
+        {
+            layer._actualState = fallback ?? GetFallbackState();
+            if (logErrors)
+                Log.Error(
+                    $"{ToPrettyString(layer.Owner)}'s state '{layer.StateId}' does not exist in RSI {rsi.Path}. Trace:\n{Environment.StackTrace}");
+        }
+
+        layer.AnimationFrame = 0;
+        layer.AnimationTime = 0;
+        layer.AnimationTimeLeft = layer._actualState?.GetDelay(0) ?? 0f;
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Render.cs

@@ -0,0 +1,194 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Client.Graphics.Clyde;
+using Robust.Client.Utility;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Graphics.RSI;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using static Robust.Client.GameObjects.SpriteComponent;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains code related to actually rendering sprites.
+public sealed partial class SpriteSystem
+{
+    public void RenderSprite(
+        Entity<SpriteComponent> sprite,
+        DrawingHandleWorld drawingHandle,
+        Angle eyeRotation,
+        Angle worldRotation,
+        Vector2 worldPosition)
+    {
+        RenderSprite(sprite,
+            drawingHandle,
+            eyeRotation,
+            worldRotation,
+            worldPosition,
+            sprite.Comp.EnableDirectionOverride ? sprite.Comp.DirectionOverride : null);
+    }
+
+    public void RenderSprite(
+        Entity<SpriteComponent> sprite,
+        DrawingHandleWorld drawingHandle,
+        Angle eyeRotation,
+        Angle worldRotation,
+        Vector2 worldPosition,
+        Direction? overrideDirection)
+    {
+        // TODO SPRITE RENDERING
+        // Add fast path for simple sprites.
+        // I.e., when a sprite is modified, check if it is "simple". If it is. cache texture information in a struct
+        // and use a fast path here.
+        // E.g., simple 1-directional, 1-layer sprites can basically become a direct texture draw call. (most in game items).
+        // Similarly, 1-directional multi-layer sprites can become a sequence of direct draw calls (most in game walls).
+
+        if (!sprite.Comp.IsInert)
+            _queuedFrameUpdate.Add(sprite);
+
+        var angle = worldRotation + eyeRotation; // angle on-screen. Used to decide the direction of 4/8 directional RSIs
+        angle = angle.Reduced().FlipPositive();  // Reduce the angles to fix math shenanigans
+
+        var cardinal = Angle.Zero;
+
+        // If we have a 1-directional sprite then snap it to try and always face it south if applicable.
+        if (sprite.Comp is {NoRotation: false, SnapCardinals: true})
+            cardinal = angle.RoundToCardinalAngle();
+
+        // worldRotation + eyeRotation should be the angle of the entity on-screen. If no-rot is enabled this is just set to zero.
+        // However, at some point later the eye-matrix is applied separately, so we subtract -eye rotation for now:
+        var entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, sprite.Comp.NoRotation ? -eyeRotation : worldRotation - cardinal);
+        var spriteMatrix = Matrix3x2.Multiply(sprite.Comp.LocalMatrix, entityMatrix);
+
+        // Fast path for when all sprites use the same transform matrix
+        if (!sprite.Comp.GranularLayersRendering)
+        {
+            foreach (var layer in sprite.Comp.Layers)
+            {
+                RenderLayer(layer, drawingHandle, ref spriteMatrix, angle, overrideDirection);
+            }
+            return;
+        }
+
+        //Default rendering (NoRotation = false)
+        entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, worldRotation);
+        var transformDefault = Matrix3x2.Multiply(sprite.Comp.LocalMatrix, entityMatrix);
+
+        //Snap to cardinals
+        entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, worldRotation - angle.RoundToCardinalAngle());
+        var transformSnap = Matrix3x2.Multiply(sprite.Comp.LocalMatrix, entityMatrix);
+
+        //No rotation
+        entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, -eyeRotation);
+        var transformNoRot = Matrix3x2.Multiply(sprite.Comp.LocalMatrix, entityMatrix);
+
+        foreach (var layer in sprite.Comp.Layers)
+        {
+            switch (layer.RenderingStrategy)
+            {
+                case LayerRenderingStrategy.UseSpriteStrategy:
+                    RenderLayer(layer, drawingHandle, ref spriteMatrix, angle, overrideDirection);
+                    break;
+                case LayerRenderingStrategy.Default:
+                    RenderLayer(layer, drawingHandle, ref transformDefault, angle, overrideDirection);
+                    break;
+                case LayerRenderingStrategy.NoRotation:
+                    RenderLayer(layer, drawingHandle, ref transformNoRot, angle, overrideDirection);
+                    break;
+                case LayerRenderingStrategy.SnapToCardinals:
+                    RenderLayer(layer, drawingHandle, ref transformSnap, angle, overrideDirection);
+                    break;
+                default:
+                    Log.Error($"Tried to render a layer with unknown rendering stragegy: {layer.RenderingStrategy}");
+                    break;
+            }
+        }
+    }
+
+    /// <summary>
+    /// Render a layer. This assumes that the input angle is between 0 and 2pi.
+    /// </summary>
+    private void RenderLayer(Layer layer, DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatrix, Angle angle, Direction? overrideDirection)
+    {
+        if (!layer.Visible || layer.Blank)
+            return;
+
+        var state = layer._actualState;
+        var dir = state == null ? RsiDirection.South : Layer.GetDirection(state.RsiDirections, angle);
+
+        // Set the drawing transform for this layer
+        layer.GetLayerDrawMatrix(dir, out var layerMatrix, layer.Owner.Comp.NoRotation);
+
+        // The direction used to draw the sprite can differ from the one that the angle would naively suggest,
+        // due to direction overrides or offsets.
+        if (overrideDirection != null && state != null)
+            dir = overrideDirection.Value.Convert(state.RsiDirections);
+        dir = dir.OffsetRsiDir(layer.DirOffset);
+
+        var texture = state?.GetFrame(dir, layer.AnimationFrame) ?? layer.Texture ?? GetFallbackTexture();
+
+        // TODO SPRITE
+        // Refactor shader-param-layers to a separate layer type after layers are split into types & collections.
+        // I.e., separate Layer -> RsiLayer, TextureLayer, LayerCollection, SpriteLayer, and ShaderLayer
+        if (layer.CopyToShaderParameters != null)
+        {
+            HandleShaderLayer(layer, texture, layer.CopyToShaderParameters);
+            return;
+        }
+
+        // Set the drawing transform for this layer
+        var transformMatrix = Matrix3x2.Multiply(layerMatrix, spriteMatrix);
+        drawingHandle.SetTransform(in transformMatrix);
+
+        if (layer.Shader != null)
+            drawingHandle.UseShader(layer.Shader);
+
+        var layerColor = layer.Owner.Comp.color * layer.Color;
+        var textureSize = texture.Size / (float) EyeManager.PixelsPerMeter;
+        var quad = Box2.FromDimensions(textureSize / -2, textureSize);
+
+        if (layer.UnShaded)
+        {
+            DebugTools.AssertNull(layer.Shader);
+            DebugTools.Assert(layerColor is {R: >= 0, G: >= 0, B: >= 0, A: >= 0}, "Default shader should not be used with negative color modulation.");
+
+            // Negative color modulation values are by the default shader to disable light shading.
+            // Specifically we set colour = - 1 - colour
+            // This is good enough to ensure that non-negative values become negative & is trivially invertible.
+            layerColor = new(new Vector4(-1) - layerColor.RGBA);
+        }
+
+        drawingHandle.DrawTextureRectRegion(texture, quad, layerColor);
+
+        if (layer.Shader != null)
+            drawingHandle.UseShader(null);
+    }
+
+    /// <summary>
+    /// Handle a a "fake layer" that just exists to modify the parameters of a shader being used by some other
+    /// layer.
+    /// </summary>
+    private void HandleShaderLayer(Layer layer, Texture texture, CopyToShaderParameters @params)
+    {
+        // Multiple atrocities to god being committed right here.
+        var otherLayerIdx = layer._parent.LayerMap[@params.LayerKey!];
+        var otherLayer = layer._parent.Layers[otherLayerIdx];
+        if (otherLayer.Shader is not { } shader)
+            return;
+
+        if (!shader.Mutable)
+            otherLayer.Shader = shader = shader.Duplicate();
+
+        var clydeTexture = Clyde.RenderHandle.ExtractTexture(texture, null, out var csr);
+
+        if (@params.ParameterTexture is { } paramTexture)
+            shader.SetParameter(paramTexture, clydeTexture);
+
+        if (@params.ParameterUV is not { } paramUV)
+            return;
+
+        var sr = Clyde.RenderHandle.WorldTextureBoundsToUV(clydeTexture, csr);
+        var uv = new Vector4(sr.Left, sr.Bottom, sr.Right, sr.Top);
+        shader.SetParameter(paramUV, uv);
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Setters.cs

@@ -0,0 +1,166 @@
+using System;
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.GameObjects;
+
+// This partial class contains various public methods for setting sprite component data.
+public sealed partial class SpriteSystem
+{
+    private bool ValidateScale(Entity<SpriteComponent> sprite, Vector2 scale)
+    {
+        if (!(MathF.Abs(scale.X) < 0.005f) && !(MathF.Abs(scale.Y) < 0.005f))
+            return true;
+
+        // Scales of ~0.0025 or lower can lead to singular matrices due to rounding errors.
+        Log.Error(
+            $"Attempted to set layer sprite scale to very small values. Entity: {ToPrettyString(sprite)}. Scale: {scale}");
+
+        return false;
+    }
+
+    #region Transform
+    public void SetScale(Entity<SpriteComponent?> sprite, Vector2 value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (!ValidateScale(sprite!, value))
+            return;
+
+        sprite.Comp._bounds = sprite.Comp._bounds.Scale(value / sprite.Comp.scale);
+        sprite.Comp.scale = value;
+        sprite.Comp.LocalMatrix = Matrix3Helpers.CreateTransform(
+            in sprite.Comp.offset,
+            in sprite.Comp.rotation,
+            in sprite.Comp.scale);
+    }
+
+    public void SetRotation(Entity<SpriteComponent?> sprite, Angle value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        sprite.Comp.rotation = value;
+        sprite.Comp.LocalMatrix = Matrix3Helpers.CreateTransform(
+            in sprite.Comp.offset,
+            in sprite.Comp.rotation,
+            in sprite.Comp.scale);
+    }
+
+    public void SetOffset(Entity<SpriteComponent?> sprite, Vector2 value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        sprite.Comp.offset = value;
+        sprite.Comp.LocalMatrix = Matrix3Helpers.CreateTransform(
+            in sprite.Comp.offset,
+            in sprite.Comp.rotation,
+            in sprite.Comp.scale);
+    }
+    #endregion
+
+    public void SetVisible(Entity<SpriteComponent?> sprite, bool value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (sprite.Comp.Visible == value)
+            return;
+
+        sprite.Comp._visible = value;
+        _tree.QueueTreeUpdate(sprite!);
+    }
+
+    public void SetDrawDepth(Entity<SpriteComponent?> sprite, int value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        sprite.Comp.drawDepth = value;
+    }
+
+    public void SetColor(Entity<SpriteComponent?> sprite, Color value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        sprite.Comp.color = value;
+    }
+
+    /// <summary>
+    /// Modify a sprites base RSI. This is the RSI that is used by any RSI layers that do not specify their own.
+    /// Note that changing the base RSI may result in existing layers having an invalid state. This will not log errors
+    /// under the assumption that the states of each layers will be updated after the base RSI has changed.
+    /// </summary>
+    public void SetBaseRsi(Entity<SpriteComponent?> sprite, RSI? value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (value == sprite.Comp._baseRsi)
+            return;
+
+        sprite.Comp._baseRsi = value;
+        if (value == null)
+            return;
+
+        var fallback = GetFallbackState();
+        for (var i = 0; i < sprite.Comp.Layers.Count; i++)
+        {
+            var layer = sprite.Comp.Layers[i];
+            if (!layer.State.IsValid || layer.RSI != null)
+                continue;
+
+            RefreshCachedState(layer, logErrors: false, fallback);
+
+            if (value.TryGetState(layer.State, out var state))
+            {
+                layer.AnimationTimeLeft = state.GetDelay(0);
+            }
+            else
+            {
+                Log.Error($"Layer {i} no longer has state '{layer.State}' due to base RSI change. Trace:\n{Environment.StackTrace}");
+                layer.Texture = null;
+            }
+        }
+    }
+
+    public void SetContainerOccluded(Entity<SpriteComponent?> sprite, bool value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        sprite.Comp._containerOccluded = value;
+        _tree.QueueTreeUpdate(sprite!);
+    }
+
+    public void SetSnapCardinals(Entity<SpriteComponent?> sprite, bool value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (value == sprite.Comp._snapCardinals)
+            return;
+
+        sprite.Comp._snapCardinals = value;
+        _tree.QueueTreeUpdate(sprite!);
+        DirtyBounds(sprite!);
+    }
+
+    public void SetGranularLayersRendering(Entity<SpriteComponent?> sprite, bool value)
+    {
+        if (!_query.Resolve(sprite.Owner, ref sprite.Comp))
+            return;
+
+        if (value == sprite.Comp.GranularLayersRendering)
+            return;
+
+        sprite.Comp.GranularLayersRendering = value;
+        _tree.QueueTreeUpdate(sprite!);
+        DirtyBounds(sprite!);
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Specifier.cs

@@ -1,137 +0,0 @@
-using System;
-using System.Collections.Generic;
-using JetBrains.Annotations;
-using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
-using Robust.Client.Utility;
-using Robust.Shared.Graphics;
-using Robust.Shared.Map;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization.TypeSerializers.Implementations;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects;
-
-public sealed partial class SpriteSystem
-{
-    private readonly Dictionary<string, IRsiStateLike> _cachedPrototypeIcons = new();
-
-    public Texture Frame0(EntityPrototype prototype)
-    {
-        return GetPrototypeIcon(prototype).Default;
-    }
-
-    public Texture Frame0(SpriteSpecifier specifier)
-    {
-        return RsiStateLike(specifier).Default;
-    }
-
-    public IRsiStateLike RsiStateLike(SpriteSpecifier specifier)
-    {
-        switch (specifier)
-        {
-            case SpriteSpecifier.Texture tex:
-                return tex.GetTexture(_resourceCache);
-
-            case SpriteSpecifier.Rsi rsi:
-                return GetState(rsi);
-
-            case SpriteSpecifier.EntityPrototype prototypeIcon:
-                return GetPrototypeIcon(prototypeIcon.EntityPrototypeId);
-
-            default:
-                throw new NotSupportedException();
-        }
-    }
-
-    public Texture GetIcon(IconComponent icon)
-    {
-        return GetState(icon.Icon).Frame0;
-    }
-
-    /// <summary>
-    ///     Returns an icon for a given <see cref="EntityPrototype"/> ID, or a fallback in case of an error.
-    ///     This method caches the result based on the prototype identifier.
-    /// </summary>
-    public IRsiStateLike GetPrototypeIcon(string prototype)
-    {
-        // Check if this prototype has been cached before, and if so return the result.
-        if (_cachedPrototypeIcons.TryGetValue(prototype, out var cachedResult))
-            return cachedResult;
-
-        if (!_proto.TryIndex<EntityPrototype>(prototype, out var entityPrototype))
-        {
-            // The specified prototype doesn't exist, return the fallback "error" sprite.
-            _sawmill.Error("Failed to load PrototypeIcon {0}", prototype);
-            return GetFallbackState();
-        }
-
-        // Generate the icon and cache it in case it's ever needed again.
-        var result = GetPrototypeIcon(entityPrototype);
-        _cachedPrototypeIcons[prototype] = result;
-
-        return result;
-    }
-
-    /// <summary>
-    ///     Returns an icon for a given <see cref="EntityPrototype"/> ID, or a fallback in case of an error.
-    ///     This method does NOT cache the result.
-    /// </summary>
-    public IRsiStateLike GetPrototypeIcon(EntityPrototype prototype)
-    {
-        // IconComponent takes precedence. If it has a valid icon, return that. Otherwise, continue as normal.
-        if (prototype.Components.TryGetValue("Icon", out var compData)
-            && compData.Component is IconComponent icon)
-        {
-            return GetIcon(icon);
-        }
-
-        // If the prototype doesn't have a SpriteComponent, then there's nothing we can do but return the fallback.
-        if (!prototype.Components.ContainsKey("Sprite"))
-        {
-            return GetFallbackState();
-        }
-
-        // Finally, we use spawn a dummy entity to get its icon.
-        var dummy = Spawn(prototype.ID, MapCoordinates.Nullspace);
-        var spriteComponent = EnsureComp<SpriteComponent>(dummy);
-        var result = spriteComponent.Icon ?? GetFallbackState();
-        Del(dummy);
-
-        return result;
-    }
-
-    [Pure]
-    public RSI.State GetFallbackState()
-    {
-        return _resourceCache.GetFallback<RSIResource>().RSI["error"];
-    }
-
-    [Pure]
-    public RSI.State GetState(SpriteSpecifier.Rsi rsiSpecifier)
-    {
-        if (_resourceCache.TryGetResource<RSIResource>(
-                SpriteSpecifierSerializer.TextureRoot / rsiSpecifier.RsiPath,
-                out var theRsi) &&
-            theRsi.RSI.TryGetState(rsiSpecifier.RsiState, out var state))
-        {
-            return state;
-        }
-
-        _sawmill.Error("Failed to load RSI {0}", rsiSpecifier.RsiPath);
-        return GetFallbackState();
-    }
-
-    private void OnPrototypesReloaded(PrototypesReloadedEventArgs args)
-    {
-        if (!args.TryGetModified<EntityPrototype>(out var modified))
-            return;
-
-        // Remove all changed prototypes from the cache, if they're there.
-        foreach (var prototype in modified)
-        {
-            // Let's be lazy and not regenerate them until something needs them again.
-            _cachedPrototypeIcons.Remove(prototype);
-        }
-    }
-}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -13,10 +13,9 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics.RSI;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
-using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using static Robust.Client.GameObjects.SpriteComponent;
@@ -35,25 +34,25 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IPrototypeManager _proto = default!;
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly IComponentFactory _factory = default!;
+
+        // Note that any new system dependencies have to be added to RobustUnitTest.BaseSetup()
         [Dependency] private readonly SharedTransformSystem _xforms = default!;
+        [Dependency] private readonly SpriteTreeSystem _tree = default!;
+        [Dependency] private readonly AppearanceSystem _appearance = default!;
 
         public static readonly ProtoId<ShaderPrototype> UnshadedId = "unshaded";
         private readonly Queue<SpriteComponent> _inertUpdateQueue = new();
 
+        public static readonly ResPath TextureRoot = SpriteSpecifierSerializer.TextureRoot;
+
         /// <summary>
         ///     Entities that require a sprite frame update.
         /// </summary>
         private readonly HashSet<EntityUid> _queuedFrameUpdate = new();
 
         private ISawmill _sawmill = default!;
-
-        internal void Render(EntityUid uid, SpriteComponent sprite, DrawingHandleWorld drawingHandle, Angle eyeRotation, in Angle worldRotation, in Vector2 worldPosition)
-        {
-            if (!sprite.IsInert)
-                _queuedFrameUpdate.Add(uid);
-
-            sprite.RenderInternal(drawingHandle, eyeRotation, worldRotation, worldPosition, sprite.EnableDirectionOverride ? sprite.DirectionOverride : null);
-        }
+        private EntityQuery<SpriteComponent> _query;
 
         public override void Initialize()
         {
@@ -62,11 +61,11 @@ namespace Robust.Client.GameObjects
             UpdatesAfter.Add(typeof(SpriteTreeSystem));
 
             SubscribeLocalEvent<PrototypesReloadedEventArgs>(OnPrototypesReloaded);
-            SubscribeLocalEvent<SpriteComponent, SpriteUpdateInertEvent>(QueueUpdateInert);
             SubscribeLocalEvent<SpriteComponent, ComponentInit>(OnInit);
 
             Subs.CVar(_cfg, CVars.RenderSpriteDirectionBias, OnBiasChanged, true);
             _sawmill = _logManager.GetSawmill("sprite");
+            _query = GetEntityQuery<SpriteComponent>();
         }
 
         public bool IsVisible(Layer layer)
@@ -85,18 +84,6 @@ namespace Robust.Client.GameObjects
             SpriteComponent.DirectionBias = value;
         }
 
-        private void QueueUpdateInert(EntityUid uid, SpriteComponent sprite, ref SpriteUpdateInertEvent ev)
-            => QueueUpdateInert(uid, sprite);
-
-        public void QueueUpdateInert(EntityUid uid, SpriteComponent sprite)
-        {
-            if (sprite._inertUpdateQueued)
-                return;
-
-            sprite._inertUpdateQueued = true;
-            _inertUpdateQueue.Enqueue(sprite);
-        }
-
         private void DoUpdateIsInert(SpriteComponent component)
         {
             component._inertUpdateQueued = false;

Robust.Client/GameObjects/EntitySystems/VisualizerSystem.cs

@@ -11,6 +11,7 @@ public abstract class VisualizerSystem<T> : EntitySystem
 {
     [Dependency] protected readonly AppearanceSystem AppearanceSystem = default!;
     [Dependency] protected readonly AnimationPlayerSystem AnimationSystem = default!;
+    [Dependency] protected readonly SpriteSystem SpriteSystem = default!;
 
     public override void Initialize()
     {

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -631,7 +631,7 @@ namespace Robust.Client.GameStates
                         if (_sawmill.Level <= LogLevel.Debug)
                             _sawmill.Debug($"  A component was dirtied: {comp.GetType()}");
 
-                        if (compState != null)
+                        if ((meta.Flags & MetaDataFlags.Detached) == 0 && compState != null)
                         {
                             var handleState = new ComponentHandleState(compState, null);
                             _entities.EventBus.RaiseComponentEvent(entity, comp, ref handleState);
@@ -1306,6 +1306,11 @@ namespace Robust.Client.GameStates
                     meta.LastStateApplied = lastStateApplied.Value;
 
                 var xform = xforms.GetComponent(ent.Value);
+
+                // TODO PVS DETACH
+                // Why is this if block here again? If a null-space entity gets sent to a player via some PVS override,
+                // and then later on it gets removed, you would assume that the client marks it as detached?
+                // I.e., modifying the metadata flag & pausing the entity should probably happen outside of this block.
                 if (xform.ParentUid.IsValid())
                 {
                     lookupSys.RemoveFromEntityTree(ent.Value, xform);
@@ -1326,6 +1331,13 @@ namespace Robust.Client.GameStates
                     xformSys.DetachEntity(ent.Value, xform);
                     DebugTools.Assert((meta.Flags & MetaDataFlags.InContainer) == 0);
 
+                    // We mark the entity as paused, without raising a pause-event.
+                    // The entity gets un-paused when the metadata's comp-state is reapplied (which also does not raise
+                    // an un-pause event). The assumption is that game logic that has to handle the pausing should be
+                    // getting networked anyway. And if its some client-side timer on a networked entity, the timer
+                    // shouldn't actually be getting paused just because the entity has left the players view.
+                    meta.PauseTime = TimeSpan.Zero;
+
                     if (container != null)
                         containerSys.AddExpectedEntity(netEntity, container);
                 }

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -13,6 +13,8 @@ namespace Robust.Client.GameStates
 {
     internal sealed class NetInterpOverlay : Overlay
     {
+        private static readonly ProtoId<ShaderPrototype> UnshadedShader = "unshaded";
+
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
@@ -32,7 +34,7 @@ namespace Robust.Client.GameStates
         {
             IoCManager.InjectDependencies(this);
             _lookup = lookup;
-            _shader = _prototypeManager.Index<ShaderPrototype>("unshaded").Instance();
+            _shader = _prototypeManager.Index(UnshadedShader).Instance();
             _container = _entityManager.System<SharedContainerSystem>();
             _xform = _entityManager.System<SharedTransformSystem>();
         }

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

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
@@ -254,7 +255,11 @@ namespace Robust.Client.Graphics.Clyde
                             region = regionMaybe[tile.Variant];
                         }
 
-                        WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region);
+                        var rotationMirroring = (_tileDefinitionManager.TryGetDefinition(tile.TypeId, out var tileDef) && tileDef.AllowRotationMirror) ?
+                                                    tile.RotationMirroring
+                                                    : 0;
+
+                        WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region, rotationMirroring);
                         i += 1;
                     }
                 }
@@ -325,7 +330,7 @@ namespace Robust.Client.Graphics.Clyde
                                 continue;
 
                             var region = regionMaybe[0];
-                            WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region);
+                            WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region, 0);
                             i += 1;
                         }
                     }
@@ -408,8 +413,11 @@ namespace Robust.Client.Graphics.Clyde
         private void _updateTileMapOnUpdate(ref TileChangedEvent args)
         {
             var gridData = _mapChunkData.GetOrNew(args.Entity);
-            if (gridData.TryGetValue(args.ChunkIndex, out var data))
-                data.Dirty = true;
+            foreach (var change in args.Changes)
+            {
+                if (gridData.TryGetValue(change.ChunkIndex, out var data))
+                    data.Dirty = true;
+            }
         }
 
         private void _updateOnGridCreated(GridStartupEvent ev)
@@ -445,13 +453,57 @@ namespace Robust.Client.Graphics.Clyde
             int gridY,
             Span<Vertex2D> vertexBuffer,
             Span<ushort> indexBuffer,
-            Box2 region)
+            Box2 region,
+            int rotationMirroring)
         {
+            var rLeftBottom = (region.Left, region.Bottom);
+            var rRightBottom = (region.Right, region.Bottom);
+            var rRightTop = (region.Right, region.Top);
+            var rLeftTop = (region.Left, region.Top);
+
+            // The vertices must be changed if there's any rotation or mirroring to the tile
+            if (rotationMirroring != 0)
+            {
+                // Rotate the tile
+                for (int r = 0; r < rotationMirroring % 4; r++)
+                {
+                    (rLeftBottom, rRightBottom, rRightTop, rLeftTop) =
+                        (rLeftTop, rLeftBottom, rRightBottom, rRightTop);
+                }
+
+                // Mirror on the x-axis
+                if (rotationMirroring >= 4)
+                {
+                    if (rotationMirroring % 2 == 0)
+                    {
+                        rLeftBottom = (rLeftBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
+                            rLeftBottom.Item2);
+                        rRightBottom = (rRightBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
+                            rRightBottom.Item2);
+                        rRightTop = (rRightTop.Item1.Equals(region.Left) ? region.Right : region.Left,
+                            rRightTop.Item2);
+                        rLeftTop = (rLeftTop.Item1.Equals(region.Left) ? region.Right : region.Left,
+                            rLeftTop.Item2);
+                    }
+                    else
+                    {
+                        rLeftBottom = (rLeftBottom.Item1,
+                            rLeftBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                        rRightBottom = (rRightBottom.Item1,
+                            rRightBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                        rRightTop = (rRightTop.Item1,
+                            rRightTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                        rLeftTop = (rLeftTop.Item1,
+                            rLeftTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
+                    }
+                }
+            }
+
             var vIdx = i * 4;
-            vertexBuffer[vIdx + 0] = new Vertex2D(gridX, gridY, region.Left, region.Bottom, Color.White);
-            vertexBuffer[vIdx + 1] = new Vertex2D(gridX + 1, gridY, region.Right, region.Bottom, Color.White);
-            vertexBuffer[vIdx + 2] = new Vertex2D(gridX + 1, gridY + 1, region.Right, region.Top, Color.White);
-            vertexBuffer[vIdx + 3] = new Vertex2D(gridX, gridY + 1, region.Left, region.Top, Color.White);
+            vertexBuffer[vIdx + 0] = new Vertex2D(gridX, gridY, rLeftBottom.Left, rLeftBottom.Bottom, Color.White);
+            vertexBuffer[vIdx + 1] = new Vertex2D(gridX + 1, gridY, rRightBottom.Right, rRightBottom.Bottom, Color.White);
+            vertexBuffer[vIdx + 2] = new Vertex2D(gridX + 1, gridY + 1, rRightTop.Right, rRightTop.Top, Color.White);
+            vertexBuffer[vIdx + 3] = new Vertex2D(gridX, gridY + 1, rLeftTop.Left, rLeftTop.Top, Color.White);
             var nIdx = i * GetQuadBatchIndexCount();
             var tIdx = (ushort)(i * 4);
             QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);

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

@@ -318,7 +318,7 @@ namespace Robust.Client.Graphics.Clyde
                         screenSpriteSize.Y++;
 
                     bool exit = false;
-                    if (entry.Sprite.GetScreenTexture)
+                    if (entry.Sprite.GetScreenTexture && entry.Sprite.PostShader != null)
                     {
                         FlushRenderQueue();
                         var tex = CopyScreenTexture(viewport.RenderTarget);
@@ -369,7 +369,7 @@ namespace Robust.Client.Graphics.Clyde
                     }
                 }
 
-                spriteSystem.Render(entry.Uid, entry.Sprite, _renderHandle.DrawingHandleWorld, eye.Rotation, in entry.WorldRot, in entry.WorldPos);
+                spriteSystem.RenderSprite(new(entry.Uid, entry.Sprite), _renderHandle.DrawingHandleWorld, eye.Rotation, entry.WorldRot, entry.WorldPos);
 
                 if (entry.Sprite.PostShader != null && entityPostRenderTarget != null)
                 {

Robust.Client/Graphics/Clyde/Clyde.Layout.cs

@@ -4,7 +4,6 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using JetBrains.Annotations;
 using Robust.Shared.Maths;
-using Vector3 = Robust.Shared.Maths.Vector3;
 
 namespace Robust.Client.Graphics.Clyde
 {

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

@@ -18,7 +18,6 @@ using Robust.Shared.Graphics;
 using static Robust.Shared.GameObjects.OccluderComponent;
 using Robust.Shared.Utility;
 using TextureWrapMode = Robust.Shared.Graphics.TextureWrapMode;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde
 {

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

@@ -11,8 +11,6 @@ using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using TKStencilOp = OpenToolkit.Graphics.OpenGL4.StencilOp;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -541,7 +539,7 @@ namespace Robust.Client.Graphics.Clyde
                     case Matrix3x2 matrix3:
                         program.SetUniform(name, matrix3);
                         break;
-                    case Matrix4 matrix4:
+                    case Matrix4x4 matrix4:
                         program.SetUniform(name, matrix4);
                         break;
                     case ClydeTexture clydeTexture:
@@ -613,6 +611,8 @@ namespace Robust.Client.Graphics.Clyde
             EnsureBatchSpaceAvailable(4, GetQuadBatchIndexCount());
             EnsureBatchState(texture, true, GetQuadBatchPrimitiveType(), _queuedShader);
 
+            // TODO RENDERING
+            // It's probably better to do this on the GPU.
             bl = Vector2.Transform(bl, _currentMatrixModel);
             br = Vector2.Transform(br, _currentMatrixModel);
             tr = Vector2.Transform(tr, _currentMatrixModel);

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

@@ -10,8 +10,6 @@ using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -528,7 +526,7 @@ namespace Robust.Client.Graphics.Clyde
                 data.Parameters[name] = value;
             }
 
-            private protected override void SetParameterImpl(string name, in Matrix4 value)
+            private protected override void SetParameterImpl(string name, in Matrix4x4 value)
             {
                 var data = Parent._shaderInstances[Handle];
                 data.ParametersDirty = true;

Robust.Client/Graphics/Clyde/Clyde.Sprite.cs

@@ -153,7 +153,7 @@ internal partial class Clyde
 
             // special casing angle = n*pi/2 to avoid box rotation & bounding calculations doesn't seem to give significant speedups.
             data.SpriteScreenBB = TransformCenteredBox(
-                data.Sprite.Bounds,
+                _spriteSystem.GetLocalBounds((data.Uid, data.Sprite)),
                 finalRotation,
                 pos + batch.PreScaleViewOffset,
                 batch.ViewScale);

Robust.Client/Graphics/Clyde/Clyde.Systems.cs

@@ -10,6 +10,7 @@ internal sealed partial class Clyde
     private MapSystem _mapSystem = default!;
     private LightTreeSystem _lightTreeSystem = default!;
     private TransformSystem _transformSystem = default!;
+    private SpriteSystem _spriteSystem = default!;
     private SpriteTreeSystem _spriteTreeSystem = default!;
     private ClientOccluderSystem _occluderSystem = default!;
 
@@ -24,6 +25,7 @@ internal sealed partial class Clyde
         _mapSystem = _entitySystemManager.GetEntitySystem<MapSystem>();
         _lightTreeSystem = _entitySystemManager.GetEntitySystem<LightTreeSystem>();
         _transformSystem = _entitySystemManager.GetEntitySystem<TransformSystem>();
+        _spriteSystem = _entitySystemManager.GetEntitySystem<SpriteSystem>();
         _spriteTreeSystem = _entitySystemManager.GetEntitySystem<SpriteTreeSystem>();
         _occluderSystem = _entitySystemManager.GetEntitySystem<ClientOccluderSystem>();
     }
@@ -33,6 +35,7 @@ internal sealed partial class Clyde
         _mapSystem = null!;
         _lightTreeSystem = null!;
         _transformSystem = null!;
+        _spriteSystem = null!;
         _spriteTreeSystem = null!;
         _occluderSystem = null!;
     }

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

@@ -305,8 +305,8 @@ namespace Robust.Client.Graphics.Clyde
                 IsSrgb = srgb,
                 Name = name,
                 MemoryPressure = memoryPressure,
-                TexturePixelType = pixType
-                // TextureInstance = new WeakReference<ClydeTexture>(instance)
+                TexturePixelType = pixType,
+                TextureInstance = new WeakReference<ClydeTexture>(instance)
             };
 
             _loadedTextures.Add(id, loaded);
@@ -466,15 +466,15 @@ namespace Robust.Client.Graphics.Clyde
         {
             var white = new Image<Rgba32>(1, 1);
             white[0, 0] = new Rgba32(255, 255, 255, 255);
-            _stockTextureWhite = (ClydeTexture) Texture.LoadFromImage(white);
+            _stockTextureWhite = (ClydeTexture) Texture.LoadFromImage(white, name: "StockTextureWhite");
 
             var black = new Image<Rgba32>(1, 1);
             black[0, 0] = new Rgba32(0, 0, 0, 255);
-            _stockTextureBlack = (ClydeTexture) Texture.LoadFromImage(black);
+            _stockTextureBlack = (ClydeTexture) Texture.LoadFromImage(black, name: "StockTextureBlack");
 
             var blank = new Image<Rgba32>(1, 1);
             blank[0, 0] = new Rgba32(0, 0, 0, 0);
-            _stockTextureTransparent = (ClydeTexture) Texture.LoadFromImage(blank);
+            _stockTextureTransparent = (ClydeTexture) Texture.LoadFromImage(blank, name: "StockTextureTransparent");
         }
 
         /// <summary>
@@ -571,7 +571,7 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private sealed class LoadedTexture
+        internal sealed class LoadedTexture
         {
             public GLHandle OpenGLObject;
             public int Width;
@@ -582,10 +582,10 @@ namespace Robust.Client.Graphics.Clyde
             public TexturePixelType TexturePixelType;
 
             public Vector2i Size => (Width, Height);
-            // public WeakReference<ClydeTexture> TextureInstance;
+            public required WeakReference<ClydeTexture> TextureInstance;
         }
 
-        private enum TexturePixelType : byte
+        internal enum TexturePixelType : byte
         {
             RenderTarget = 0,
             Rgba32,
@@ -686,5 +686,16 @@ namespace Robust.Client.Graphics.Clyde
                 _ => throw new ArgumentException(nameof(stockTexture))
             };
         }
+
+        public IEnumerable<(ClydeTexture, LoadedTexture)> GetLoadedTextures()
+        {
+            foreach (var loaded in _loadedTextures.Values)
+            {
+                if (!loaded.TextureInstance.TryGetTarget(out var textureInstance))
+                    continue;
+
+                yield return (textureInstance, loaded);
+            }
+        }
     }
 }

Robust.Client/Graphics/Clyde/Clyde.Windowing.cs

@@ -467,7 +467,7 @@ namespace Robust.Client.Graphics.Clyde
             _windowing!.RunOnWindowThread(a);
         }
 
-        public IFileDialogManager? FileDialogImpl => _windowing as IFileDialogManager;
+        public IFileDialogManagerImplementation? FileDialogImpl => _windowing as IFileDialogManagerImplementation;
 
         private abstract class WindowReg
         {

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -17,8 +17,6 @@ using Robust.Shared.Timing;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
 using Color = Robust.Shared.Maths.Color;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -72,6 +70,11 @@ namespace Robust.Client.Graphics.Clyde
             return new DummyTexture((1, 1));
         }
 
+        public IEnumerable<(Clyde.ClydeTexture, Clyde.LoadedTexture)> GetLoadedTextures()
+        {
+            return [];
+        }
+
         public ClydeDebugLayers DebugLayers { get; set; }
 
         public string GetKeyName(Keyboard.Key key) => string.Empty;
@@ -302,7 +305,7 @@ namespace Robust.Client.Graphics.Clyde
             action();
         }
 
-        public IFileDialogManager? FileDialogImpl => null;
+        public IFileDialogManagerImplementation? FileDialogImpl => null;
 
         private sealed class DummyCursor : ICursor
         {
@@ -393,7 +396,7 @@ namespace Robust.Client.Graphics.Clyde
             {
             }
 
-            private protected override void SetParameterImpl(string name, in Matrix4 value)
+            private protected override void SetParameterImpl(string name, in Matrix4x4 value)
             {
             }
 

Robust.Client/Graphics/Clyde/GLObjects/Clyde.GLHandle.cs

@@ -11,7 +11,7 @@ namespace Robust.Client.Graphics.Clyde
         ///     Basically just a handle around the integer object handles returned by OpenGL.
         /// </summary>
         [PublicAPI]
-        private struct GLHandle : IEquatable<GLHandle>
+        internal struct GLHandle : IEquatable<GLHandle>
         {
             public readonly uint Handle;
 

Robust.Client/Graphics/Clyde/GLObjects/Clyde.ShaderProgram.cs

@@ -5,8 +5,6 @@ using System.Runtime.CompilerServices;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -277,20 +275,20 @@ namespace Robust.Client.Graphics.Clyde
                 _clyde.CheckGlError();
             }
 
-            public void SetUniform(string uniformName, in Matrix4 matrix, bool transpose=true)
+            public void SetUniform(string uniformName, in Matrix4x4 matrix, bool transpose=true)
             {
                 var uniformId = GetUniform(uniformName);
                 SetUniformDirect(uniformId, matrix, transpose);
             }
 
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            private unsafe void SetUniformDirect(int uniformId, in Matrix4 value, bool transpose=true)
+            private unsafe void SetUniformDirect(int uniformId, in Matrix4x4 value, bool transpose=true)
             {
-                Matrix4 tmpTranspose = value;
+                Matrix4x4 tmpTranspose = value;
                 if (transpose)
                 {
                     // transposition not supported on GLES2, & no access to _hasGLES
-                    tmpTranspose.Transpose();
+                    tmpTranspose = Matrix4x4.Transpose(value);
                 }
                 GL.UniformMatrix4(uniformId, 1, false, (float*) &tmpTranspose);
                 _clyde.CheckGlError();
@@ -551,7 +549,7 @@ namespace Robust.Client.Graphics.Clyde
                 }
             }
 
-            public void SetUniformMaybe(string uniformName, in Matrix4 value, bool transpose=true)
+            public void SetUniformMaybe(string uniformName, in Matrix4x4 value, bool transpose=true)
             {
                 if (TryGetUniform(uniformName, out var slot))
                 {

Robust.Client/Graphics/Clyde/Windowing/Glfw.Cursors.cs

@@ -87,11 +87,13 @@ namespace Robust.Client.Graphics.Clyde
                 if (cmd.Cursor != default)
                     ptr = _winThreadCursors[cmd.Cursor].Ptr;
 
+#if DEBUG
                 if (_win32Experience)
                 {
                     // Based on a true story.
                     Thread.Sleep(15);
                 }
+#endif
 
                 GLFW.SetCursor(window, ptr);
             }

Robust.Client/Graphics/Clyde/Windowing/Glfw.Windows.cs

@@ -662,6 +662,10 @@ namespace Robust.Client.Graphics.Clyde
             {
                 var icons = _clyde.LoadWindowIcons().ToArray();
 
+                // Done if no icon (e.g., macOS)
+                if (icons.Length == 0)
+                    return;
+
                 // Turn each image into a byte[] so we can actually pin their contents.
                 // Wish I knew a clean way to do this without allocations.
                 var images = icons

Robust.Client/Graphics/Clyde/Windowing/Glfw.cs

@@ -23,7 +23,9 @@ namespace Robust.Client.Graphics.Clyde
             private readonly ISawmill _sawmillGlfw;
 
             private bool _glfwInitialized;
+#if DEBUG
             private bool _win32Experience;
+#endif
 
             public GlfwWindowingImpl(Clyde clyde, IDependencyCollection deps)
             {

Robust.Client/Graphics/Clyde/Windowing/Sdl3.FileDialog.cs

@@ -1,5 +1,4 @@
 using System;
-using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -12,31 +11,16 @@ namespace Robust.Client.Graphics.Clyde;
 
 internal partial class Clyde
 {
-    private sealed partial class Sdl3WindowingImpl : IFileDialogManager
+    private sealed partial class Sdl3WindowingImpl : IFileDialogManagerImplementation
     {
-        public async Task<Stream?> OpenFile(FileDialogFilters? filters = null)
+        public async Task<string?> OpenFile(FileDialogFilters? filters)
         {
-            var fileName = await ShowFileDialogOfType(SDL.SDL_FILEDIALOG_OPENFILE, filters);
-            if (fileName == null)
-                return null;
-
-            return File.OpenRead(fileName);
+            return await ShowFileDialogOfType(SDL.SDL_FILEDIALOG_OPENFILE, filters);
         }
 
-        public async Task<(Stream fileStream, bool alreadyExisted)?> SaveFile(FileDialogFilters? filters = null, bool truncate = true)
+        public async Task<string?> SaveFile(FileDialogFilters? filters)
         {
-            var fileName = await ShowFileDialogOfType(SDL.SDL_FILEDIALOG_SAVEFILE, filters);
-            if (fileName == null)
-                return null;
-
-            try
-            {
-                return (File.Open(fileName, truncate ? FileMode.Truncate : FileMode.Open), true);
-            }
-            catch (FileNotFoundException)
-            {
-                return (File.Open(fileName, FileMode.Create), false);
-            }
+            return await ShowFileDialogOfType(SDL.SDL_FILEDIALOG_SAVEFILE, filters);
         }
 
         private unsafe Task<string?> ShowFileDialogOfType(int type, FileDialogFilters? filters)
@@ -74,6 +58,8 @@ internal partial class Clyde
                     NativeMemory.Free(filter.name);
                     NativeMemory.Free(filter.pattern);
                 }
+
+                NativeMemory.Free(filtersAlloc);
             }
 
             return task;

Robust.Client/Graphics/IClydeInternal.cs

@@ -54,6 +54,7 @@ namespace Robust.Client.Graphics
         IClydeDebugStats DebugStats { get; }
 
         Texture GetStockTexture(ClydeStockTexture stockTexture);
+        IEnumerable<(Clyde.Clyde.ClydeTexture, Clyde.Clyde.LoadedTexture)> GetLoadedTextures();
 
         ClydeDebugLayers DebugLayers { get; set; }
 
@@ -70,6 +71,6 @@ namespace Robust.Client.Graphics
 
         void RunOnWindowThread(Action action);
 
-        IFileDialogManager? FileDialogImpl { get; }
+        IFileDialogManagerImplementation? FileDialogImpl { get; }
     }
 }

Robust.Client/Graphics/Shaders/ShaderInstance.cs

@@ -4,8 +4,6 @@ using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics
 {
@@ -169,7 +167,7 @@ namespace Robust.Client.Graphics
             SetParameterImpl(name, value);
         }
 
-        public void SetParameter(string name, in Matrix4 value)
+        public void SetParameter(string name, in Matrix4x4 value)
         {
             EnsureAlive();
             EnsureMutable();
@@ -236,7 +234,7 @@ namespace Robust.Client.Graphics
         private protected abstract void SetParameterImpl(string name, bool value);
         private protected abstract void SetParameterImpl(string name, bool[] value);
         private protected abstract void SetParameterImpl(string name, in Matrix3x2 value);
-        private protected abstract void SetParameterImpl(string name, in Matrix4 value);
+        private protected abstract void SetParameterImpl(string name, in Matrix4x4 value);
         private protected abstract void SetParameterImpl(string name, Texture value);
         private protected abstract void SetStencilImpl(StencilParameters value);
     }

Robust.Client/Graphics/Shaders/ShaderPrototype.cs

@@ -11,8 +11,6 @@ using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 using YamlDotNet.RepresentationModel;
-using Vector3 = Robust.Shared.Maths.Vector3;
-using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics
 {
@@ -222,7 +220,7 @@ namespace Robust.Client.Graphics
                     case Matrix3x2 i:
                         instance.SetParameter(key, i);
                         break;
-                    case Matrix4 i:
+                    case Matrix4x4 i:
                         instance.SetParameter(key, i);
                         break;
                 }

Robust.Client/Physics/DebugPhysicsIslandSystem.cs

@@ -47,7 +47,7 @@ namespace Robust.Client.Physics
          * This will draw above every body involved in a particular island solve.
          */
 
-        public readonly Queue<(TimeSpan Time, List<PhysicsComponent> Bodies)> IslandSolve = new();
+        public readonly Queue<(TimeSpan Time, List<Entity<PhysicsComponent, TransformComponent>> Bodies)> IslandSolve = new();
         public const float SolveDuration = 0.1f;
 
         public override void Initialize()

Robust.Client/Physics/JointSystem.cs

@@ -67,7 +67,7 @@ namespace Robust.Client.Physics
 
                 // Add new joint (if possible).
                 // Need to wait for BOTH joint components to come in first before we can add it. Yay dependencies!
-                if (!EntityManager.HasComponent<JointComponent>(other))
+                if (!HasComp<JointComponent>(other))
                     continue;
 
                 // TODO: if (other entity is outside of PVS range) continue;

Robust.Client/Physics/PhysicsSystem.Predict.cs

@@ -90,9 +90,10 @@ public sealed partial class PhysicsSystem
         // existing contacts for predicted entities before performing any actual prediction.
 
         var contacts = new List<Contact>();
-        var maps = new HashSet<EntityUid>();
 
         var enumerator = AllEntityQuery<PredictedPhysicsComponent, PhysicsComponent, TransformComponent>();
+        _broadphase.FindNewContacts();
+
         while (enumerator.MoveNext(out _, out var physics, out var xform))
         {
             DebugTools.Assert(physics.Predict);
@@ -100,10 +101,6 @@ public sealed partial class PhysicsSystem
             if (xform.MapUid is not { } map)
                 continue;
 
-            if (maps.Add(map) && PhysMapQuery.TryGetComponent(map, out var physMap) &&
-                MapQuery.TryGetComponent(map, out var mapComp))
-                _broadphase.FindNewContacts(physMap, mapComp.MapId);
-
             contacts.AddRange(physics.Contacts);
         }
 

Robust.Client/Physics/PhysicsSystem.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
+using Robust.Shared.Collections;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Physics;
@@ -23,21 +24,23 @@ namespace Robust.Client.Physics
             SimulateWorld(frameTime, _gameTiming.InPrediction);
         }
 
-        protected override void Cleanup(PhysicsMapComponent component, float frameTime)
+        protected override void Cleanup(float frameTime)
         {
-            var toRemove = new List<Entity<PhysicsComponent>>();
+            var toRemove = new ValueList<Entity<PhysicsComponent, TransformComponent>>();
 
             // Because we're not predicting 99% of bodies its sleep timer never gets incremented so we'll just do it ourselves.
             // (and serializing it over the network isn't necessary?)
             // This is a client-only problem.
             // Also need to suss out having the client build the island anyway and just... not solving it?
-            foreach (var body in component.AwakeBodies)
+            foreach (var ent in AwakeBodies)
             {
+                var body = ent.Comp1;
+
                 if (!body.SleepingAllowed || body.LinearVelocity.Length() > LinearToleranceSqr / 2f || body.AngularVelocity * body.AngularVelocity > AngularToleranceSqr / 2f) continue;
                 body.SleepTime += frameTime;
                 if (body.SleepTime > TimeToSleep)
                 {
-                    toRemove.Add(new Entity<PhysicsComponent>(body.Owner, body));
+                    toRemove.Add(ent);
                 }
             }
 
@@ -46,37 +49,38 @@ namespace Robust.Client.Physics
                 SetAwake(body, false);
             }
 
-            base.Cleanup(component, frameTime);
+            base.Cleanup(frameTime);
         }
 
-        protected override void UpdateLerpData(PhysicsMapComponent component, List<PhysicsComponent> bodies, EntityQuery<TransformComponent> xformQuery)
+        protected override void UpdateLerpData(List<Entity<PhysicsComponent, TransformComponent>> bodies)
         {
-            foreach (var body in bodies)
+            foreach (var bodyEnt in bodies)
             {
+                var body = bodyEnt.Comp1;
+                var xform = bodyEnt.Comp2;
+
                 if (body.BodyType == BodyType.Static ||
-                    component.LerpData.TryGetValue(body.Owner, out var lerpData) ||
-                    !xformQuery.TryGetComponent(body.Owner, out var xform) ||
-                    lerpData.ParentUid == xform.ParentUid)
+                    LerpData.TryGetValue(bodyEnt, out var lerpData) ||
+                    lerpData == xform.ParentUid)
                 {
                     continue;
                 }
 
-                component.LerpData[xform.Owner] = (xform.ParentUid, xform.LocalPosition, xform.LocalRotation);
+                LerpData[bodyEnt.Owner] = xform.ParentUid;
             }
         }
 
         /// <summary>
         /// Flush all of our lerping data.
         /// </summary>
-        protected override void FinalStep(PhysicsMapComponent component)
+        protected override void FinalStep()
         {
-            base.FinalStep(component);
-            var xformQuery = GetEntityQuery<TransformComponent>();
+            base.FinalStep();
 
-            foreach (var (uid, (parentUid, position, rotation)) in component.LerpData)
+            foreach (var (uid, parentUid) in LerpData)
             {
-                if (!xformQuery.TryGetComponent(uid, out var xform) ||
-                    !parentUid.IsValid())
+                // Can't just re-use xform from before as movement events may cause event subs to fire.
+                if (!XformQuery.TryGetComponent(uid, out var xform) || !parentUid.IsValid())
                 {
                     continue;
                 }
@@ -85,7 +89,7 @@ namespace Robust.Client.Physics
                 _transform.SetLocalPositionRotation(uid, xform.LocalPosition, xform.LocalRotation, xform);
             }
 
-            component.LerpData.Clear();
+            LerpData.Clear();
         }
     }
 }

Robust.Client/Placement/IPlacementManager.cs

@@ -1,5 +1,8 @@
 using System;
+using Robust.Client.Graphics;
 using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Timing;
 
@@ -18,16 +21,30 @@ namespace Robust.Client.Placement
         PlacementMode? CurrentMode { get; set; }
         PlacementInformation? CurrentPermission { get; set; }
 
+        IEntityManager EntityManager { get; }
+        IEyeManager EyeManager { get; }
+        IMapManager MapManager { get; }
+
         /// <summary>
         /// The direction to spawn the entity in (presently exposed for EntitySpawnWindow UI)
         /// </summary>
         Direction Direction { get; set; }
 
         /// <summary>
-        /// Gets called when Direction changed (presently for EntitySpawnWindow UI)
+        /// Whether a tile placement should be mirrored or not.
+        /// </summary>
+        bool Mirrored { get; set; }
+
+        /// <summary>
+        /// Gets called when Direction changed (presently for EntitySpawnWindow/TileSpawnWindow UI)
         /// </summary>
         event EventHandler DirectionChanged;
 
+        /// <summary>
+        /// Gets called when Mirrored changed (presently for TileSpawnWindow UI)
+        /// </summary>
+        event EventHandler MirroredChanged;
+
         /// <summary>
         /// Gets called when the PlacementManager changed its build/erase mode or when the hijacks changed
         /// </summary>
@@ -39,5 +56,15 @@ namespace Robust.Client.Placement
         void ToggleEraserHijacked(PlacementHijack hijack);
 
         void FrameUpdate(FrameEventArgs e);
+
+        /// <summary>
+        /// The name of the placement mode option to just use the default for the selected entity.
+        /// </summary>
+        const string DefaultModeName = "Default";
+
+        /// <summary>
+        /// An array of the names of all available placement modes.
+        /// </summary>
+        string[] AllModeNames { get; }
     }
 }

Robust.Client/Placement/Modes/AlignWall.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Numerics;
 using Robust.Shared.Map;
-using Vector2 = System.Numerics.Vector2;
 
 namespace Robust.Client.Placement.Modes
 {

Robust.Client/Placement/Modes/AlignWallProper.cs

@@ -1,6 +1,6 @@
 using System.Linq;
+using System.Numerics;
 using Robust.Shared.Map;
-using Vector2 = System.Numerics.Vector2;
 
 namespace Robust.Client.Placement.Modes
 {

Robust.Client/Placement/PlacementManager.cs

@@ -22,6 +22,7 @@ using Robust.Shared.Utility;
 using Robust.Shared.Log;
 using Direction = Robust.Shared.Maths.Direction;
 using Robust.Shared.Map.Components;
+using System.Linq;
 
 namespace Robust.Client.Placement
 {
@@ -32,21 +33,28 @@ namespace Robust.Client.Placement
         [Dependency] internal readonly IPlayerManager PlayerManager = default!;
         [Dependency] internal readonly IResourceCache ResourceCache = default!;
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-        [Dependency] internal readonly IMapManager MapManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IGameTiming _time = default!;
-        [Dependency] internal readonly IEyeManager EyeManager = default!;
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] internal readonly IInputManager InputManager = default!;
         [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
-        [Dependency] internal readonly IEntityManager EntityManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IBaseClient _baseClient = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] internal readonly IClyde Clyde = default!;
 
+        private static readonly ProtoId<ShaderPrototype> UnshadedShader = "unshaded";
+
+        public IEntityManager EntityManager => _entityManager;
+        public IEyeManager EyeManager => _eyeManager;
+        public IMapManager MapManager => _mapManager;
+
         private ISawmill _sawmill = default!;
 
         private SharedMapSystem Maps => EntityManager.System<SharedMapSystem>();
         private SharedTransformSystem XformSystem => EntityManager.System<SharedTransformSystem>();
+        private SpriteSystem Sprite => EntityManager.System<SpriteSystem>();
 
         /// <summary>
         ///     How long before a pending tile change is dropped.
@@ -174,6 +182,18 @@ namespace Robust.Client.Placement
 
         private Direction _direction = Direction.South;
 
+        private bool _mirrored;
+
+        public bool Mirrored
+        {
+            get => _mirrored;
+            set
+            {
+                _mirrored = value;
+                MirroredChanged?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
         /// <inheritdoc />
         public Direction Direction
         {
@@ -185,15 +205,27 @@ namespace Robust.Client.Placement
             }
         }
 
+        private string[]? _allModeNames;
+        public string[] AllModeNames
+        {
+            get
+            {
+                return _allModeNames ??= [IPlacementManager.DefaultModeName, .. _modeDictionary.Keys.Order()];
+            }
+        }
+
         /// <inheritdoc />
         public event EventHandler? DirectionChanged;
 
+        /// <inheritdoc />
+        public event EventHandler? MirroredChanged;
+
         private PlacementOverlay _drawOverlay = default!;
         private bool _isActive;
 
         public void Initialize()
         {
-            _drawingShader = _prototypeManager.Index<ShaderPrototype>("unshaded").Instance();
+            _drawingShader = _prototypeManager.Index(UnshadedShader).Instance();
             _sawmill = _logManager.GetSawmill("placement");
 
             _networkManager.RegisterNetMessage<MsgPlacement>(HandlePlacementMessage);
@@ -344,12 +376,15 @@ namespace Robust.Client.Placement
 
         private void HandleTileChanged(ref TileChangedEvent args)
         {
-            var coords = Maps.GridTileToLocal(
-                args.NewTile.GridUid,
-                EntityManager.GetComponent<MapGridComponent>(args.NewTile.GridUid),
-                args.NewTile.GridIndices);
+            foreach (var change in args.Changes)
+            {
+                var coords = Maps.GridTileToLocal(
+                args.Entity,
+                args.Entity.Comp,
+                change.GridIndices);
 
-            _pendingTileChanges.RemoveAll(c => c.Item1 == coords);
+                _pendingTileChanges.RemoveAll(c => c.Item1 == coords);
+            }
         }
 
         /// <inheritdoc />
@@ -487,16 +522,15 @@ namespace Robust.Client.Placement
         {
             ClearWithoutDeactivation();
 
-            CurrentPermission = info;
-
-            if (!_modeDictionary.TryFirstOrNull(pair => pair.Key.Equals(CurrentPermission.PlacementOption), out KeyValuePair<string, Type>? placeMode))
+            if (info.PlacementOption is not { } option || !_modeDictionary.TryGetValue(option, out var placeMode))
             {
-                _sawmill.Log(LogLevel.Warning, $"Invalid placement mode `{CurrentPermission.PlacementOption}`");
+                _sawmill.Log(LogLevel.Warning, $"Invalid placement mode `{info.PlacementOption}`");
                 Clear();
                 return;
             }
 
-            CurrentMode = (PlacementMode) Activator.CreateInstance(placeMode.Value.Value, this)!;
+            CurrentPermission = info;
+            CurrentMode = (PlacementMode) Activator.CreateInstance(placeMode, this)!;
 
             if (hijack != null)
             {
@@ -694,11 +728,11 @@ namespace Robust.Client.Placement
             CurrentPlacementOverlayEntity = null;
         }
 
-        private SpriteComponent SetupPlacementOverlayEntity()
+        private Entity<SpriteComponent> SetupPlacementOverlayEntity()
         {
             EnsureNoPlacementOverlayEntity();
             CurrentPlacementOverlayEntity = EntityManager.SpawnEntity(null, MapCoordinates.Nullspace);
-            return EntityManager.EnsureComponent<SpriteComponent>(CurrentPlacementOverlayEntity.Value);
+            return (CurrentPlacementOverlayEntity.Value, EntityManager.EnsureComponent<SpriteComponent>(CurrentPlacementOverlayEntity.Value));
         }
 
         private void PreparePlacement(string templateName)
@@ -715,10 +749,16 @@ namespace Robust.Client.Placement
                 EntityManager.GetComponent<MetaDataComponent>(CurrentPlacementOverlayEntity.Value));
         }
 
-        public void PreparePlacementSprite(SpriteComponent sprite)
+        public void PreparePlacementSprite(Entity<SpriteComponent> sprite)
         {
             var sc = SetupPlacementOverlayEntity();
-            sc.CopyFrom(sprite);
+            Sprite.CopySprite(sprite.AsNullable(), sc.AsNullable());
+        }
+
+        [Obsolete("Use the Entity<SpriteComponent> overload.")]
+        public void PreparePlacementSprite(SpriteComponent sprite)
+        {
+            PreparePlacementSprite((sprite.Owner, sprite));
         }
 
         public void PreparePlacementTexList(List<IDirectionalTextureProvider>? texs, bool noRot, EntityPrototype? prototype)
@@ -729,27 +769,27 @@ namespace Robust.Client.Placement
                 // This one covers most cases (including Construction)
                 foreach (var v in texs)
                 {
-                    if (v is RSI.State)
+                    if (v is RSI.State st)
                     {
-                        var st = (RSI.State) v;
-                        sc.AddLayer(st.StateId, st.RSI);
+                        Sprite.AddRsiLayer(sc.AsNullable(), st.StateId, st.RSI);
                     }
                     else
                     {
                         // Fallback
-                        sc.AddLayer(v.Default);
+                        Sprite.AddTextureLayer(sc.AsNullable(), v.Default);
                     }
                 }
             }
             else
             {
-                sc.AddLayer(new ResPath("/Textures/Interface/tilebuildoverlay.png"));
+                Sprite.AddTextureLayer(sc.AsNullable(), new ResPath("/Textures/Interface/tilebuildoverlay.png"));
             }
-            sc.NoRotation = noRot;
+
+            sc.Comp.NoRotation = noRot;
 
             if (prototype != null && prototype.TryGetComponent<SpriteComponent>("Sprite", out var spriteComp))
             {
-                sc.Scale = spriteComp.Scale;
+                Sprite.SetScale(sc.AsNullable(), spriteComp.Scale);
             }
 
         }
@@ -757,7 +797,7 @@ namespace Robust.Client.Placement
         private void PreparePlacementTile()
         {
             var sc = SetupPlacementOverlayEntity();
-            sc.AddLayer(new ResPath("/Textures/Interface/tilebuildoverlay.png"));
+            Sprite.AddTextureLayer(sc.AsNullable(), new ResPath("/Textures/Interface/tilebuildoverlay.png"));
 
             IsActive = true;
         }
@@ -777,7 +817,9 @@ namespace Robust.Client.Placement
                     var grid = EntityManager.GetComponent<MapGridComponent>(gridId);
 
                     // no point changing the tile to the same thing.
-                    if (Maps.GetTileRef(gridId, grid, coordinates).Tile.TypeId == CurrentPermission.TileType)
+                    var tileRef = Maps.GetTileRef(gridId, grid, coordinates).Tile;
+                    if (tileRef.TypeId == CurrentPermission.TileType &&
+                        tileRef.RotationMirroring == Tile.DirectionToByte(Direction) + (Mirrored ? 4 : 0))
                         return;
                 }
 
@@ -801,9 +843,14 @@ namespace Robust.Client.Placement
             };
 
             if (CurrentPermission.IsTile)
+            {
                 message.TileType = CurrentPermission.TileType;
+                message.Mirrored = Mirrored;
+            }
             else
+            {
                 message.EntityTemplateName = CurrentPermission.EntityType;
+            }
 
             // world x and y
             message.NetCoordinates = EntityManager.GetNetCoordinates(coordinates);

Robust.Client/Placement/PlacementMode.cs

@@ -126,7 +126,7 @@ namespace Robust.Client.Placement
 
                 sprite.Color = IsValidPosition(coordinate) ? ValidPlaceColor : InvalidPlaceColor;
                 var rot = args.Viewport.Eye?.Rotation ?? default;
-                spriteSys.Render(uid.Value, sprite, args.WorldHandle, rot, worldRot, worldPos);
+                spriteSys.RenderSprite((uid.Value, sprite), args.WorldHandle, rot, worldRot, worldPos);
             }
         }
 

Robust.Client/Player/PlayerManager.cs

@@ -166,7 +166,7 @@ namespace Robust.Client.Player
             {
                 if (_client.RunLevel != ClientRunLevel.SinglePlayerGame)
                     Sawmill.Warning($"Attaching local player to an entity {EntManager.ToPrettyString(uid)} without an eye. This eye will not be netsynced and may cause issues.");
-                var eye = (EyeComponent) Factory.GetComponent(typeof(EyeComponent));
+                var eye = Factory.GetComponent<EyeComponent>();
                 eye.NetSyncEnabled = false;
                 EntManager.AddComponent(uid.Value, eye);
             }

Robust.Client/Prototypes/ClientPrototypeManager.cs

@@ -13,7 +13,9 @@ namespace Robust.Client.Prototypes
     public sealed class ClientPrototypeManager : PrototypeManager
     {
         [Dependency] private readonly INetManager _netManager = default!;
+#pragma warning disable CS0414
         [Dependency] private readonly IClientGameTiming _timing = default!;
+#pragma warning restore CS0414
         [Dependency] private readonly IGameControllerInternal _controller = default!;
         [Dependency] private readonly IReloadManager _reload = default!;
 

Robust.Client/ResourceManagement/ResourceCache.Preload.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading.Tasks;
@@ -8,6 +9,7 @@ using Robust.Client.Graphics;
 using Robust.Client.Utility;
 using Robust.Shared;
 using Robust.Shared.Audio;
+using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Graphics;
@@ -59,7 +61,14 @@ namespace Robust.Client.ResourceManagement
             {
                 try
                 {
-                    TextureResource.LoadPreTexture(_manager, data);
+                    TextureResource.LoadTextureParameters(_manager, data);
+                    if (!data.LoadParameters.Preload)
+                    {
+                        data.Skip = true;
+                        return;
+                    }
+
+                    TextureResource.LoadPreTextureData(_manager, data);
                 }
                 catch (Exception e)
                 {
@@ -72,7 +81,7 @@ namespace Robust.Client.ResourceManagement
 
             foreach (var data in texList)
             {
-                if (data.Bad)
+                if (data.Bad || data.Skip)
                     continue;
 
                 try
@@ -87,6 +96,7 @@ namespace Robust.Client.ResourceManagement
             }
 
             var errors = 0;
+            var skipped = 0;
             foreach (var data in texList)
             {
                 if (data.Bad)
@@ -95,6 +105,12 @@ namespace Robust.Client.ResourceManagement
                     continue;
                 }
 
+                if (data.Skip)
+                {
+                    skipped += 1;
+                    continue;
+                }
+
                 try
                 {
                     var texResource = new TextureResource();
@@ -110,9 +126,10 @@ namespace Robust.Client.ResourceManagement
             }
 
             sawmill.Debug(
-                "Preloaded {CountLoaded} textures ({CountErrored} errored) in {LoadTime}",
-                texList.Length,
+                "Preloaded {CountLoaded} textures ({CountErrored} errored, {CountSkipped} skipped) in {LoadTime}",
+                texList.Length - skipped - errors,
                 errors,
+                skipped,
                 sw.Elapsed);
         }
 
@@ -176,65 +193,143 @@ namespace Robust.Client.ResourceManagement
             // TODO allow RSIs to opt out (useful for very big & rare RSIs)
             // TODO combine with (non-rsi) texture atlas?
 
-            Array.Sort(atlasList, (b, a) => (b.AtlasSheet?.Height ?? 0).CompareTo(a.AtlasSheet?.Height ?? 0));
+            // We now need to insert the RSIs into the atlas. This specific problem is 2BP|O|F - the items are oriented
+            // and cutting is free. The sorting is done by a slightly modified FFDH algorithm. The algorithm is exactly
+            // the same as the standard FFDH algorithm with one main difference: We create new "levels" above placed
+            // blocks. For example if the first block was 10x20, then the second was 10x10 units, we would create a
+            // 10x10 level above the second block that would be treated as a normal level. This increases the packing
+            // efficiency from ~85% to ~95% with very little extra computational effort. The algorithm appears to be
+            // ~97% effective for storing SS14s RSIs.
+            //
+            // Here are some more resources about the strip packing problem!
+            //   -  https://en.wikipedia.org/w/index.php?title=Strip_packing_problem&oldid=1263496949#First-fit_decreasing-height_(FFDH)
+            //   -  https://www.csc.liv.ac.uk/~epa/surveyhtml.html
+            //   -  https://www.dei.unipd.it/~fisch/ricop/tesi/tesi_dottorato_Lodi_1999.pdf
+
+            // The array must be sorted from biggest to smallest first.
+            Array.Sort(atlasList, (b, a) => a.AtlasSheet.Height.CompareTo(b.AtlasSheet.Height));
 
-            // Each RSI sub atlas has a different size.
-            // Even if we iterate through them once to estimate total area, I have NFI how to sanely estimate an optimal square-texture size.
-            // So fuck it, just default to letting it be as large as it needs to and crop it as needed?
             var maxSize = Math.Min(GL.GetInteger(GetPName.MaxTextureSize), _configurationManager.GetCVar(CVars.ResRSIAtlasSize));
-            var sheet = new Image<Rgba32>(maxSize, maxSize);
 
-            var deltaY = 0;
-            Vector2i offset = default;
-            int finalized = -1;
-            int atlasCount = 0;
-            for (int i = 0; i < atlasList.Length; i++)
+            // THIS IS NOT GUARANTEED TO HAVE ANY PARTICULARLY LOGICAL ORDERING.
+            // E.G you could have atlas 1 RSIs appear *before* you're done seeing atlas 2 RSIs.
+            var levels = new ValueList<Level>();
+
+            // List of all the image atlases.
+            var imageAtlases = new ValueList<Image<Rgba32>>();
+
+            // List of all the actual atlases.
+            var finalAtlases = new ValueList<OwnedTexture>();
+
+            // Number of total pixels in each atlas.
+            var finalPixels = new ValueList<int>();
+
+            // First we just find the location of all the RSIs in the atlas before actually placing them.
+            // This allows us to effectively determine how much space we need to allocate for the images.
+            var currentHeight = 0;
+            var currentAtlasIndex = 0;
+            foreach (var rsi in atlasList)
             {
-                var rsi = atlasList[i];
-                if (rsi.Bad)
+                var insertHeight = rsi.AtlasSheet.Height;
+                var insertWidth = rsi.AtlasSheet.Width;
+
+                var found = false;
+                for (var i = 0; i < levels.Count && !found; i++)
+                {
+                    var levelPosition = levels[i].Position;
+                    var levelWidth = levels[i].Width;
+                    var levelHeight = levels[i].Height;
+
+                    // Check if it can fit in this level.
+                    if (levelHeight < insertHeight || levelWidth + insertWidth > levels[i].MaxWidth)
+                        continue;
+
+                    found = true;
+
+                    levels[i].Width += insertWidth;
+                    rsi.AtlasOffset = levelPosition + new Vector2i(levelWidth, 0);
+                    levels[i].RSIList.Add(rsi);
+
+                    // Creating the extra "free" space above blocks that can be used for inserting more items.
+                    // This differs from the FFDH spec which just ignores this space.
+                    Debug.Assert(levelHeight >= insertHeight); // Must be true because the array needs to be sorted
+                    if (levelHeight - insertHeight == 0)
+                        continue;
+
+                    var freeLevel = new Level
+                    {
+                        AtlasId = levels[i].AtlasId,
+                        Position = levelPosition + new Vector2i(levelWidth, insertHeight),
+                        Height = levelHeight - insertHeight,
+                        Width = 0,
+                        MaxWidth = insertWidth,
+                        RSIList = [ ]
+                    };
+
+                    levels.Add(freeLevel);
+                }
+
+                if (found)
                     continue;
 
-                DebugTools.Assert(rsi.AtlasSheet.Width < sheet.Width);
-                DebugTools.Assert(rsi.AtlasSheet.Height < sheet.Height);
-
-                if (offset.X + rsi.AtlasSheet.Width > sheet.Width)
+                // Ran out of space, we need to move on to the next atlas.
+                // This also isn't in the normal FFDH algorithm (obviously) but its close enough.
+                if (currentHeight + insertHeight > maxSize)
                 {
-                    offset.X = 0;
-                    offset.Y += deltaY;
+                    imageAtlases.Add(new Image<Rgba32>(maxSize, currentHeight));
+                    finalPixels.Add(0);
+                    currentHeight = 0;
+                    currentAtlasIndex++;
                 }
 
-                if (offset.Y + rsi.AtlasSheet.Height > sheet.Height)
-                {
-                    FinalizeMetaAtlas(i-1, sheet);
-                    sheet = new Image<Rgba32>(maxSize, maxSize);
-                    deltaY = 0;
-                    offset = default;
-                }
+                rsi.AtlasOffset = new Vector2i(0, currentHeight);
 
-                deltaY = Math.Max(deltaY, rsi.AtlasSheet.Height);
-                var box = new UIBox2i(0, 0, rsi.AtlasSheet.Width, rsi.AtlasSheet.Height);
-                rsi.AtlasSheet.Blit(box, sheet, offset);
-                rsi.AtlasOffset = offset;
-                offset.X += rsi.AtlasSheet.Width;
+                var newLevel = new Level
+                {
+                    AtlasId = currentAtlasIndex,
+                    Position = new Vector2i(0, currentHeight),
+                    Height = insertHeight,
+                    Width = insertWidth,
+                    MaxWidth = maxSize,
+                    RSIList = [ rsi ]
+                };
+                levels.Add(newLevel);
+
+                currentHeight += insertHeight;
             }
 
-            var height = offset.Y + deltaY;
-            var croppedSheet = new Image<Rgba32>(maxSize, height);
-            sheet.Blit(new UIBox2i(0, 0, maxSize, height), croppedSheet, default);
-            FinalizeMetaAtlas(atlasList.Length - 1, croppedSheet);
+            // This allocation takes a long time.
+            imageAtlases.Add(new Image<Rgba32>(maxSize, currentHeight));
+            finalPixels.Add(0);
 
-            void FinalizeMetaAtlas(int toIndex, Image<Rgba32> sheet)
+            // Put all textures on the atlases
+            foreach (var level in levels)
             {
-                var fromIndex = finalized + 1;
-                var atlas = Clyde.LoadTextureFromImage(sheet, $"Meta atlas {fromIndex}-{toIndex}");
-                for (int i = fromIndex; i <= toIndex; i++)
+                foreach (var rsi in level.RSIList)
                 {
-                    var rsi = atlasList[i];
-                    rsi.AtlasTexture = atlas;
-                }
+                    var box = new UIBox2i(0, 0, rsi.AtlasSheet.Width, rsi.AtlasSheet.Height);
 
-                finalized = toIndex;
-                atlasCount++;
+                    rsi.AtlasSheet.Blit(box, imageAtlases[level.AtlasId], rsi.AtlasOffset);
+                    finalPixels[level.AtlasId] += rsi.AtlasSheet.Width * rsi.AtlasSheet.Height;
+                }
+            }
+
+            // Finalize the atlases.
+            for (var i = 0; i < imageAtlases.Count; i++)
+            {
+                var atlasTexture = Clyde.LoadTextureFromImage(imageAtlases[i], $"Meta atlas {i}");
+                finalAtlases.Add(atlasTexture);
+
+                sawmill.Debug($"(Meta atlas {i}) - cropped utilization: {(float)finalPixels[i] / (maxSize * imageAtlases[i].Height):P2}, fill percentage: {(float)imageAtlases[i].Height / maxSize:P2}");
+            }
+
+            // Finally, reference the actual atlas from the RSIs.
+            foreach (var level in levels)
+            {
+                foreach (var rsi in level.RSIList)
+                {
+                    rsi.AtlasTexture = finalAtlases[level.AtlasId];
+                }
             }
 
             Parallel.ForEach(rsiList, data =>
@@ -279,7 +374,7 @@ namespace Robust.Client.ResourceManagement
             sawmill.Debug(
                 "Preloaded {CountLoaded} RSIs into {CountAtlas} Atlas(es?) ({CountNotAtlas} not atlassed, {CountErrored} errored) in {LoadTime}",
                 rsiList.Length,
-                atlasCount,
+                finalAtlases.Count,
                 nonAtlasList.Length,
                 errors,
                 sw.Elapsed);
@@ -290,4 +385,38 @@ namespace Robust.Client.ResourceManagement
             return rsi.MetaAtlas && rsi.LoadParameters == TextureLoadParameters.Default;
         }
     }
+
+    /// <summary>
+    ///     A "Level" to place boxes. Similar to FFDH levels, but with more parameters so we can fit in "free" levels
+    ///     above placed boxes.
+    /// </summary>
+    internal sealed class Level
+    {
+        /// <summary>
+        ///     Index of the atlas this is located.
+        /// </summary>
+        public required int AtlasId;
+        /// <summary>
+        ///     Bottom left of the location for the RSIs.
+        /// </summary>
+        public required Vector2i Position;
+        /// <summary>
+        ///     The current width of the level.
+        /// </summary>
+        /// <remarks>This can (and will) be 0. Will change.</remarks>
+        public required int Width;
+        /// <summary>
+        ///     The current height of the level.
+        /// </summary>
+        /// <remarks>This value should never change.</remarks>
+        public required int Height;
+        /// <summary>
+        ///     Maximum width of the level.
+        /// </summary>
+        public required int MaxWidth;
+        /// <summary>
+        ///     List of all the RSIs stored in this level. RSIs are ordered from tallest to smallest per level.
+        /// </summary>
+        public required List<RSIResource.LoadStepData> RSIList;
+    }
 }

Robust.Client/ResourceManagement/ResourceTypes/AudioResource.cs

@@ -1,8 +1,8 @@
 using System;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using Robust.Client.Audio;
-using Robust.Shared.Audio;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Utility;
@@ -11,6 +11,13 @@ namespace Robust.Client.ResourceManagement;
 
 public sealed class AudioResource : BaseResource
 {
+    // from: https://en.wikipedia.org/wiki/List_of_file_signatures
+    private static readonly byte[] OggSignature = "OggS"u8.ToArray();
+    private static readonly byte[] RiffSignature = "RIFF"u8.ToArray();
+    private const int WavSignatureStart = 8; // RIFF????
+    private static readonly byte[] WavSignature = "WAVE"u8.ToArray();
+    private const int MaxSignatureLength = 12; // RIFF????WAVE
+
     public AudioStream AudioStream { get; private set; } = default!;
 
     public void Load(AudioStream stream)
@@ -28,14 +35,19 @@ public sealed class AudioResource : BaseResource
         }
 
         using var fileStream = cache.ContentFileRead(path);
+        var seekableStream = fileStream.CanSeek ? fileStream : fileStream.CopyToMemoryStream();
+        byte[] signature = seekableStream.ReadExact(MaxSignatureLength);
+        seekableStream.Seek(0, SeekOrigin.Begin);
+
         var audioManager = dependencies.Resolve<IAudioInternal>();
-        if (path.Extension == "ogg")
+        if (signature[..OggSignature.Length].SequenceEqual(OggSignature))
         {
-            AudioStream = audioManager.LoadAudioOggVorbis(fileStream, path.ToString());
+            AudioStream = audioManager.LoadAudioOggVorbis(seekableStream, path.ToString());
         }
-        else if (path.Extension == "wav")
+        else if (signature[..RiffSignature.Length].SequenceEqual(RiffSignature)
+                 && signature[WavSignatureStart..MaxSignatureLength].SequenceEqual(WavSignature))
         {
-            AudioStream = audioManager.LoadAudioWav(fileStream, path.ToString());
+            AudioStream = audioManager.LoadAudioWav(seekableStream, path.ToString());
         }
         else
         {

Robust.Client/ResourceManagement/ResourceTypes/TextureResource.cs

@@ -22,28 +22,41 @@ namespace Robust.Client.ResourceManagement
 
         public override void Load(IDependencyCollection dependencies, ResPath path)
         {
-            if (path.Directory.Filename.EndsWith(".rsi"))
+            if (IsInRsi(path))
             {
-                Logger.WarningS(
-                    "res",
+                var sawmill = dependencies.Resolve<ILogManager>().GetSawmill("res");
+                sawmill.Warning(
                     "Loading raw texture inside RSI: {Path}. Refer to the RSI state instead of the raw PNG.",
                     path);
             }
 
             var data = new LoadStepData {Path = path};
 
-            LoadPreTexture(dependencies.Resolve<IResourceManager>(), data);
+            LoadTextureParameters(dependencies.Resolve<IResourceManager>(), data);
+            LoadPreTextureData(dependencies.Resolve<IResourceManager>(), data);
             LoadTexture(dependencies.Resolve<IClyde>(), data);
             LoadFinish(dependencies.Resolve<IResourceCache>(), data);
         }
 
-        internal static void LoadPreTexture(IResourceManager cache, LoadStepData data)
+        private static bool IsInRsi(ResPath path)
+        {
+            var dir = path.Directory;
+            if (dir == ResPath.Root)
+                return false;
+
+            return dir.Filename.EndsWith(".rsi");
+        }
+
+        internal static void LoadPreTextureData(IResourceManager cache, LoadStepData data)
         {
             using (var stream = cache.ContentFileRead(data.Path))
             {
                 data.Image = Image.Load<Rgba32>(stream);
             }
+        }
 
+        internal static void LoadTextureParameters(IResourceManager cache, LoadStepData data)
+        {
             data.LoadParameters = TryLoadTextureParameters(cache, data.Path) ?? TextureLoadParameters.Default;
         }
 
@@ -95,7 +108,8 @@ namespace Robust.Client.ResourceManagement
         {
             var data = new LoadStepData {Path = path};
 
-            LoadPreTexture(dependencies.Resolve<IResourceManager>(), data);
+            LoadTextureParameters(dependencies.Resolve<IResourceManager>(), data);
+            LoadPreTextureData(dependencies.Resolve<IResourceManager>(), data);
 
             if (data.Image.Width == Texture.Width && data.Image.Height == Texture.Height)
             {
@@ -119,6 +133,7 @@ namespace Robust.Client.ResourceManagement
             public Image<Rgba32> Image = default!;
             public TextureLoadParameters LoadParameters;
             public OwnedTexture Texture = default!;
+            public bool Skip;
             public bool Bad;
         }
 

Robust.Client/Upload/Commands/LoadPrototypeCommand.cs

@@ -22,7 +22,7 @@ public sealed class LoadPrototypeCommand : IConsoleCommand
         var dialogManager = IoCManager.Resolve<IFileDialogManager>();
         var loadManager = IoCManager.Resolve<IGamePrototypeLoadManager>();
 
-        var stream = await dialogManager.OpenFile();
+        var stream = await dialogManager.OpenFile(access: FileAccess.Read);
         if (stream is null)
             return;
 

Robust.Client/Upload/Commands/UploadFileCommand.cs

@@ -1,3 +1,4 @@
+using System.IO;
 using Robust.Client.UserInterface;
 using Robust.Shared;
 using Robust.Shared.Configuration;
@@ -36,7 +37,7 @@ public sealed class UploadFileCommand : IConsoleCommand
         var path = new ResPath(args[0]).ToRelativePath();
 
         var filters = new FileDialogFilters(new FileDialogFilters.Group(path.Extension));
-        await using var file = await _dialog.OpenFile(filters);
+        await using var file = await _dialog.OpenFile(filters, FileAccess.Read);
 
         if (file == null)
         {

Robust.Client/UserInterface/Control.cs

@@ -994,6 +994,9 @@ namespace Robust.Client.UserInterface
 
         internal int DoFrameUpdateRecursive(FrameEventArgs args)
         {
+            if (!Visible)
+                return 0;
+
             var total = 1;
             FrameUpdate(args);