Version: 267.3.2

Apparently NetSerializer treats IDynamicTypeSerializer and IStaticTypeSerializer differently for sealed types??

(cherry-picked from 6bbeaeeba6, without the test changes)

(cherry picked from commit d187018834dfa1cdead9ce5a7b72c38b07f8c81f)

.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 }}

.github/workflows/build-test.yml

@@ -10,7 +10,7 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest] # , macos-latest] - temporarily disabled due to libfreetype.dll errors.
+        os: [ubuntu-latest, windows-latest, macos-latest]
 
     runs-on: ${{ matrix.os }}
 

.github/workflows/publish-client.yml

@@ -26,7 +26,7 @@ jobs:
           dotnet-version: 9.0.x
 
       - name: Package client
-        run: Tools/package_client_build.py -p windows mac linux
+        run: Tools/package_client_build.py
 
       - name: Shuffle files around
         run: |

Directory.Packages.props

@@ -44,10 +44,11 @@
     <PackageVersion Include="NUnit3TestAdapter" Version="4.6.0" />
     <PackageVersion Include="Nett" Version="0.15.0" />
     <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.2" />
-    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
+    <PackageVersion Include="OpenTK.Audio.OpenAL" Version="4.9.4" />
     <PackageVersion Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
     <PackageVersion Include="Pidgin" Version="3.3.0" />
-    <PackageVersion Include="Robust.Natives" Version="0.1.1" />
+    <PackageVersion Include="Robust.Natives" Version="0.2.3" />
+    <PackageVersion Include="Robust.Natives.Zstd" Version="0.1.1-zstd1.5.7" />
     <PackageVersion Include="Robust.Natives.Cef" Version="131.3.5" />
     <PackageVersion Include="Robust.Shared.AuthLib" Version="0.1.2" />
     <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.10" />
@@ -55,11 +56,14 @@
     <PackageVersion Include="Serilog" Version="4.2.0" />
     <PackageVersion Include="Serilog.Sinks.Loki" Version="4.0.0-beta3" />
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.7" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.11" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
     <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
-    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
+    <PackageVersion Include="SpaceWizards.Sdl" Version="1.0.0" />
+    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.1.0" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
+    <PackageVersion Include="libsodium" Version="1.0.20.1" />
+    <PackageVersion Include="System.Management" Version="9.0.8" />
     <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.26100.1" />
     <PackageVersion Include="TerraFX.Interop.Xlib" Version="6.4.0" />
     <PackageVersion Include="VorbisPizza" Version="1.3.0" />

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 -->
 

MSBuild/XamlIL.targets

@@ -16,7 +16,10 @@
 
   <ItemGroup>
     <ProjectReference Include="$(MSBuildThisFileDirectory)\..\Robust.Client.NameGenerator\Robust.Client.NameGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
-    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\Robust.Client.Injectors.csproj" ReferenceOutputAssembly="false"/>
+    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\Robust.Client.Injectors.csproj" ReferenceOutputAssembly="false">
+      <SetConfiguration Condition="'$(Configuration)' == 'DebugOpt'">Configuration=Debug</SetConfiguration>
+      <SetConfiguration Condition="'$(Configuration)' == 'Tools'">Configuration=Release</SetConfiguration>
+    </ProjectReference>
   </ItemGroup>
 
   <!-- XamlIL does not make use of special Robust configurations like DebugOpt. Convert these down. -->

RELEASE-NOTES.md

@@ -54,22 +54,627 @@ END TEMPLATE-->
 *None yet*
 
 
-## 255.1.2
+## 267.3.2
 
 
-## 255.1.1
+## 267.3.1
+
+
+## 267.3.0
+
+### New features
+
+* Sandbox:
+  * Added `System.DateOnly` and `System.TimeOnly`.
+* `MapId`, `MapCoordinates`, and `EntityCoordinates` are now yaml serialisable
+* The base component tree lookup system has new methods including several new `QueryAabb()` overloads that take in a collection and various new `IntersectRay()` overloads that should replace `IntersectRayWithPredicate`.
+ * Added `OccluderSystem.InRangeUnoccluded()` for checking for occluders that lie between two points.
+* `LocalizedCommands` now pass the command name as an argument to the localized help text.
+
+### Bugfixes
+
+* Fixed `MapLoaderSystem.SerializeEntitiesRecursive()` not properly serialising when given multiple root entities (e.g., multiple maps)
+* Fixed yaml hot reloading throwing invalid path exceptions.
+* The `EntityManager.CreateEntityUninitialized` overload that uses MapCoordinates now actually attaches entities to a grid if one is present at those coordinates, as was stated in it's documentation.
+* Fixed physics joint relays not being properly updated when an entity is removed from a container.
+
+### Other
+
+* Updated natives again to attempt to fix issues caused by the previous update.
+
+
+## 267.2.1
+
+
+## 267.2.0
+
+### New features
+
+* Sprites and Sprite layers have a new `Loop` data field that can be set to false to automatically pause animations once they have finished.
+
+### Bugfixes
+
+* Fixed `CollectionExtensions.TryGetValue` throwing an exception when given a negative list index.
+* Fixed `EntityManager.PredictedQueueDeleteEntity()` not deferring changes for networked entities until the end of the tick.
+* Fixed `EntityManager.IsQueuedForDeletion` not returning true foe entities getting deleted via `PredictedQueueDeleteEntity()`
+
+### Other
+
+* `IResourceManager.GetContentRoots()` has been obsoleted and returns no more results.
+
+### Internal
+
+* `IResourceManager.GetContentRoots()` has been replaced with a similar method on `IResourceManagerInternal`. This new method returns `string`s instead of `ResPath`s, and usage code has been updated to use these paths correctly.
+
+
+## 267.1.0
+
+### New features
+
+* Animation:
+  * `AnimationTrackProperty.KeyFrame` can now have easings functions applied.
+* Graphics:
+  * `PointLightComponent` now has two fields, `falloff` and `curveFactor`, for controlling light falloff and the shape of the light attenuation curve.
+  * `IClydeViewport` now has an `Id` and `ClearCachedResources` event. Together, these allow you to properly cache rendering resources per viewport.
+* Miscellaneous:
+  * Added `display.max_fps` CVar.
+  * Added `IGameTiming.FrameStartTime`.
+* Sandbox:
+  * Added `System.WeakReference<T>`.
+  * Added `SpaceWizards.Sodium.CryptoGenericHashBlake2B.Hash()`.
+  * Added `System.Globalization.UnicodeCategory`.
+* Serialization:
+  * Added a new entity yaml deserialization option (`SerializationOptions.EntityExceptionBehaviour`) that can optionally make deserialization more exception tolerant.
+* Tooling:
+  * `devwindow` now has a tab listing active `IRenderTarget`s, allowing insight into resource consumption.
+  * `loadgrid` now creates a map if passed an invalid map ID.
+  * Added game version information to F3 overlay.
+  * Added completions to more map commands.
+* UI system:
+  * `Control.OrderedChildCollection` (gotten from `.Children`) now implements `IReadOnlyList<Control>`, allowing it to be indexed directly.
+    * Added `WrapContainer` control. This lays out multiple elements along an axis, wrapping them if there's not enough space. It comes with many options and can handle multiple axes.
+  * Popups/modals now work in secondary windows. This entails putting roots for these on each UI root.
+  * If you are not using `OSWindow` and are instead creating secondary windows manually, you need to call `WindowRoot.CreateRootControls()` manually for this to work.
+  * Added `Axis` enum, `IAxisImplementation` interface and axis implementations. These allow writing general-purpose UI layout code that can work on multiple axis at once.
+* WebView:
+  * Added `web.remote_debug_port` CVar to change Chromium's remote debug port.
+
+### Bugfixes
+
+* Audio:
+  * Fix audio occlusion & velocity being calculated with the audio entity instead of the source entity.
+* Bound UI:
+  * Try to fix an assert related to `UserInterfaceComponent` delta states.
+* Configuration:
+  * The client no longer tries to send `CLIENT | REPLICATED` CVars when not connected to a server. This could cause test failures.
+* Math:
+  * Fixed `Matrix3Helpers.TransformBounds()` returning an incorrect result. Now it effectively behaves like `Matrix3Helpers.TransformBox()` and has been marked as obsolete.
+* Physics:
+  * Work around an undiagnosed crash processing entities without parents.
+* Serialization:
+  * Fix `[DataRecord]`s with computed get-only properties.
+* Resources:
+  * Fix some edge case broken path joining in `DirLoader` and `WritableDirProvider`.
+* Tests:
+  * Fix `PlacementManager.CurrentMousePosition` in integration tests.
+* UI system:
+  * Animations for the debug console and scrolling are no longer framerate dependent.
+  * Fix `OutputPanel.SetMessage` triggering a scrolling animation when editing messages other than the last one.
+  * Fix word wrapping with two-`char` runes in `RichTextLabel` and `OutputPanel`.
+* WebView:
+  * Multiple clients with WebView can now run at the same time, thanks to better CEF cache management.
+
+### Other
+
+* Audio:
+  * Improved error logging for invalid file names in `SharedAudioSystem`.
+* Configuration:
+  * Fix crash if more than 255 `REPLICATED` CVars exist. Also increased the max size of the CVar replication message.
+* Entities:
+  * Transform:
+    * `AnchorEntity` logs instead of using an assert for invalid arguments.
+  * Containers:
+    * `SharedContainerSystem.CleanContainer` now uses `PredictedDel()` instead.
+* Networking:
+  * The client now logs an error when attempting to send a network message without server connection. Previously, it would be silently dropped.
+  * `net.interp` and `net.buffer_size` CVars are now `REPLICATED`.
+* Graphics:
+  * The function used for pointlight attenuation has been modified to be c1 continuous as opposed to simply c0 continuous, resulting in smoother boundary behavior.
+  * RSI validator no longer allows empty (`""`) state names.
+* Packaging:
+  * Server packaging now excludes all files in the `Audio/` directory.
+  * Server packaging now excludes engine resources `EngineFonts/` and `Midi/`.
+  * ACZ explicitly specifies manifest charset as UTF-8.
+* Serialization:
+  * `CurTime`-relative `TimeSpan` values that are `MaxValue` now deserialize without overflow.
+  * `SpriteSpecifier.Texture` will now fail to validate if the path is inside a `.rsi`. Use RSI sprite specifiers instead.
+* Resources:
+  * `IWritableDirProvider.RootDir` is now null on clients.
+* WebView:
+  * CEF cache is no longer in the content-accessible user data directory.
+
+### Internal
+
+* Added some debug commands for debugging viewport resource management: `vp_clear_all_cached` & `vp_test_finalize`
+* `uitest` command now supports command argument for tab selection, like `uitest2`.
+* Rewrote `BoxContainer` implementation to make use of new axis system.
+* Moved `uitest2` and `devwindow` to use the `OSWindow` control.
+* SDL3 binding has been moved to `SpaceWizards.Sdl` NuGet package.
+* `dmetamem` command has been moved from `DEBUG` to `TOOLS`.
+* Consolidate `AttachToGridOrMap` with `TryGetMapOrGridCoordinates`.
+* Secondary window render targets have clear names specified.
+* Updated `SpaceWizards.NFluidsynth` to `0.2.2`.
+* `Robust.Client.WebView.Cef.Program` is now internal.
+* `download_manifest_file.py` script in repo now always decodes as UTF-8 correctly.
+* Added a new debug assert to game state processing.
+
+## 267.0.0
+
+### Breaking changes
+
+* When a player disconnects, the relevant callbacks are now fired *after* removing the channel from `INetManager`.
+
+### New features
+
+* Engine builds are now published for ARM64 & FreeBSD.
+* CPU model names are now detected on Windows & Linux ARM64.
+* Toolshed's `spawn:in` command now works on entities without `Physics` component.
+
+### Bugfixes
+
+* SDL3 windowing backend fixes:
+  * Avoid macOS freezes with multiple windows.
+  * Fix macOS rendering breaking when closing secondary windows.
+  * File dialogs properly associate parent windows.
+  * Fix IME positions not working with UI scaling properly.
+  * Properly specify library names for loading native library.
+
+* WinBit threads don't permanently stay stuck when their window closes.
+* Checking for the "`null`" literal in serialization is now culture invariant.
+
+### Other
+
+* Compat mode on the client now defaults to on for Windows Snapdragon devices, to work around driver bugs.
+* Update various libraries & natives. This enables out-of-the-box ARM64 support on all platforms and is a long-overdue modernization.
+* Key name displays now use proper Unicode symbols for macOS ⌥ and ⌘.
+* Automated CI for RobustToolbox runs on macOS again.
+* Autocompletions for `ProtoId<T>` in Toolshed now use `PrototypeIdsLimited` instead of arbitrarily cutting out if more than 256 of a prototype exists.
+
+
+## 266.0.0
+
+### Breaking changes
+
+* A new analyzer has been added that will error if you attempt to subscribe to `AfterAutoHandleStateEvent` on a
+  component that doesn't have the `AutoGenerateComponentState` attribute, or doesn't have the first argument of that
+  attribute set to `true`. In most cases you will want to set said argument to `true`.
+* The fields on `AutoGenerateComponentStateAttribute` are now `readonly`. Setting these directly (instead of using the constructor arguments) never worked in the first place, so this change only catches existing programming errors.
+* When a player disconnects, `ISharedPlayerManager.PlayerStatusChanged` is now fired *after* removing the session from the `Sessions` list.
+* `.rsi` files are now compacted into individual `.rsic` files on packaging. This should significantly reduce file count & improve performance all over release builds, but breaks the ability to access `.png` files into RSIs directly. To avoid this, `"rsic": false` can be specified in the RSI's JSON metadata.
+* The `scale` command has been removed, with the intent of it being moved to content instead.
+
+### New features
+
+* ViewVariables editors for `ProtoId` fields now have a Select button which opens a window listing all available prototypes of the appropriate type.
+* added **IConfigurationManager**.*SubscribeMultiple* ext. method to provide simpler way to unsubscribe from multiple cvar at once
+* Added `SharedMapSystem.QueueDeleteMap`, which deletes a map with the specified MapId in the next tick.
+* Added generic version of `ComponentRegistry.TryGetComponent`.
+* `AttributeHelper.HasAttribute` has had an overload's type signature loosened from `INamedTypeSymbol` to `ITypeSymbol`.
+* Errors are now logged when sending messages to disconnected `INetChannel`s.
+* Warnings are now logged if sending a message via Lidgren failed for some reason.
+* `.yml` and `.ftl` files in the same directory are now concatenated onto each other, to reduce file count in packaged builds. This is done through the new `AssetPassMergeTextDirectories` pass.
+* Added `System.Linq.ImmutableArrayExtensions` to sandbox.
+* `ImmutableDictionary<TKey, TValue>` and `ImmutableHashSet<T>` can now be network serialized.
+* `[AutoPausedField]` now works on fields of type `Dictionary<TKey, TimeSpan>`.
+* `[NotYamlSerializable]` analyzer now detects nullable fields of the not-serializable type.
+* `ItemList` items can now have a scale applied for the icon.
+* Added new OS mouse cursor shapes for the SDL3 backend. These are not available on the GLFW backend.
+* Added `IMidiRenderer.MinVolume` to scale the volume of MIDI notes.
+* Added `SharedPhysicsSystem.ScaleFixtures`, to apply the physics-only changes of the prior `scale` command.
+
+### Bugfixes
+
+* `LayoutContainer.SetMarginsPreset` and `SetAnchorAndMarginPreset` now correctly use the provided control's top anchor when calculating the margins for its presets; it previously used the bottom anchor instead. This may result in a few UI differences, by a few pixels at most.
+* `IConfigurationManager` no longer logs a warning when saving configuration in an integration test.
+* Fixed impossible-to-source `ChannelClosedException`s when sending some net messages to disconnected `INetChannel`s.
+* Fixed an edge case causing some color values to throw an error in `ColorNaming`.
+* Fresh builds from specific projects should no longer cause errors related to `Robust.Client.Injectors` not being found.
+* Stopped errors getting logged about `NoteOff` and `NoteOn` operations failing in MIDI.
+* Fixed MIDI players not resuming properly when re-entering PVS range.
+
+### Other
+
+* Updated ImageSharp to 3.1.11 to stop the warning about a DoS vulnerability.
+* Prototype YAML documents that are completely empty are now skipped by the prototype loader. Previously they would cause a load error for the whole file.
+* `TileSpawnWindow` can now be localized.
+* `BaseWindow` uses the new mouse cursor shapes for diagonal resizing.
+* `NFluidsynth` has been updated to 0.2.0
+
+### Internal
+
+* Added `uitest` tab for standard mouse cursor shapes.
+
+
+## 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/_generic.ftl

@@ -0,0 +1,3 @@
+generic-map = map
+generic-grid = grid
+generic-mapid = map Id

Resources/Locale/en-US/client-state-commands.ftl

@@ -1,16 +1,16 @@
 # Loc strings for various entity state & client-side PVS related commands
 
-cmd-reset-ent-help = Usage: resetent <Entity UID>
-cmd-reset-ent-desc = Reset an entity to the most recently received server state. This will also reset entities that have been detached to null-space. 
+cmd-reset-ent-help = Usage: {$command} <Entity UID>
+cmd-reset-ent-desc = Reset an entity to the most recently received server state. This will also reset entities that have been detached to null-space.
 
-cmd-reset-all-ents-help = Usage: resetallents
-cmd-reset-all-ents-desc = Resets all entities to the most recently received server state. This only impacts entities that have not been detached to null-space. 
+cmd-reset-all-ents-help = Usage: {$command}
+cmd-reset-all-ents-desc = Resets all entities to the most recently received server state. This only impacts entities that have not been detached to null-space.
 
-cmd-detach-ent-help = Usage: detachent <Entity UID>
+cmd-detach-ent-help = Usage: {$command} <Entity UID>
 cmd-detach-ent-desc = Detach an entity to null-space, as if it had left PVS range.
 
-cmd-local-delete-help = Usage: localdelete <Entity UID>
+cmd-local-delete-help = Usage: {$command} <Entity UID>
 cmd-local-delete-desc = Deletes an entity. Unlike the normal delete command, this is CLIENT-SIDE. Unless the entity is a client-side entity, this will likely cause errors.
 
-cmd-full-state-reset-help = Usage: fullstatereset
+cmd-full-state-reset-help = Usage: {$command}
 cmd-full-state-reset-desc = Discards any entity state information and requests a full-state from the server.

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

@@ -0,0 +1,33 @@
+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-unknown = unknown color, you should not see this
+
+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/commands.ftl

@@ -23,8 +23,8 @@ cmd-error-dir-not-found = Could not find directory: {$dir}.
 cmd-failure-no-attached-entity = There is no entity attached to this shell.
 
 ## 'help' command
-cmd-help-desc = Display general help or help text for a specific command
-cmd-help-help = Usage: help [command name]
+cmd-help-desc = Display general help or help text for a specific command.
+cmd-help-help = Usage: {$command} [command name]
     When no command name is provided, displays general-purpose help text. If a command name is provided, displays help text for that command.
 
 cmd-help-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
@@ -35,7 +35,7 @@ cmd-help-arg-cmdname = [command name]
 
 ## 'cvar' command
 cmd-cvar-desc = Gets or sets a CVar.
-cmd-cvar-help = Usage: cvar <name | ?> [value]
+cmd-cvar-help = Usage: {$command} <name | ?> [value]
     If a value is passed, the value is parsed and stored as the new value of the CVar.
     If not, the current value of the CVar is displayed.
     Use 'cvar ?' to get a list of all registered CVars.
@@ -49,14 +49,14 @@ cmd-cvar-value-hidden = <value hidden>
 
 ## 'cvar_subs' command
 cmd-cvar_subs-desc = Lists the OnValueChanged subscriptions for a CVar.
-cmd-cvar_subs-help = Usage: cvar_subs <name>
+cmd-cvar_subs-help = Usage: {$command} <name>
 
 cmd-cvar_subs-invalid-args = Must provide exactly one argument.
 cmd-cvar_subs-arg-name = <name>
 
 ## 'list' command
-cmd-list-desc = Lists available commands, with optional search filter
-cmd-list-help = Usage: list [filter]
+cmd-list-desc = Lists available commands, with optional search filter.
+cmd-list-help = Usage: {$command} [filter]
     Lists all available commands. If an argument is provided, it will be used to filter commands by name.
 
 cmd-list-heading = SIDE NAME            DESC{"\u000A"}-------------------------{"\u000A"}
@@ -64,13 +64,13 @@ cmd-list-heading = SIDE NAME            DESC{"\u000A"}-------------------------{
 cmd-list-arg-filter = [filter]
 
 ## '>' command, aka remote exec
-cmd-remoteexec-desc = Executes server-side commands
+cmd-remoteexec-desc = Executes server-side commands.
 cmd-remoteexec-help = Usage: > <command> [arg] [arg] [arg...]
     Executes a command on the server. This is necessary if a command with the same name exists on the client, as simply running the command would run the client command first.
 
 ## 'gc' command
-cmd-gc-desc = Run the GC (Garbage Collector)
-cmd-gc-help = Usage: gc [generation]
+cmd-gc-desc = Run the GC (Garbage Collector).
+cmd-gc-help = Usage: {$command} [generation]
     Uses GC.Collect() to execute the Garbage Collector.
     If an argument is provided, it is parsed as a GC generation number and GC.Collect(int) is used.
     Use the 'gfc' command to do an LOH-compacting full GC.
@@ -79,13 +79,13 @@ cmd-gc-arg-generation = [generation]
 
 ## 'gcf' command
 cmd-gcf-desc = Run the GC, fully, compacting LOH and everything.
-cmd-gcf-help = Usage: gcf
+cmd-gcf-help = Usage: {$command}
     Does a full GC.Collect(2, GCCollectionMode.Forced, true, true) while also compacting LOH.
     This will probably lock up for hundreds of milliseconds, be warned.
 
 ## 'gc_mode' command
-cmd-gc_mode-desc = Change/Read the GC Latency mode
-cmd-gc_mode-help = Usage: gc_mode [type]
+cmd-gc_mode-desc = Change/Read the GC Latency mode.
+cmd-gc_mode-help = Usage: {$command} [type]
     If no argument is provided, returns the current GC latency mode.
     If an argument is passed, it is parsed as GCLatencyMode and set as the GC latency mode.
 
@@ -98,8 +98,8 @@ cmd-gc_mode-result = resulting gc latency mode: { $mode }
 cmd-gc_mode-arg-type = [type]
 
 ## 'mem' command
-cmd-mem-desc = Prints managed memory info
-cmd-mem-help = Usage: mem
+cmd-mem-desc = Prints managed memory info.
+cmd-mem-help = Usage: {$command}
 
 cmd-mem-report = Heap Size: { TOSTRING($heapSize, "N0") }
     Total Allocated: { TOSTRING($totalAllocated, "N0") }
@@ -108,26 +108,26 @@ cmd-mem-report = Heap Size: { TOSTRING($heapSize, "N0") }
 cmd-physics-overlay = {$overlay} is not a recognised overlay
 
 ## 'lsasm' command
-cmd-lsasm-desc = Lists loaded assemblies by load context
+cmd-lsasm-desc = Lists loaded assemblies by load context.
 cmd-lsasm-help = Usage: lsasm
 
 ## 'exec' command
-cmd-exec-desc = Executes a script file from the game's writeable user data
-cmd-exec-help = Usage: exec <fileName>
+cmd-exec-desc = Executes a script file from the game's writeable user data.
+cmd-exec-help = Usage: {$command} <fileName>
     Each line in the file is executed as a single command, unless it starts with a #
 
 cmd-exec-arg-filename = <fileName>
 
 ## 'dump_net_comps' command
 cmd-dump_net_comps-desc = Prints the table of networked components.
-cmd-dump_net_comps-help = Usage: dump_net-comps
+cmd-dump_net_comps-help = Usage: {$command}
 
 cmd-dump_net_comps-error-writeable = Registration still writeable, network ids have not been generated.
 cmd-dump_net_comps-header = Networked Component Registrations:
 
 ## 'dump_event_tables' command
 cmd-dump_event_tables-desc = Prints directed event tables for an entity.
-cmd-dump_event_tables-help = Usage: dump_event_tables <entityUid>
+cmd-dump_event_tables-help = Usage: {$command} <entityUid>
 
 cmd-dump_event_tables-missing-arg-entity = Missing entity argument
 cmd-dump_event_tables-error-entity = Invalid entity
@@ -135,7 +135,7 @@ cmd-dump_event_tables-arg-entity = <entityUid>
 
 ## 'monitor' command
 cmd-monitor-desc = Toggles a debug monitor in the F3 menu.
-cmd-monitor-help = Usage: monitor <name>
+cmd-monitor-help = Usage: {$command} <name>
     Possible monitors are: { $monitors }
     You can also use the special values "-all" and "+all" to hide or show all monitors, respectively.
 
@@ -148,13 +148,13 @@ cmd-monitor-plus-all-hint = Shows all monitors
 
 ## 'setambientlight' command
 cmd-set-ambient-light-desc = Allows you to set the ambient light for the specified map, in SRGB.
-cmd-set-ambient-light-help = setambientlight [mapid] [r g b a]
+cmd-set-ambient-light-help = Usage: {$command} [mapid] [r g b a]
 cmd-set-ambient-light-parse = Unable to parse args as a byte values for a color.
 
 ## Mapping commands
 
 cmd-savemap-desc = Serializes a map to disk. Will not save a post-init map unless forced.
-cmd-savemap-help = savemap <MapID> <Path> [force]
+cmd-savemap-help = Usage: {$command} <MapID> <Path> [force]
 cmd-savemap-not-exist = Target map does not exist.
 cmd-savemap-init-warning = Attempted to save a post-init map without forcing the save.
 cmd-savemap-attempt = Attempting to save map {$mapId} to {$path}.
@@ -165,7 +165,7 @@ cmd-hint-savemap-path = <Path>
 cmd-hint-savemap-force = [bool]
 
 cmd-loadmap-desc = Loads a map from disk into the game.
-cmd-loadmap-help = loadmap <MapID> <Path> [x] [y] [rotation] [consistentUids]
+cmd-loadmap-help = Usage: {$command} <MapID> <Path> [x] [y] [rotation] [consistentUids]
 cmd-loadmap-nullspace = You cannot load into map 0.
 cmd-loadmap-exists = Map {$mapId} already exists.
 cmd-loadmap-success = Map {$mapId} has been loaded from {$path}.
@@ -180,73 +180,74 @@ cmd-hint-savebp-id = <Grid EntityID>
 ## 'flushcookies' command
 # Note: the flushcookies command is from Robust.Client.WebView, it's not in the main engine code.
 
-cmd-flushcookies-desc = Flush CEF cookie storage to disk
-cmd-flushcookies-help = This ensure cookies are properly saved to disk in the event of unclean shutdowns.
+cmd-flushcookies-desc = Flush CEF cookie storage to disk.
+cmd-flushcookies-help = Usage: {$command}
+    This ensure cookies are properly saved to disk in the event of unclean shutdowns.
     Note that the actual operation is asynchronous.
 
 cmd-ldrsc-desc = Pre-caches a resource.
-cmd-ldrsc-help = Usage: ldrsc <path> <type>
+cmd-ldrsc-help = Usage: {$command} <path> <type>
 
 cmd-rldrsc-desc = Reloads a resource.
-cmd-rldrsc-help = Usage: rldrsc <path> <type>
+cmd-rldrsc-help = Usage: {$command} <path> <type>
 
 cmd-gridtc-desc = Gets the tile count of a grid.
-cmd-gridtc-help = Usage: gridtc <gridId>
+cmd-gridtc-help = Usage: {$command} <gridId>
 
 
 # Client-side commands
 cmd-guidump-desc = Dump GUI tree to /guidump.txt in user data.
-cmd-guidump-help = Usage: guidump
+cmd-guidump-help = Usage: {$command}
 
-cmd-uitest-desc = Open a dummy UI testing window
-cmd-uitest-help = Usage: uitest
+cmd-uitest-desc = Open a dummy UI testing window.
+cmd-uitest-help = Usage: {$command}
 
 ## 'uitest2' command
-cmd-uitest2-desc = Opens a UI control testing OS window
-cmd-uitest2-help = Usage: uitest2 <tab>
+cmd-uitest2-desc = Opens a UI control testing OS window.
+cmd-uitest2-help = Usage: {$command} <tab>
 cmd-uitest2-arg-tab = <tab>
 cmd-uitest2-error-args = Expected at most one argument
 cmd-uitest2-error-tab = Invalid tab: '{$value}'
 cmd-uitest2-title = UITest2
 
 
-cmd-setclipboard-desc = Sets the system clipboard
-cmd-setclipboard-help = Usage: setclipboard <text>
+cmd-setclipboard-desc = Sets the system clipboard.
+cmd-setclipboard-help = Usage: {$command} <text>
 
-cmd-getclipboard-desc = Gets the system clipboard
-cmd-getclipboard-help = Usage: Getclipboard
+cmd-getclipboard-desc = Gets the system clipboard.
+cmd-getclipboard-help = Usage: {$command}
 
 cmd-togglelight-desc = Toggles light rendering.
-cmd-togglelight-help = Usage: togglelight
+cmd-togglelight-help = Usage: {$command}
 
 cmd-togglefov-desc = Toggles fov for client.
-cmd-togglefov-help = Usage: togglefov
+cmd-togglefov-help = Usage: {$command}
 
 cmd-togglehardfov-desc = Toggles hard fov for client. (for debugging space-station-14#2353)
-cmd-togglehardfov-help = Usage: togglehardfov
+cmd-togglehardfov-help = Usage: {$command}
 
 cmd-toggleshadows-desc = Toggles shadow rendering.
-cmd-toggleshadows-help = Usage: toggleshadows
+cmd-toggleshadows-help = Usage: {$command}
 
 cmd-togglelightbuf-desc = Toggles lighting rendering. This includes shadows but not FOV.
-cmd-togglelightbuf-help = Usage: togglelightbuf
+cmd-togglelightbuf-help = Usage: {$command}
 
 cmd-chunkinfo-desc = Gets info about a chunk under your mouse cursor.
-cmd-chunkinfo-help = Usage: chunkinfo
+cmd-chunkinfo-help = Usage: {$command}
 
 cmd-rldshader-desc = Reloads all shaders.
-cmd-rldshader-help = Usage: rldshader
+cmd-rldshader-help = Usage: {$command}
 
 cmd-cldbglyr-desc = Toggle fov and light debug layers.
-cmd-cldbglyr-help= Usage: cldbglyr <layer>: Toggle <layer>
+cmd-cldbglyr-help= Usage: {$command} <layer>: Toggle <layer>
     cldbglyr: Turn all Layers off
 
 cmd-key-info-desc = Keys key info for a key.
-cmd-key-info-help = Usage: keyinfo <Key>
+cmd-key-info-help = Usage: {$command} <Key>
 
 ## 'bind' command
 cmd-bind-desc = Binds an input key combination to an input command.
-cmd-bind-help = Usage: bind { cmd-bind-arg-key } { cmd-bind-arg-mode } { cmd-bind-arg-command }
+cmd-bind-help = Usage: {$command} { cmd-bind-arg-key } { cmd-bind-arg-mode } { cmd-bind-arg-command }
     Note that this DOES NOT automatically save bindings.
     Use the 'svbind' command to save binding configuration.
 
@@ -255,319 +256,322 @@ cmd-bind-arg-mode = <BindMode>
 cmd-bind-arg-command = <InputCommand>
 
 cmd-net-draw-interp-desc = Toggles the debug drawing of the network interpolation.
-cmd-net-draw-interp-help = Usage: net_draw_interp
+cmd-net-draw-interp-help = Usage: {$command}
 
 cmd-net-watch-ent-desc = Dumps all network updates for an EntityId to the console.
-cmd-net-watch-ent-help = Usage: net_watchent <0|EntityUid>
+cmd-net-watch-ent-help = Usage: {$command} <0|EntityUid>
 
 cmd-net-refresh-desc = Requests a full server state.
-cmd-net-refresh-help = Usage: net_refresh
+cmd-net-refresh-help = Usage: {$command}
 
 cmd-net-entity-report-desc = Toggles the net entity report panel.
-cmd-net-entity-report-help = Usage: net_entityreport
+cmd-net-entity-report-help = Usage: {$command}
 
 cmd-fill-desc = Fill up the console for debugging.
-cmd-fill-help = Fills the console with some nonsense for debugging.
+cmd-fill-help = Usage: {$command}
+                Fills the console with some nonsense for debugging.
 
 cmd-cls-desc = Clears the console.
-cmd-cls-help = Clears the debug console of all messages.
+cmd-cls-help = Usage: {$command}
+               Clears the debug console of all messages.
 
 cmd-sendgarbage-desc = Sends garbage to the server.
-cmd-sendgarbage-help = The server will reply with 'no u'
+cmd-sendgarbage-help = Usage: {$command}
+                       The server will reply with 'no u'
 
 cmd-loadgrid-desc = Loads a grid from a file into an existing map.
-cmd-loadgrid-help = loadgrid <MapID> <Path> [x y] [rotation] [storeUids]
+cmd-loadgrid-help = Usage: {$command} <MapID> <Path> [x y] [rotation] [storeUids]
 
 cmd-loc-desc = Prints the absolute location of the player's entity to console.
-cmd-loc-help = loc
+cmd-loc-help = Usage: {$command}
 
 cmd-tpgrid-desc = Teleports a grid to a new location.
-cmd-tpgrid-help = tpgrid <gridId> <X> <Y> [<MapId>]
+cmd-tpgrid-help = Usage: {$command} <gridId> <X> <Y> [<MapId>]
 
 cmd-rmgrid-desc = Removes a grid from a map. You cannot remove the default grid.
-cmd-rmgrid-help = rmgrid <gridId>
+cmd-rmgrid-help = Usage: {$command} <gridId>
 
 cmd-mapinit-desc = Runs map init on a map.
-cmd-mapinit-help = mapinit <mapID>
+cmd-mapinit-help = Usage: {$command} <mapID>
 
 cmd-lsmap-desc = Lists maps.
-cmd-lsmap-help = lsmap
+cmd-lsmap-help = Usage: {$command}
 
 cmd-lsgrid-desc = Lists grids.
-cmd-lsgrid-help = lsgrid
+cmd-lsgrid-help = Usage: {$command}
 
 cmd-addmap-desc = Adds a new empty map to the round. If the mapID already exists, this command does nothing.
-cmd-addmap-help = addmap <mapID> [pre-init]
+cmd-addmap-help = Usage: {$command} <mapID> [pre-init]
 
 cmd-rmmap-desc = Removes a map from the world. You cannot remove nullspace.
-cmd-rmmap-help = rmmap <mapId>
+cmd-rmmap-help = Usage: {$command} <mapId>
 
 cmd-savegrid-desc = Serializes a grid to disk.
-cmd-savegrid-help = savegrid <gridID> <Path>
+cmd-savegrid-help = Usage: {$command} <gridID> <Path>
 
 cmd-testbed-desc = Loads a physics testbed on the specified map.
-cmd-testbed-help = testbed <mapid> <test>
+cmd-testbed-help = Usage: {$command} <mapid> <test>
 
 ## 'flushcookies' command
 # Note: the flushcookies command is from Robust.Client.WebView, it's not in the main engine code.
 
 ## 'addcomp' command
 cmd-addcomp-desc = Adds a component to an entity.
-cmd-addcomp-help = addcomp <uid> <componentName>
+cmd-addcomp-help = Usage: {$command} <uid> <componentName>
 cmd-addcompc-desc = Adds a component to an entity on the client.
-cmd-addcompc-help = addcompc <uid> <componentName>
+cmd-addcompc-help = Usage: {$command} <uid> <componentName>
 
 ## 'rmcomp' command
 cmd-rmcomp-desc = Removes a component from an entity.
-cmd-rmcomp-help = rmcomp <uid> <componentName>
+cmd-rmcomp-help = Usage: {$command} <uid> <componentName>
 cmd-rmcompc-desc = Removes a component from an entity on the client.
-cmd-rmcompc-help = rmcomp <uid> <componentName>
+cmd-rmcompc-help = Usage: {$command} <uid> <componentName>
 
 ## 'addview' command
 cmd-addview-desc = Allows you to subscribe to an entity's view for debugging purposes.
-cmd-addview-help = addview <entityUid>
+cmd-addview-help = Usage: {$command} <entityUid>
 cmd-addviewc-desc = Allows you to subscribe to an entity's view for debugging purposes.
-cmd-addviewc-help = addview <entityUid>
+cmd-addviewc-help = Usage: {$command} <entityUid>
 
 ## 'removeview' command
 cmd-removeview-desc = Allows you to unsubscribe to an entity's view for debugging purposes.
-cmd-removeview-help = removeview <entityUid>
+cmd-removeview-help = Usage: {$command} <entityUid>
 
 ## 'loglevel' command
 cmd-loglevel-desc = Changes the log level for a provided sawmill.
-cmd-loglevel-help = Usage: loglevel <sawmill> <level>
+cmd-loglevel-help = Usage: {$command} <sawmill> <level>
       sawmill: A label prefixing log messages. This is the one you're setting the level for.
       level: The log level. Must match one of the values of the LogLevel enum.
 
 cmd-testlog-desc = Writes a test log to a sawmill.
-cmd-testlog-help = Usage: testlog <sawmill> <level> <message>
+cmd-testlog-help = Usage: {$command} <sawmill> <level> <message>
     sawmill: A label prefixing the logged message.
     level: The log level. Must match one of the values of the LogLevel enum.
     message: The message to be logged. Wrap this in double quotes if you want to use spaces.
 
 ## 'vv' command
 cmd-vv-desc = Opens View Variables.
-cmd-vv-help = Usage: vv <entity ID|IoC interface name|SIoC interface name>
+cmd-vv-help = Usage: {$command} <entity ID|IoC interface name|SIoC interface name>
 
 ## 'showvelocities' command
 cmd-showvelocities-desc = Displays your angular and linear velocities.
-cmd-showvelocities-help = Usage: showvelocities
+cmd-showvelocities-help = Usage: {$command}
 
 ## 'setinputcontext' command
 cmd-setinputcontext-desc = Sets the active input context.
-cmd-setinputcontext-help = Usage: setinputcontext <context>
+cmd-setinputcontext-help = Usage: {$command} <context>
 
 ## 'forall' command
 cmd-forall-desc = Runs a command over all entities with a given component.
-cmd-forall-help = Usage: forall <bql query> do <command...>
+cmd-forall-help = Usage: {$command} <bql query> do <command...>
 
 ## 'delete' command
 cmd-delete-desc = Deletes the entity with the specified ID.
-cmd-delete-help = delete <entity UID>
+cmd-delete-help = Usage: {$command} <entity UID>
 
 # System commands
 cmd-showtime-desc = Shows the server time.
-cmd-showtime-help = showtime
+cmd-showtime-help = Usage: {$command}
 
 cmd-restart-desc = Gracefully restarts the server (not just the round).
-cmd-restart-help = restart
+cmd-restart-help = Usage: {$command}
 
 cmd-shutdown-desc = Gracefully shuts down the server.
-cmd-shutdown-help = shutdown
+cmd-shutdown-help = Usage: {$command}
 
 cmd-saveconfig-desc = Saves the server configuration to the config file.
-cmd-saveconfig-help = saveconfig
+cmd-saveconfig-help = Usage: {$command}
 
 cmd-netaudit-desc = Prints into about NetMsg security.
-cmd-netaudit-help = netaudit
+cmd-netaudit-help = Usage: {$command}
 
 # Player commands
 cmd-tp-desc = Teleports a player to any location in the round.
-cmd-tp-help = tp <x> <y> [<mapID>]
+cmd-tp-help = Usage: {$command} <x> <y> [<mapID>]
 
 cmd-tpto-desc = Teleports the current player or the specified players/entities to the location of the first player/entity.
-cmd-tpto-help = tpto <username|uid> [username|NetEntity]...
+cmd-tpto-help = Usage: {$command} <username|uid> [username|NetEntity]...
 cmd-tpto-destination-hint = destination (NetEntity or username)
 cmd-tpto-victim-hint = entity to teleport (NetEntity or username)
 cmd-tpto-parse-error = Cant resolve entity or player: {$str}
 
 cmd-listplayers-desc = Lists all players currently connected.
-cmd-listplayers-help = listplayers
+cmd-listplayers-help = Usage: {$command}
 
 cmd-kick-desc = Kicks a connected player out of the server, disconnecting them.
-cmd-kick-help = kick <PlayerIndex> [<Reason>]
+cmd-kick-help = Usage: {$command} <PlayerIndex> [<Reason>]
 
 # Spin command
 cmd-spin-desc = Causes an entity to spin. Default entity is the attached player's parent.
-cmd-spin-help = spin velocity [drag] [entityUid]
+cmd-spin-help = Usage: {$command} velocity [drag] [entityUid]
 
 # Localization command
 cmd-rldloc-desc = Reloads localization (client & server).
-cmd-rldloc-help = Usage: rldloc
+cmd-rldloc-help = Usage: {$command}
 
 # Debug entity controls
 cmd-spawn-desc = Spawns an entity with specific type.
-cmd-spawn-help = spawn <prototype> OR spawn <prototype> <relative entity ID> OR spawn <prototype> <x> <y>
+cmd-spawn-help = Usage: {$command} <prototype> | {$command} <prototype> <relative entity ID> | {$command} <prototype> <x> <y>
 cmd-cspawn-desc = Spawns a client-side entity with specific type at your feet.
-cmd-cspawn-help = cspawn <entity type>
-
-cmd-scale-desc = Increases or decreases an entity's size naively.
-cmd-scale-help = scale <entityUid> <float>
+cmd-cspawn-help = Usage: {$command} <entity type>
 
 cmd-dumpentities-desc = Dump entity list.
-cmd-dumpentities-help = Dumps entity list of UIDs and prototype.
+cmd-dumpentities-help = Usage: {$command}
+                        Dumps entity list of UIDs and prototype.
 
 cmd-getcomponentregistration-desc = Gets component registration information.
-cmd-getcomponentregistration-help = Usage: getcomponentregistration <componentName>
+cmd-getcomponentregistration-help = Usage: {$command} <componentName>
 
 cmd-showrays-desc = Toggles debug drawing of physics rays. An integer for <raylifetime> must be provided.
-cmd-showrays-help = Usage: showrays <raylifetime>
+cmd-showrays-help = Usage: {$command} <raylifetime>
 
 cmd-disconnect-desc = Immediately disconnect from the server and go back to the main menu.
-cmd-disconnect-help = Usage: disconnect
+cmd-disconnect-help = Usage: {$command}
 
 cmd-entfo-desc = Displays verbose diagnostics for an entity.
-cmd-entfo-help = Usage: entfo <entityuid>
+cmd-entfo-help = Usage: {$command} <entityuid>
     The entity UID can be prefixed with 'c' to convert it to a client entity UID.
 
-cmd-fuck-desc = Throws an exception
-cmd-fuck-help = Usage: fuck
+cmd-fuck-desc = Throws an exception.
+cmd-fuck-help = Usage: {$command}
 
 cmd-showpos-desc = Show the position of all entities on the screen.
-cmd-showpos-help = Usage: showpos
+cmd-showpos-help = Usage: {$command}
 
 cmd-showrot-desc = Show the rotation of all entities on the screen.
-cmd-showrot-help = Usage: showrot
+cmd-showrot-help = Usage: {$command}
 
 cmd-showvel-desc = Show the local velocity of all entites on the screen.
-cmd-showvel-help = Usage: showvel
+cmd-showvel-help = Usage: {$command}
 
 cmd-showangvel-desc = Show the angular velocity of all entities on the screen.
-cmd-showangvel-help = Usage: showangvel
+cmd-showangvel-help = Usage: {$command}
 
 cmd-sggcell-desc = Lists entities on a snap grid cell.
-cmd-sggcell-help = Usage: sggcell <gridID> <vector2i>\nThat vector2i param is in the form x<int>,y<int>.
+cmd-sggcell-help = Usage: {$command} <gridID> <vector2i>\nThat vector2i param is in the form x<int>,y<int>.
 
 cmd-overrideplayername-desc = Changes the name used when attempting to connect to the server.
-cmd-overrideplayername-help = Usage: overrideplayername <name>
+cmd-overrideplayername-help = Usage: {$command} <name>
 
-cmd-showanchored-desc = Shows anchored entities on a particular tile
-cmd-showanchored-help = Usage: showanchored
+cmd-showanchored-desc = Shows anchored entities on a particular tile.
+cmd-showanchored-help = Usage: {$command}
 
 cmd-dmetamem-desc = Dumps a type's members in a format suitable for the sandbox configuration file.
-cmd-dmetamem-help = Usage: dmetamem <type>
+cmd-dmetamem-help = Usage: {$command} <type>
 
 cmd-launchauth-desc = Load authentication tokens from launcher data to aid in testing of live servers.
-cmd-launchauth-help = Usage: launchauth <account name>
+cmd-launchauth-help = Usage: {$command} <account name>
 
 cmd-lightbb-desc = Toggles whether to show light bounding boxes.
-cmd-lightbb-help = Usage: lightbb
+cmd-lightbb-help = Usage: {$command}
 
-cmd-monitorinfo-desc = Monitors info
-cmd-monitorinfo-help = Usage: monitorinfo <id>
+cmd-monitorinfo-desc = Monitors info.
+cmd-monitorinfo-help = Usage: {$command} <id>
 
-cmd-setmonitor-desc = Set monitor
-cmd-setmonitor-help = Usage: setmonitor <id>
+cmd-setmonitor-desc = Set monitor.
+cmd-setmonitor-help = Usage: {$command} <id>
 
 cmd-physics-desc = Shows a debug physics overlay. The arg supplied specifies the overlay.
-cmd-physics-help = Usage: physics <aabbs / com / contactnormals / contactpoints / distance / joints / shapeinfo / shapes>
+cmd-physics-help = Usage: {$command} <aabbs / com / contactnormals / contactpoints / distance / joints / shapeinfo / shapes>
 
 cmd-hardquit-desc = Kills the game client instantly.
-cmd-hardquit-help = Kills the game client instantly, leaving no traces. No telling the server goodbye.
+cmd-hardquit-help = Usage: {$command}
+                    Kills the game client instantly, leaving no traces. No telling the server goodbye.
 
 cmd-quit-desc = Shuts down the game client gracefully.
-cmd-quit-help = Properly shuts down the game client, notifying the connected server and such.
+cmd-quit-help = Usage: {$command}
+                Properly shuts down the game client, notifying the connected server and such.
 
 cmd-csi-desc = Opens a C# interactive console.
-cmd-csi-help = Usage: csi
+cmd-csi-help = Usage: {$command}
 
 cmd-scsi-desc = Opens a C# interactive console on the server.
-cmd-scsi-help = Usage: scsi
+cmd-scsi-help = Usage: {$command}
 
 cmd-watch-desc = Opens a variable watch window.
-cmd-watch-help = Usage: watch
+cmd-watch-help = Usage: {$command}
 
-cmd-showspritebb-desc = Toggle whether sprite bounds are shown
-cmd-showspritebb-help = Usage: showspritebb
+cmd-showspritebb-desc = Toggle whether sprite bounds are shown.
+cmd-showspritebb-help = Usage: {$command}
 
 cmd-togglelookup-desc = Shows / hides entitylookup bounds via an overlay.
-cmd-togglelookup-help = Usage: togglelookup
+cmd-togglelookup-help = Usage: {$command}
 
 cmd-net_entityreport-desc = Toggles the net entity report panel.
-cmd-net_entityreport-help = Usage: net_entityreport
+cmd-net_entityreport-help = Usage: {$command}
 
 cmd-net_refresh-desc = Requests a full server state.
-cmd-net_refresh-help = Usage: net_refresh
+cmd-net_refresh-help = Usage: {$command}
 
 cmd-net_graph-desc = Toggles the net statistics panel.
-cmd-net_graph-help = Usage: net_graph
+cmd-net_graph-help = Usage: {$command}
 
 cmd-net_watchent-desc = Dumps all network updates for an EntityId to the console.
-cmd-net_watchent-help = Usage: net_watchent <0|EntityUid>
+cmd-net_watchent-help = Usage: {$command} <0|EntityUid>
 
 cmd-net_draw_interp-desc = Toggles the debug drawing of the network interpolation.
-cmd-net_draw_interp-help = Usage: net_draw_interp <0|EntityUid>
+cmd-net_draw_interp-help = Usage: {$command} <0|EntityUid>
 
 cmd-vram-desc = Displays video memory usage statics by the game.
-cmd-vram-help = Usage: vram
+cmd-vram-help = Usage: {$command}
 
 cmd-showislands-desc = Shows the current physics bodies involved in each physics island.
-cmd-showislands-help = Usage: showislands
+cmd-showislands-help = Usage: {$command}
 
 cmd-showgridnodes-desc = Shows the nodes for grid split purposes.
-cmd-showgridnodes-help = Usage: showgridnodes
+cmd-showgridnodes-help = Usage: {$command}
 
 cmd-profsnap-desc = Make a profiling snapshot.
-cmd-profsnap-help = Usage: profsnap
+cmd-profsnap-help = Usage: {$command}
 
-cmd-devwindow-desc = Dev Window
-cmd-devwindow-help = Usage: devwindow
+cmd-devwindow-desc = Dev Window.
+cmd-devwindow-help = Usage: {$command}
 
 cmd-scene-desc = Immediately changes the UI scene/state.
-cmd-scene-help = Usage: scene <className>
+cmd-scene-help = Usage: {$command} <className>
 
 cmd-szr_stats-desc = Report serializer statistics.
-cmd-szr_stats-help = Usage: szr_stats
+cmd-szr_stats-help = Usage: {$command}
 
 cmd-hwid-desc = Returns the current HWID (HardWare ID).
-cmd-hwid-help = Usage: hwid
+cmd-hwid-help = Usage: {$command}
 
 cmd-vvread-desc = Retrieve a path's value using VV (View Variables).
-cmd-vvread-help = Usage: vvread <path>
+cmd-vvread-help = Usage: {$command} <path>
 
 cmd-vvwrite-desc = Modify a path's value using VV (View Variables).
-cmd-vvwrite-help = Usage: vvwrite <path>
+cmd-vvwrite-help = Usage: {$command} <path>
 
 cmd-vvinvoke-desc = Invoke/Call a path with arguments using VV.
-cmd-vvinvoke-help = Usage: vvinvoke <path> [arguments...]
+cmd-vvinvoke-help = Usage: {$command} <path> [arguments...]
 
 cmd-dump_dependency_injectors-desc = Dump IoCManager's dependency injector cache.
-cmd-dump_dependency_injectors-help = Usage: dump_dependency_injectors
+cmd-dump_dependency_injectors-help = Usage: {$command}
 cmd-dump_dependency_injectors-total-count = Total count: { $total }
 
 cmd-dump_netserializer_type_map-desc = Dump NetSerializer's type map and serializer hash.
-cmd-dump_netserializer_type_map-help = Usage: dump_netserializer_type_map
+cmd-dump_netserializer_type_map-help = Usage: {$command}
 
-cmd-hub_advertise_now-desc = Immediately advertise to the master hub server
-cmd-hub_advertise_now-help = Usage: hub_advertise_now
+cmd-hub_advertise_now-desc = Immediately advertise to the master hub server.
+cmd-hub_advertise_now-help = Usage: {$command}
 
-cmd-echo-desc = Echo arguments back to the console
-cmd-echo-help = Usage: echo "<message>"
+cmd-echo-desc = Echo arguments back to the console.
+cmd-echo-help = Usage: {$command} "<message>"
 
 ## 'vfs_ls' command
 cmd-vfs_ls-desc = List directory contents in the VFS.
-cmd-vfs_ls-help = Usage: vfs_list <path>
+cmd-vfs_ls-help = Usage: {$command} <path>
     Example:
     vfs_list /Assemblies
 
 cmd-vfs_ls-err-args = Need exactly 1 argument.
 cmd-vfs_ls-hint-path = <path>
 
-cmd-reloadtiletextures-desc = Reloads the tile texture atlas to allow hot reloading tile sprites
-cmd-reloadtiletextures-help = Usage: reloadtiletextures
+cmd-reloadtiletextures-desc = Reloads the tile texture atlas to allow hot reloading tile sprites.
+cmd-reloadtiletextures-help = Usage: {$command}
 
 cmd-audio_length-desc = Shows the length of an audio file
-cmd-audio_length-help = Usage: audio_length { cmd-audio_length-arg-file-name }
+cmd-audio_length-help = Usage: {$command} { cmd-audio_length-arg-file-name }
 cmd-audio_length-arg-file-name = <file name>
 
 ## PVS
@@ -576,7 +580,9 @@ cmd-pvs-override-info-empty = Entity {$nuid} has no PVS overrides.
 cmd-pvs-override-info-global = Entity {$nuid} has a global override.
 cmd-pvs-override-info-clients = Entity {$nuid} has a session override for {$clients}.
 
-cmd-localization_set_culture-desc = Set DefaultCulture for the client LocalizationManager
-cmd-localization_set_culture-help = Usage: localization_set_culture <cultureName>
+cmd-localization_set_culture-desc = Set DefaultCulture for the client LocalizationManager.
+cmd-localization_set_culture-help = Usage: {$command} <cultureName>
 cmd-localization_set_culture-culture-name = <cultureName>
 cmd-localization_set_culture-changed = Localization changed to { $code } ({ $nativeName } / { $englishName })
+
+cmd-addmap-hint-2 = runMapInit [true / false]

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

@@ -1,14 +1,13 @@
 ## EntitySpawnWindow
 
 entity-spawn-window-title = Entity Spawn Panel
-entity-spawn-window-search-bar-placeholder = search
-entity-spawn-window-clear-button = Clear
 entity-spawn-window-replace-button-text = Replace
 entity-spawn-window-override-menu-tooltip = Override placement
 
 ## TileSpawnWindow
 
 tile-spawn-window-title = Place Tiles
+tile-spawn-window-mirror-button-text = Mirror Tiles
 
 ## Console
 
@@ -21,3 +20,5 @@ output-panel-scroll-down-button-text = Scroll Down
 ## Common Used
 
 window-erase-button-text = Erase Mode
+window-search-bar-placeholder = Search
+window-clear-button = Clear

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

@@ -0,0 +1,25 @@
+## "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 }
+
+## "Render Targets" dev window tab
+dev-window-tab-render-targets-title = Render Targets
+dev-window-tab-render-targets-reload = Reload
+dev-window-tab-render-targets-filter = Filter
+dev-window-tab-render-targets-column-id = ID
+dev-window-tab-render-targets-column-name = Name
+dev-window-tab-render-targets-column-size = Size
+dev-window-tab-render-targets-column-type = Type
+dev-window-tab-render-targets-column-vram = VRAM
+dev-window-tab-render-targets-column-thumbnail = Thumbnail
+
+dev-window-tab-render-targets-value-null = null
+dev-window-tab-render-targets-value-not-available = Not available
+dev-window-tab-render-targets-summary = Total VRAM: { $vram }

Resources/Locale/en-US/input.ftl

@@ -2,6 +2,7 @@ input-key-Escape = Escape
 input-key-Control = Control
 input-key-Shift = Shift
 input-key-Alt = Alt
+input-key-Alt-mac = ⌥
 input-key-Menu = Menu
 input-key-F1 = F1
 input-key-F2 = F2
@@ -70,8 +71,8 @@ input-key-MouseButton9 = Mouse 9
 
 input-key-LSystem-win = Left Win
 input-key-RSystem-win = Right Win
-input-key-LSystem-mac = Left Cmd
-input-key-RSystem-mac = Right Cmd
+input-key-LSystem-mac = Left ⌘
+input-key-RSystem-mac = Right ⌘
 input-key-LSystem-linux = Left Meta
 input-key-RSystem-linux = Right Meta
 

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 =
@@ -426,3 +428,7 @@ command-description-cmd-info =
     On its own, this means it'll print the command's help message.
 command-description-comp-rm =
     Removes the given component from the entity.
+
+command-description-overlay-toggle = Toggle an overlay on or off
+command-description-overlay-add = Add an overlay (if it does not already exist)
+command-description-overlay-remove = Remove an overlay

Resources/Locale/en-US/view-variables.ftl

@@ -25,3 +25,9 @@ vv-sound-reference-distance = Reference Distance
 vv-sound-loop = Loop
 vv-sound-play-offset = Play Offset (s)
 vv-sound-variation = Pitch variation
+
+
+## ProtoId
+vv-protoid-id-placeholder = Prototype ID
+vv-protoid-select-button-label = Select
+vv-protoid-addwindow-title = Set Prototype

Resources/Shaders/Internal/light_shared.swsl

@@ -14,6 +14,8 @@ uniform highp vec2 lightCenter;
 uniform highp float lightRange;
 uniform highp float lightPower;
 uniform highp float lightSoftness;
+uniform highp float lightFalloff;
+uniform highp float lightCurveFactor;
 uniform highp float lightIndex;
 uniform sampler2D shadowMap;
 
@@ -47,8 +49,15 @@ void fragment()
         discard;
     }
 
-    highp float dist = dot(diff, diff) + LIGHTING_HEIGHT;
-    highp float val = clamp((1.0 - clamp(sqrt(dist) / lightRange, 0.0, 1.0)) * (1.0 / (sqrt(dist + 1.0))), 0.0, 1.0);
+    // this implementation of light attenuation primarily adapted from
+    // https://lisyarus.github.io/blog/posts/point-light-attenuation.html
+    highp float sqr_dist = dot(diff, diff) + LIGHTING_HEIGHT;
+
+    highp float s = clamp(sqrt(sqr_dist) / lightRange, 0.0, 1.0);
+    highp float s2 = s * s;
+    // controls curve by lerping between two variants (inverse-shape and inversequadratic-shape)
+    highp float curveFactor = mix(s, s2, clamp(lightCurveFactor, 0.0, 1.0));
+    highp float val = clamp(((1.0 - s2) * (1.0 - s2)) / (1.0 + lightFalloff * curveFactor), 0.0, 1.0);
 
     val *= lightPower;
     val *= mask;

Robust.Analyzers.Tests/AfterAutoHandleStateAnalyzerTest.cs

@@ -0,0 +1,110 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<Robust.Analyzers.AfterAutoHandleStateAnalyzer,
+        Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture, TestOf(typeof(AfterAutoHandleStateAnalyzer))]
+public sealed class AfterAutoHandleStateAnalyzerTest
+{
+    private const string SubscribeEventDef = """
+        using System;
+        namespace Robust.Shared.GameObjects;
+
+        public readonly struct EntityUid;
+
+        public abstract class EntitySystem
+        {
+            public void SubscribeLocalEvent<T, TEvent>() where TEvent : notnull { }
+        }
+
+        public interface IComponent;
+        public interface IComponentState;
+        """;
+
+    // A rare case for block-scoped namespace, I thought. Then I realized this
+    // only needed the one type definition.
+    private const string OtherTypeDefs = """
+        using System;
+
+        namespace JetBrains.Annotations
+        {
+            public sealed class BaseTypeRequiredAttribute(Type baseType) : Attribute;
+        }
+        """;
+
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<AfterAutoHandleStateAnalyzer, DefaultVerifier>
+        {
+            TestState = { Sources = { code } }
+        };
+
+        TestHelper.AddEmbeddedSources(test.TestState,
+            "Robust.Shared.Analyzers.ComponentNetworkGeneratorAuxiliary.cs",
+            "Robust.Shared.GameObjects.EventBusAttributes.cs");
+
+        test.TestState.Sources.Add(("EntitySystem.Subscriptions.cs", SubscribeEventDef));
+        test.TestState.Sources.Add(("Types.cs", OtherTypeDefs));
+
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+            using Robust.Shared.GameObjects;
+
+            [AutoGenerateComponentState(true)]
+            public sealed class AutoGenTrue;
+            [AutoGenerateComponentState(true, true)]
+            public sealed class AutoGenTrueTrue;
+
+            public sealed class NotAutoGen;
+            [AutoGenerateComponentState]
+            public sealed class AutoGenNoArgs;
+            [AutoGenerateComponentState(false)]
+            public sealed class AutoGenFalse;
+
+            public sealed class Foo : EntitySystem
+            {
+                public void Good()
+                {
+                    // Subscribing to other events works
+                    SubscribeLocalEvent<AutoGenNoArgs, object>();
+                    // First arg true allows subscribing
+                    SubscribeLocalEvent<AutoGenTrue, AfterAutoHandleStateEvent>();
+                    SubscribeLocalEvent<AutoGenTrueTrue, AfterAutoHandleStateEvent>();
+                }
+
+                public void Bad()
+                {
+                    // Can't subscribe if AutoGenerateComponentState isn't even present
+                    SubscribeLocalEvent<NotAutoGen, AfterAutoHandleStateEvent>();
+
+                    // Can't subscribe if first arg is not specified/false
+                    SubscribeLocalEvent<AutoGenNoArgs, AfterAutoHandleStateEvent>();
+                    SubscribeLocalEvent<AutoGenFalse, AfterAutoHandleStateEvent>();
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(29,9): error RA0040: Tried to subscribe to AfterAutoHandleStateEvent for 'NotAutoGen' which doesn't have an AutoGenerateComponentState attribute
+            VerifyCS.Diagnostic(AfterAutoHandleStateAnalyzer.MissingAttribute).WithSpan(29, 9, 29, 69).WithArguments("NotAutoGen"),
+            // /0/Test0.cs(32,9): error RA0041: Tried to subscribe to AfterAutoHandleStateEvent for 'AutoGenNoArgs' which doesn't have raiseAfterAutoHandleState set
+            VerifyCS.Diagnostic(AfterAutoHandleStateAnalyzer.MissingAttributeParam).WithSpan(32, 9, 32, 72).WithArguments("AutoGenNoArgs"),
+            // /0/Test0.cs(33,9): error RA0041: Tried to subscribe to AfterAutoHandleStateEvent for 'AutoGenFalse' which doesn't have raiseAfterAutoHandleState set
+            VerifyCS.Diagnostic(AfterAutoHandleStateAnalyzer.MissingAttributeParam).WithSpan(33, 9, 33, 71).WithArguments("AutoGenFalse")
+        );
+    }
+}

Robust.Analyzers.Tests/ComponentPauseGeneratorTest.cs

@@ -1,4 +1,4 @@
-extern alias SerializationGenerator;
+extern alias SerializationGenerator;
 using System.Linq;
 using System.Reflection;
 using Microsoft.CodeAnalysis;
@@ -126,6 +126,48 @@ public sealed class ComponentPauseGeneratorTest
             """);
     }
 
+    [Test]
+    public void TestDictionary()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public Dictionary<string, TimeSpan> Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            [global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    foreach (var key in component.Foo.Keys)
+                        component.Foo[key] += args.PausedTime;
+                }
+            }
+            }
+
+            """);
+    }
+
     [Test]
     public void TestAutoState()
     {

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,67 @@ 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 { }
+            [NotYamlSerializable]
+            public readonly struct NotSerializableStruct { }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField]
+                public NotSerializableClass BadField;
+
+                [DataField]
+                public NotSerializableClass BadProperty { get; set; }
+
+                [DataField]
+                public NotSerializableClass? BadNullableField;
+
+                [DataField]
+                public NotSerializableStruct BadStructField;
+
+                [DataField]
+                public NotSerializableStruct BadStructProperty { get; set; }
+
+                [DataField]
+                public NotSerializableStruct? BadNullableStructField;
+
+                [DataField]
+                public NotSerializableStruct? BadNullableStructProperty { 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(12,12): error RA0033: Data field BadField in data definition Foo is type NotSerializableClass, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(12, 12, 12, 32).WithArguments("BadField", "Foo", "NotSerializableClass"),
+            // /0/Test0.cs(15,12): error RA0033: Data field BadProperty in data definition Foo is type NotSerializableClass, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(15, 12, 15, 32).WithArguments("BadProperty", "Foo", "NotSerializableClass"),
+            // /0/Test0.cs(18,12): error RA0036: Data field BadNullableField in data definition Foo is type NotSerializableClass, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(18, 12, 18, 33).WithArguments("BadNullableField", "Foo", "NotSerializableClass"),
+            // /0/Test0.cs(21,12): error RA0036: Data field BadStructField in data definition Foo is type NotSerializableStruct, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(21, 12, 21, 33).WithArguments("BadStructField", "Foo", "NotSerializableStruct"),
+            // /0/Test0.cs(24,12): error RA0036: Data field BadStructProperty in data definition Foo is type NotSerializableStruct, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(24, 12, 24, 33).WithArguments("BadStructProperty", "Foo", "NotSerializableStruct"),
+            // /0/Test0.cs(27,12): error RA0036: Data field BadNullableStructField in data definition Foo is type NotSerializableStruct, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(27, 12, 27, 34).WithArguments("BadNullableStructField", "Foo", "NotSerializableStruct"),
+            // /0/Test0.cs(30,12): error RA0036: Data field BadNullableStructProperty in data definition Foo is type NotSerializableStruct, which is not YAML serializable
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(30, 12, 30, 34).WithArguments("BadNullableStructProperty", "Foo", "NotSerializableStruct")
         );
     }
 }

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

@@ -10,6 +10,7 @@
   <ItemGroup>
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" LogicalName="Robust.Shared.Analyzers.AccessAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" LogicalName="Robust.Shared.Analyzers.AccessPermissions.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\ComponentNetworkGeneratorAuxiliary.cs" LogicalName="Robust.Shared.Analyzers.ComponentNetworkGeneratorAuxiliary.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\MustCallBaseAttribute.cs" LogicalName="Robust.Shared.IoC.MustCallBaseAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
@@ -17,6 +18,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/AfterAutoHandleStateAnalyzer.cs

@@ -0,0 +1,85 @@
+#nullable enable
+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 AfterAutoHandleStateAnalyzer : DiagnosticAnalyzer
+{
+    private const string AfterAutoHandleStateEventName = "AfterAutoHandleStateEvent";
+    private const string AutoGenStateAttribute = "Robust.Shared.Analyzers.AutoGenerateComponentStateAttribute";
+    private const string SubscribeLocalEventName = "SubscribeLocalEvent";
+
+    public static readonly DiagnosticDescriptor MissingAttribute = new(
+        Diagnostics.IdAutoGenStateAttributeMissing,
+        "Unreachable AfterAutoHandleState subscription",
+        "Tried to subscribe to AfterAutoHandleStateEvent for '{0}' which doesn't have an "
+        + "AutoGenerateComponentState attribute",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        // Does this even show up anywhere in Rider? >:(
+        "You must mark your component with '[AutoGenerateComponentState(true)]' to subscribe to this event."
+    );
+
+    public static readonly DiagnosticDescriptor MissingAttributeParam = new(
+        Diagnostics.IdAutoGenStateParamMissing,
+        "Unreachable AfterAutoHandleState subscription",
+        "Tried to subscribe to AfterAutoHandleStateEvent for '{0}' which doesn't have "
+        + "raiseAfterAutoHandleState set",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        "The AutoGenerateComponentState attribute must be passed 'true' in order to subscribe to this event."
+    );
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+        [MissingAttribute, MissingAttributeParam];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        // This is more to stop user error rather than code generation error
+        // (Plus this shouldn't affect code gen anyway)
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var autoGenStateAttribute = compilationContext.Compilation.GetTypeByMetadataName(AutoGenStateAttribute);
+            // No attribute, no analyzer.
+            if (autoGenStateAttribute is null)
+                return;
+
+            compilationContext.RegisterOperationAction(
+                analysisContext => CheckEventSubscription(analysisContext, autoGenStateAttribute),
+                OperationKind.Invocation);
+        });
+    }
+
+    private static void CheckEventSubscription(OperationAnalysisContext context, ITypeSymbol autoGenStateAttribute)
+    {
+        if (context.Operation is not IInvocationOperation operation)
+            return;
+
+        // Check the method has the right name and has the right type args
+        if (operation.TargetMethod is not
+            { Name: SubscribeLocalEventName, TypeArguments: [var component, { Name: AfterAutoHandleStateEventName }] })
+            return;
+
+        // Search the component's attributes for something matching autoGenStateAttribute
+        AttributeHelper.HasAttribute(component, autoGenStateAttribute, out var autoGenAttribute);
+
+        // First argument is raiseAfterAutoHandleState—note it shouldn't ever
+        // be null, since it has a default, but eh.
+        if (autoGenAttribute?.ConstructorArguments[0].Value is true)
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(autoGenAttribute is null ? MissingAttribute : MissingAttributeParam,
+            operation.Syntax.GetLocation(),
+            component.Name));
+    }
+}

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,51 @@ 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;
+
+            fieldTypeSymbol = TypeSymbolHelper.GetNullableUnderlyingTypeOrSelf(fieldTypeSymbol);
+
+            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 +237,25 @@ 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;
+
+        propertyTypeSymbol = TypeSymbolHelper.GetNullableUnderlyingTypeOrSelf(propertyTypeSymbol);
+
+        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 +380,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 +402,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 +425,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/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.Lock.cs

@@ -0,0 +1,51 @@
+using System;
+using System.IO;
+using Robust.Client.Utility;
+
+namespace Robust.Client.WebView.Cef;
+
+internal sealed partial class WebViewManagerCef
+{
+    private const string BaseCacheName = "cef_cache";
+    private const string LockFileName = "robust.lock";
+    private FileStream? _lockFileStream;
+    private const int MaxAttempts = 15; // This probably shouldn't be a cvar because the only reason you'd need it change for legit just botting the game.
+
+    private string FindAndLockCacheDirectory()
+    {
+        var rootDir = Path.Combine(UserDataDir.GetRootUserDataDir(_gameController), BaseCacheName);
+
+        for (var i = 0; i < MaxAttempts; i++)
+        {
+            var cacheDirPath = Path.Combine(rootDir, i.ToString());
+
+            if (TryLockCacheDir(i, cacheDirPath))
+                return cacheDirPath;
+        }
+
+        throw new Exception("Unable to locate available CEF cache directory!");
+    }
+
+    private bool TryLockCacheDir(int attempt, string path)
+    {
+        _sawmill.Verbose($"Trying to lock cache directory {attempt}");
+
+        // Does not fail if directory already exists.
+        Directory.CreateDirectory(path);
+
+        var lockFilePath = Path.Combine(path, LockFileName);
+
+        try
+        {
+            var file = File.Open(lockFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
+            _lockFileStream = file;
+            _sawmill.Debug($"Successfully locked CEF cache directory {attempt}");
+            return true;
+        }
+        catch (IOException ex)
+        {
+            _sawmill.Error($"Failed to lock cache directory {attempt}: {ex}");
+            return false;
+        }
+    }
+}

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -61,12 +61,9 @@ namespace Robust.Client.WebView.Cef
             if (cefResourcesPath == null)
                 throw new InvalidOperationException("Unable to locate cef_resources directory!");
 
-            var cachePath = "";
-            if (_resourceManager.UserData is WritableDirProvider userData)
-            {
-                var rootDir = UserDataDir.GetRootUserDataDir(_gameController);
-                cachePath = Path.Combine(rootDir, "cef_cache", "0");
-            }
+            var remoteDebugPort = _cfg.GetCVar(WCVars.WebRemoteDebugPort);
+
+            var cachePath = FindAndLockCacheDirectory();
 
             var settings = new CefSettings()
             {
@@ -76,7 +73,7 @@ namespace Robust.Client.WebView.Cef
                 BrowserSubprocessPath = subProcessPath,
                 LocalesDirPath = Path.Combine(cefResourcesPath, "locales"),
                 ResourcesDirPath = cefResourcesPath,
-                RemoteDebuggingPort = 9222,
+                RemoteDebuggingPort = remoteDebugPort,
                 CookieableSchemesList = "usr,res",
                 CachePath = cachePath,
             };

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

@@ -26,4 +26,16 @@ public static class WCVars
     /// </summary>
     public static readonly CVarDef<bool> WebHeadless =
         CVarDef.Create("web.headless", false, CVar.CLIENTONLY);
+
+#if TOOLS
+    private const int DefaultRemoteDebugPort = 9222;
+#else
+    private const int DefaultRemoteDebugPort = 0;
+#endif
+
+    /// <summary>
+    /// If not 0, the port number used for Chromium's remote debugging.
+    /// </summary>
+    public static readonly CVarDef<int> WebRemoteDebugPort =
+        CVarDef.Create("web.remote_debug_port", DefaultRemoteDebugPort, CVar.CLIENTONLY);
 }

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.
@@ -56,8 +54,14 @@ namespace Robust.Client.Animations
             }
             else
             {
+                var next = KeyFrames[nextKeyFrame];
+
                 // Get us a scale 0 -> 1 here.
-                var t = playingTime / KeyFrames[nextKeyFrame].KeyTime;
+                var t = playingTime / next.KeyTime;
+
+                // Apply easing to time parameter, if one was specified
+                if (next.Easing != null)
+                    t = next.Easing(t);
 
                 switch (InterpolationMode)
                 {
@@ -122,9 +126,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:
@@ -149,10 +153,20 @@ namespace Robust.Client.Animations
             /// </summary>
             public readonly float KeyTime;
 
-            public KeyFrame(object value, float keyTime)
+            /// <summary>
+            ///     An easing function to apply when interpolating to this keyframe's value.
+            ///     Modifies the time parameter (0..1) of the interpolation between the previous keyframe and this one.
+            /// </summary>
+            /// <remarks>
+            ///     See <see cref="Easings"/> for examples of easing functions, or provide your own.
+            /// </remarks>
+            public readonly Func<float, float>? Easing;
+
+            public KeyFrame(object value, float keyTime, Func<float, float>? easing = null)
             {
                 Value = value;
                 KeyTime = keyTime;
+                Easing = easing;
             }
         }
     }

Robust.Client/Audio/AudioManager.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using OpenTK.Audio.OpenAL;
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Client.Audio.Sources;
 using Robust.Client.ResourceManagement;
 using Robust.Shared;
@@ -57,8 +56,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);
         }
@@ -145,7 +144,7 @@ internal sealed partial class AudioManager : IAudioInternal
     private static void RemoveEfx((int sourceHandle, int filterHandle) handles)
     {
         if (handles.filterHandle != 0)
-            EFX.DeleteFilter(handles.filterHandle);
+            ALC.EFX.DeleteFilter(handles.filterHandle);
     }
 
     private void _checkAlcError(ALDevice device,

Robust.Client/Audio/AudioSystem.Effects.cs

@@ -1,4 +1,3 @@
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Client.Audio.Effects;
 using Robust.Shared.Audio.Components;
 using Robust.Shared.GameObjects;

Robust.Client/Audio/AudioSystem.cs

@@ -372,13 +372,13 @@ public sealed partial class AudioSystem : SharedAudioSystem
             return;
         }
 
+        var parentUid = xform.ParentUid;
         Vector2 worldPos;
         component.Volume = component.Params.Volume;
 
         // Handle grid audio differently by using grid position.
         if ((component.Flags & AudioFlags.GridAudio) != 0x0)
         {
-            var parentUid = xform.ParentUid;
             worldPos = _maps.GetGridPosition(parentUid);
         }
         else
@@ -412,7 +412,7 @@ public sealed partial class AudioSystem : SharedAudioSystem
         }
         else
         {
-            var occlusion = GetOcclusion(listener, delta, distance, entity);
+            var occlusion = GetOcclusion(listener, delta, distance, parentUid);
             component.Occlusion = occlusion;
         }
 
@@ -420,11 +420,11 @@ public sealed partial class AudioSystem : SharedAudioSystem
         component.Position = worldPos;
 
         // Make race cars go NYYEEOOOOOMMMMM
-        if (_physicsQuery.TryGetComponent(entity, out var physicsComp))
+        if (_physicsQuery.TryGetComponent(parentUid, out var physicsComp))
         {
             // This actually gets the tracked entity's xform & iterates up though the parents for the second time. Bit
             // inefficient.
-            var velocity = _physics.GetMapLinearVelocity(entity, physicsComp, xform);
+            var velocity = _physics.GetMapLinearVelocity(parentUid, physicsComp);
             component.Velocity = velocity;
         }
     }
@@ -582,13 +582,18 @@ 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;
         }
 
         var playing = CreateAndStartPlayingStream(audioParams, specifier, stream);
         _xformSys.SetCoordinates(playing.Entity, new EntityCoordinates(entity, Vector2.Zero));
 
+        // Since we're playing the sound immediately in the middle of a tick, we need to force ProcessStream -now-
+        // to set occlusion/position/velocity etc
+        // otherwise predicted positional sounds will sound very incorrect in several possible ways (e#5802, e#6175) until the next tick
+        ProcessStream(playing.Entity, playing.Component, Transform(playing.Entity), GetListenerCoordinates());
+
         return playing;
     }
 
@@ -626,12 +631,16 @@ 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;
         }
 
         var playing = CreateAndStartPlayingStream(audioParams, specifier, stream);
         _xformSys.SetCoordinates(playing.Entity, coordinates);
+
+        // see PlayEntity for why this is necessary
+        ProcessStream(playing.Entity, playing.Component, Transform(playing.Entity), GetListenerCoordinates());
+
         return playing;
     }
 
@@ -714,8 +723,6 @@ public sealed partial class AudioSystem : SharedAudioSystem
         offset = Math.Clamp(offset, 0f, maxOffset);
         source.PlaybackPosition = offset;
 
-        // For server we will rely on the adjusted one but locally we will have to adjust it ourselves.
-        ApplyAudioParams(comp.Params, comp);
         source.StartPlaying();
         return (entity, comp);
     }
@@ -753,6 +760,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,5 +1,6 @@
 using System;
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using System.Numerics;
+using OpenTK.Audio.OpenAL;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Effects;
 using Robust.Shared.Maths;
@@ -15,16 +16,16 @@ internal sealed class AudioEffect : IAudioEffect
 
     public AudioEffect(IAudioInternal manager)
     {
-        Handle = EFX.GenEffect();
+        Handle = ALC.EFX.GenEffect();
         _master = manager;
-        EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
+        ALC.EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
     }
 
     public void Dispose()
     {
         if (Handle != 0)
         {
-            EFX.DeleteEffect(Handle);
+            ALC.EFX.DeleteEffect(Handle);
             Handle = 0;
         }
     }
@@ -43,14 +44,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
             _master._checkAlError();
         }
     }
@@ -61,14 +62,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
             _master._checkAlError();
         }
     }
@@ -79,14 +80,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
             _master._checkAlError();
         }
     }
@@ -97,14 +98,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
             _master._checkAlError();
         }
     }
@@ -115,14 +116,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
             _master._checkAlError();
         }
     }
@@ -133,14 +134,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
             _master._checkAlError();
         }
     }
@@ -151,14 +152,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
             _master._checkAlError();
         }
     }
@@ -169,14 +170,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
             _master._checkAlError();
         }
     }
@@ -187,14 +188,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
             _master._checkAlError();
         }
     }
@@ -205,14 +206,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
             _master._checkAlError();
         }
     }
@@ -223,7 +224,7 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
+            var value = ALC.EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
             _master._checkAlError();
             return new Vector3(value.X, value.Z, value.Y);
         }
@@ -231,7 +232,7 @@ internal sealed class AudioEffect : IAudioEffect
         {
             _checkDisposed();
             var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
-            EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
+            ALC.EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
             _master._checkAlError();
         }
     }
@@ -242,14 +243,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
             _master._checkAlError();
         }
     }
@@ -260,14 +261,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
             _master._checkAlError();
         }
     }
@@ -278,7 +279,7 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
+            var value = ALC.EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
             _master._checkAlError();
             return new Vector3(value.X, value.Z, value.Y);
         }
@@ -286,7 +287,7 @@ internal sealed class AudioEffect : IAudioEffect
         {
             _checkDisposed();
             var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
-            EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
+            ALC.EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
             _master._checkAlError();
         }
     }
@@ -297,14 +298,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
             _master._checkAlError();
         }
     }
@@ -315,14 +316,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
             _master._checkAlError();
         }
     }
@@ -333,14 +334,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
             _master._checkAlError();
         }
     }
@@ -351,14 +352,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
             _master._checkAlError();
         }
     }
@@ -369,14 +370,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
             _master._checkAlError();
         }
     }
@@ -387,14 +388,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
             _master._checkAlError();
         }
     }
@@ -405,14 +406,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
             _master._checkAlError();
         }
     }
@@ -423,14 +424,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
+            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
+            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
             _master._checkAlError();
         }
     }
@@ -441,14 +442,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
+            ALC.EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
+            ALC.EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
             _master._checkAlError();
         }
     }

Robust.Client/Audio/Effects/AuxiliaryAudio.cs

@@ -1,4 +1,4 @@
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using OpenTK.Audio.OpenAL;
 using Robust.Shared.Audio.Effects;
 
 namespace Robust.Client.Audio.Effects;
@@ -6,13 +6,13 @@ namespace Robust.Client.Audio.Effects;
 /// <inheritdoc />
 internal sealed class AuxiliaryAudio : IAuxiliaryAudio
 {
-    internal int Handle = EFX.GenAuxiliaryEffectSlot();
+    internal int Handle = ALC.EFX.GenAuxiliaryEffectSlot();
 
     public void Dispose()
     {
         if (Handle != -1)
         {
-            EFX.DeleteAuxiliaryEffectSlot(Handle);
+            ALC.EFX.DeleteAuxiliaryEffectSlot(Handle);
             Handle = -1;
         }
     }
@@ -22,11 +22,11 @@ internal sealed class AuxiliaryAudio : IAuxiliaryAudio
     {
         if (effect is AudioEffect audEffect)
         {
-            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
+            ALC.EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
         }
         else
         {
-            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
+            ALC.EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
         }
     }
 }

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>
@@ -207,4 +213,6 @@ public interface IMidiRenderer : IDisposable
     ///     Actually disposes of this renderer. Do NOT use outside the MIDI thread.
     /// </summary>
     internal void InternalDispose();
+
+    byte MinVolume { get; set; }
 }

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

@@ -42,7 +42,7 @@ internal sealed partial class MidiManager : IMidiManager
     [Dependency] private readonly IRuntimeLog _runtime = default!;
 
     private AudioSystem _audioSys = default!;
-    private SharedPhysicsSystem _broadPhaseSystem = default!;
+    private SharedPhysicsSystem _physics = default!;
     private SharedTransformSystem _xformSystem = default!;
 
     public IReadOnlyList<IMidiRenderer> Renderers
@@ -81,7 +81,7 @@ internal sealed partial class MidiManager : IMidiManager
     private Thread? _midiThread;
     private ISawmill _midiSawmill = default!;
     private float _gain = 0f;
-    private bool _volumeDirty = true;
+    private bool _gainDirty = true;
 
     // Not reliable until Fluidsynth is initialized!
     [ViewVariables(VVAccess.ReadWrite)]
@@ -96,7 +96,7 @@ internal sealed partial class MidiManager : IMidiManager
                 return;
 
             _cfgMan.SetCVar(CVars.MidiVolume, clamped);
-            _volumeDirty = true;
+            _gainDirty = true;
         }
     }
 
@@ -114,12 +114,13 @@ internal sealed partial class MidiManager : IMidiManager
         "/usr/share/sounds/sf2/TimGM6mb.sf2",
     };
 
-    private static readonly string WindowsSoundfont = $@"{Environment.GetEnvironmentVariable("SystemRoot")}\system32\drivers\gm.dls";
+    private static readonly string WindowsSoundfont =
+        $@"{Environment.GetEnvironmentVariable("SystemRoot")}\system32\drivers\gm.dls";
 
     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/";
 
@@ -145,11 +146,13 @@ internal sealed partial class MidiManager : IMidiManager
     {
         if (FluidsynthInitialized || _failedInitialize) return;
 
-        _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
-        {
-            _gain = value;
-            _volumeDirty = true;
-        }, true);
+        _cfgMan.OnValueChanged(CVars.MidiVolume,
+            value =>
+            {
+                _gain = value;
+                _gainDirty = true;
+            },
+            true);
 
         _midiSawmill = _logger.GetSawmill("midi");
 #if DEBUG
@@ -167,13 +170,15 @@ internal sealed partial class MidiManager : IMidiManager
         // not a directory, preserve the old file and create an actual directory
         else if (!_resourceManager.UserData.IsDir(CustomSoundfontDirectory))
         {
-            _resourceManager.UserData.Rename(CustomSoundfontDirectory, CustomSoundfontDirectory.WithName(CustomSoundfontDirectory.Filename + ".old"));
+            _resourceManager.UserData.Rename(CustomSoundfontDirectory,
+                CustomSoundfontDirectory.WithName(CustomSoundfontDirectory.Filename + ".old"));
             _resourceManager.UserData.CreateDir(CustomSoundfontDirectory);
         }
 
         try
         {
-            NFluidsynth.Logger.SetLoggerMethod(_loggerDelegate); // Will cause a safe DllNotFoundException if not available.
+            NFluidsynth.Logger
+                .SetLoggerMethod(_loggerDelegate); // Will cause a safe DllNotFoundException if not available.
 
             _settings = new Settings();
             _settings["synth.sample-rate"].DoubleValue = 44100;
@@ -193,7 +198,7 @@ internal sealed partial class MidiManager : IMidiManager
             //_settings["synth.verbose"].IntValue = 1; // Useful for debugging.
 
             var midiParallel = _cfgMan.GetCVar(CVars.MidiParallelism);
-            _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int)(Math.Log2(midiParallel) * 2048), 1, 65535);
+            _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int) (Math.Log2(midiParallel) * 2048), 1, 65535);
             _settings["synth.cpu-cores"].IntValue = Math.Clamp(midiParallel, 1, 256);
 
             _midiSawmill.Debug($"Synth Cores: {_settings["synth.cpu-cores"].IntValue}");
@@ -219,7 +224,7 @@ internal sealed partial class MidiManager : IMidiManager
         };
 
         _audioSys = _entityManager.EntitySysManager.GetEntitySystem<AudioSystem>();
-        _broadPhaseSystem = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
+        _physics = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
         _xformSystem = _entityManager.System<SharedTransformSystem>();
         _entityManager.GetEntityQuery<PhysicsComponent>();
         _entityManager.GetEntityQuery<TransformComponent>();
@@ -263,83 +268,10 @@ internal sealed partial class MidiManager : IMidiManager
         {
             soundfontLoader.SetCallbacks(_soundfontLoaderCallbacks);
 
-            var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _audio, _taskManager, _midiSawmill);
+            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;
 
@@ -347,6 +279,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 _renderers.Add(renderer);
             }
+
             return renderer;
         }
         finally
@@ -383,99 +316,23 @@ internal sealed partial class MidiManager : IMidiManager
 
         _updateSemaphore.Release();
 
-        _volumeDirty = false;
+        _gainDirty = false;
     }
 
     private void UpdateRenderer(IMidiRenderer renderer, MapCoordinates listener)
     {
-        // TODO: This should be sharing more code with AudioSystem.
         try
         {
             if (renderer.Disposed)
                 return;
 
-            if (_volumeDirty)
-            {
-                renderer.Source.Gain = Gain;
-            }
-
             if (!renderer.Mono)
-            {
                 renderer.Source.Global = true;
-                return;
-            }
 
-            MapCoordinates mapPos;
-
-            if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
-            {
-                renderer.TrackingCoordinates = _xformSystem.GetMapCoordinates(renderer.TrackingEntity.Value);
-
-                // Pause it if the attached entity is paused.
-                if (_entityManager.IsPaused(renderer.TrackingEntity))
-                {
-                    renderer.Source.Pause();
-                    return;
-                }
-            }
-            else if (renderer.TrackingCoordinates == null)
-            {
-                renderer.Source.Pause();
-                return;
-            }
-
-            mapPos = renderer.TrackingCoordinates.Value;
-
-            // If it's on a different map then just mute it, not pause.
-            if (mapPos.MapId == MapId.Nullspace || mapPos.MapId != listener.MapId)
-            {
-                renderer.Source.Gain = 0f;
-                return;
-            }
-
-            // Was previously muted maybe so try unmuting it?
-            if (renderer.Source.Gain == 0f)
-            {
-                renderer.Source.Gain = Gain;
-            }
-
-            var worldPos = mapPos.Position;
-            var delta = worldPos - listener.Position;
-            var distance = delta.Length();
-
-            // Update position
-            // Out of range so just clip it for us.
-            if (distance > renderer.Source.MaxDistance)
-            {
-                // Still keeps the source playing, just with no volume.
-                renderer.Source.Gain = 0f;
-                return;
-            }
-
-            // Same imprecision suppression as audiosystem.
-            if (distance > 0f && distance < 0.01f)
-            {
-                worldPos = listener.Position;
-                delta = Vector2.Zero;
-                distance = 0f;
-            }
-
-            renderer.Source.Position = worldPos;
-
-            // Update velocity (doppler).
-            if (!_entityManager.Deleted(renderer.TrackingEntity))
-            {
-                var velocity = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity.Value);
-                renderer.Source.Velocity = velocity;
-            }
+            if (!renderer.Source.Global)
+                UpdateLocalRenderer(renderer, listener);
             else
-            {
-                renderer.Source.Velocity = Vector2.Zero;
-            }
-
-            // Update occlusion
-            var occlusion = _audioSys.GetOcclusion(listener, delta, distance, renderer.TrackingEntity);
-            renderer.Source.Occlusion = occlusion;
+                UpdateGlobalRenderer(renderer);
         }
         catch (Exception ex)
         {
@@ -483,6 +340,58 @@ internal sealed partial class MidiManager : IMidiManager
         }
     }
 
+    private void UpdateLocalRenderer(IMidiRenderer renderer, MapCoordinates listener)
+    {
+        if (_entityManager.Deleted(renderer.TrackingEntity) || _entityManager.IsPaused(renderer.TrackingEntity))
+        {
+            renderer.Source.Gain = 0f;
+
+            return;
+        }
+
+        MapCoordinates mapCoords = _xformSystem.GetMapCoordinates(renderer.TrackingEntity.Value);
+        renderer.TrackingCoordinates = mapCoords;
+
+        if (mapCoords.MapId == MapId.Nullspace || mapCoords.MapId != listener.MapId)
+        {
+            renderer.Source.Gain = 0f;
+
+            return;
+        }
+
+        Vector2 mapPosition = mapCoords.Position;
+        Vector2 listenerDelta = mapPosition - listener.Position;
+        var listenerDeltaLength = listenerDelta.Length();
+
+        if (listenerDeltaLength > renderer.Source.MaxDistance)
+        {
+            renderer.Source.Gain = 0f;
+
+            return;
+        }
+
+        if (listenerDeltaLength is > 0f and < 0.01f)
+        {
+            mapPosition = listener.Position;
+            listenerDelta = Vector2.Zero;
+            listenerDeltaLength = 0f;
+        }
+
+        if (_gainDirty || renderer.Source.Gain == 0f)
+            renderer.Source.Gain = Gain;
+
+        renderer.Source.Position = mapPosition;
+        renderer.Source.Velocity = _physics.GetMapLinearVelocity(renderer.TrackingEntity.Value);
+        renderer.Source.Occlusion =
+            _audioSys.GetOcclusion(listener, listenerDelta, listenerDeltaLength, renderer.TrackingEntity);
+    }
+
+    private void UpdateGlobalRenderer(IMidiRenderer renderer)
+    {
+        if (_gainDirty)
+            renderer.Source.Gain = Gain;
+    }
+
     /// <summary>
     ///     Main method for the thread rendering the midi audio.
     /// </summary>
@@ -502,7 +411,7 @@ internal sealed partial class MidiManager : IMidiManager
                     {
                         if (!renderer.Disposed)
                         {
-                            if (renderer.Master is { Disposed: true })
+                            if (renderer.Master is {Disposed: true})
                                 renderer.Master = null;
 
                             renderer.Render();
@@ -572,130 +481,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;
@@ -214,6 +214,11 @@ internal sealed class MidiRenderer : IMidiRenderer
     [ViewVariables]
     public BitArray FilteredChannels { get; } = new(RobustMidiEvent.MaxChannels);
 
+    [ViewVariables]
+    public byte MinVolume { get => _minVolume; set => _minVolume = value; }
+
+    private byte _minVolume;
+
     [ViewVariables(VVAccess.ReadWrite)]
     public byte? VelocityOverride { get; set; } = null;
 
@@ -435,15 +440,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();
@@ -548,14 +544,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                     if (velocity <= 0)
                         continue;
 
-                    try
-                    {
-                        _synth.NoteOn(channel, key, velocity);
-                    }
-                    catch (FluidSynthInteropException e)
-                    {
-                        _midiSawmill.Error($"CH:{channel} KEY:{key} VEL:{velocity} {e.ToStringBetter()}");
-                    }
+                    _synth.TryNoteOn(channel, key, velocity);
                 }
             }
 
@@ -583,19 +572,32 @@ internal sealed class MidiRenderer : IMidiRenderer
                 {
                     case RobustMidiCommand.NoteOff:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = 0;
-                        _synth.NoteOff(midiEvent.Channel, midiEvent.Key);
-                        break;
+                        _synth.TryNoteOff(midiEvent.Channel, midiEvent.Key);
 
+                        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.TryNoteOn(midiEvent.Channel, midiEvent.Key, velocity);
+
+                            break;
+                        }
+
                         if (FilteredChannels[midiEvent.Channel])
                             break;
 
-                        var velocity = VelocityOverride ?? midiEvent.Velocity;
+                        if (MinVolume > 0)
+                            velocity = (byte)Math.Floor(MathHelper.Lerp(MinVolume, 127, (float)velocity / 127));
+
+                        velocity = VelocityOverride ?? velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
-                        _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
-                        break;
+                        _synth.TryNoteOn(midiEvent.Channel, midiEvent.Key, velocity);
 
+                        break;
                     case RobustMidiCommand.AfterTouch:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = midiEvent.Value;
                         _synth.KeyPressure(midiEvent.Channel, midiEvent.Key, midiEvent.Value);

Robust.Client/Audio/Sources/AudioSource.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Numerics;
 using OpenTK.Audio.OpenAL;
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Shared.Audio;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
@@ -77,7 +76,7 @@ internal sealed class AudioSource : BaseAudioSource
         else
         {
             if (FilterHandle != 0)
-                EFX.DeleteFilter(FilterHandle);
+                ALC.EFX.DeleteFilter(FilterHandle);
 
             AL.DeleteSource(SourceHandle);
             Master.RemoveAudioSource(SourceHandle);

Robust.Client/Audio/Sources/BaseAudioSource.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Numerics;
 using OpenTK.Audio.OpenAL;
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Client.Audio.Effects;
 using Robust.Shared.Audio.Effects;
 using Robust.Shared.Audio.Sources;
@@ -82,9 +81,9 @@ public abstract class BaseAudioSource : IAudioSource
         get
         {
             _checkDisposed();
-            var state = AL.GetSourceState(SourceHandle);
+            var state = AL.GetSource(SourceHandle, ALGetSourcei.SourceState);
             Master._checkAlError();
-            return state == ALSourceState.Playing;
+            return state == (int)ALSourceState.Playing;
         }
         set
         {
@@ -362,11 +361,11 @@ public abstract class BaseAudioSource : IAudioSource
 
         if (audio is AuxiliaryAudio impAudio)
         {
-            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, impAudio.Handle, 0, 0);
+            ALC.EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, impAudio.Handle, 0, 0);
         }
         else
         {
-            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, 0, 0, 0);
+            ALC.EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, 0, 0, 0);
         }
 
         Master._checkAlError();
@@ -376,12 +375,12 @@ public abstract class BaseAudioSource : IAudioSource
     {
         if (FilterHandle == 0)
         {
-            FilterHandle = EFX.GenFilter();
-            EFX.Filter(FilterHandle, FilterInteger.FilterType, (int) FilterType.Lowpass);
+            FilterHandle = ALC.EFX.GenFilter();
+            ALC.EFX.Filter(FilterHandle, FilterInteger.FilterType, (int) FilterType.Lowpass);
         }
 
-        EFX.Filter(FilterHandle, FilterFloat.LowpassGain, gain);
-        EFX.Filter(FilterHandle, FilterFloat.LowpassGainHF, cutoff);
+        ALC.EFX.Filter(FilterHandle, FilterFloat.LowpassGain, gain);
+        ALC.EFX.Filter(FilterHandle, FilterFloat.LowpassGainHF, cutoff);
         AL.Source(SourceHandle, ALSourcei.EfxDirectFilter, FilterHandle);
     }
 

Robust.Client/Audio/Sources/BufferedAudioSource.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using OpenTK.Audio.OpenAL;
-using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Shared.Audio.Sources;
 
 namespace Robust.Client.Audio.Sources;
@@ -37,9 +36,9 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         get
         {
             _checkDisposed();
-            var state = AL.GetSourceState(SourceHandle);
+            var state = AL.GetSource(SourceHandle, ALGetSourcei.SourceState);
             _master._checkAlError();
-            return state == ALSourceState.Playing;
+            return state == (int)ALSourceState.Playing;
         }
         set
         {
@@ -84,7 +83,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         else
         {
             if (FilterHandle != 0)
-                EFX.DeleteFilter(FilterHandle);
+                ALC.EFX.DeleteFilter(FilterHandle);
 
             AL.DeleteSource(SourceHandle);
             AL.DeleteBuffers(BufferHandles);

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

@@ -31,8 +31,7 @@ public sealed class LightTreeSystem : ComponentTreeSystem<LightTreeComponent, Po
 
         var pos = XformSystem.GetRelativePosition(
             entry.Transform,
-            entry.Component.TreeUid.Value,
-            GetEntityQuery<TransformComponent>());
+            entry.Component.TreeUid.Value);
 
         return ExtractAabb(in entry, pos, default);
     }

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/Configuration/ClientNetConfigurationManager.cs

@@ -71,7 +71,7 @@ internal sealed class ClientNetConfigurationManager : NetConfigurationManager, I
         // Actually set the CVar
         base.SetCVar(name, value, force);
 
-        if ((flags & CVar.REPLICATED) == 0)
+        if ((flags & CVar.REPLICATED) == 0 || !NetManager.IsConnected)
             return;
 
         var msg = new MsgConVars();

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/Commands/DumpMetadataMembersCommand.cs

@@ -4,7 +4,7 @@ using Robust.Shared.ContentPack;
 
 namespace Robust.Client.Console.Commands
 {
-#if DEBUG
+#if TOOLS
     internal sealed class DumpMetadataMembersCommand : LocalizedCommands
     {
         public override string Command => "dmetamem";

Robust.Client/Console/Commands/UITestCommand.TabWrapContainer.cs

@@ -0,0 +1,124 @@
+using System;
+using Robust.Client.Graphics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Maths;
+using ItemJustification = Robust.Client.UserInterface.Controls.WrapContainer.ItemJustification;
+
+namespace Robust.Client.Console.Commands;
+
+internal sealed partial class UITestControl
+{
+    private sealed class TabWrapContainer : Control
+    {
+        private readonly CheckBox _equalSizeBox;
+        private readonly CheckBox _reverseBox;
+        private readonly OptionButton _axisButton;
+        private readonly OptionButton _justifyButton;
+        private readonly LineEdit _separationEdit;
+        private readonly LineEdit _crossSeparationEdit;
+
+        public TabWrapContainer()
+        {
+            var container = new WrapContainer
+            {
+                MouseFilter = MouseFilterMode.Stop,
+                VerticalExpand = true,
+            };
+
+            var random = new Random(3005);
+
+            for (var i = 0; i < 35; i++)
+            {
+                var val = random.Next(1, 16);
+
+                var text = string.Create(val, 0, (span, _) => span.Fill('O'));
+                container.AddChild(new Button { Text = text });
+            }
+
+            AddChild(new BoxContainer
+            {
+                Orientation = BoxContainer.LayoutOrientation.Vertical,
+                Children =
+                {
+                    new BoxContainer
+                    {
+                        Orientation = BoxContainer.LayoutOrientation.Horizontal,
+                        SeparationOverride = 4,
+                        Children =
+                        {
+                            (_equalSizeBox = new CheckBox
+                            {
+                                Text = nameof(WrapContainer.EqualSize)
+                            }),
+                            (_reverseBox = new CheckBox
+                            {
+                                Text = nameof(WrapContainer.Reverse)
+                            }),
+                            (_axisButton = new OptionButton()),
+                            (_justifyButton = new OptionButton()),
+                            (_separationEdit = new LineEdit
+                            {
+                                PlaceHolder = "Separation",
+                                SetWidth = 100,
+                            }),
+                            (_crossSeparationEdit = new LineEdit
+                            {
+                                PlaceHolder = "Cross Separation",
+                                SetWidth = 100,
+                            })
+                        }
+                    },
+                    new PanelContainer
+                    {
+                        PanelOverride = new StyleBoxFlat { BackgroundColor = Color.Black },
+                        Children =
+                        {
+                            container
+                        }
+                    }
+                },
+            });
+
+            _axisButton.AddItem(nameof(Axis.Horizontal), (int)Axis.Horizontal);
+            _axisButton.AddItem(nameof(Axis.HorizontalReverse), (int)Axis.HorizontalReverse);
+            _axisButton.AddItem(nameof(Axis.Vertical), (int)Axis.Vertical);
+            _axisButton.AddItem(nameof(Axis.VerticalReverse), (int)Axis.VerticalReverse);
+
+            _axisButton.OnItemSelected += args =>
+            {
+                _axisButton.SelectId(args.Id);
+                container.LayoutAxis = (Axis)args.Id;
+            };
+
+            _justifyButton.AddItem(nameof(ItemJustification.Begin), (int)ItemJustification.Begin);
+            _justifyButton.AddItem(nameof(ItemJustification.Center), (int)ItemJustification.Center);
+            _justifyButton.AddItem(nameof(ItemJustification.End), (int)ItemJustification.End);
+
+            _justifyButton.OnItemSelected += args =>
+            {
+                _justifyButton.SelectId(args.Id);
+                container.Justification = (ItemJustification)args.Id;
+            };
+
+            _equalSizeBox.OnPressed += _ => container.EqualSize = _equalSizeBox.Pressed;
+            _reverseBox.OnPressed += _ => container.Reverse = _reverseBox.Pressed;
+
+            _separationEdit.OnTextChanged += args =>
+            {
+                if (!int.TryParse(args.Text, out var sep))
+                    sep = 0;
+
+                container.SeparationOverride = sep;
+            };
+
+            _crossSeparationEdit.OnTextChanged += args =>
+            {
+                if (!int.TryParse(args.Text, out var sep))
+                    sep = 0;
+
+                container.CrossSeparationOverride = sep;
+            };
+        }
+    }
+}

Robust.Client/Console/Commands/UITestCommand.cs

@@ -4,8 +4,6 @@ using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Console;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 
@@ -44,7 +42,10 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
         var progressBar = new ProgressBar { MaxValue = 10, Value = 5 };
         vBox.AddChild(progressBar);
 
-        var optionButton = new OptionButton();
+        var optionButton = new OptionButton
+        {
+            ToolTip = "This button has a tooltip. Spooky!"
+        };
         optionButton.AddItem("Honk");
         optionButton.AddItem("Foo");
         optionButton.AddItem("Bar");
@@ -154,6 +155,8 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
 
         _sprite = new TabSpriteView();
         _tabContainer.AddChild(_sprite);
+        _tabContainer.AddChild(TabCursorShapes());
+        _tabContainer.AddChild(new TabWrapContainer { Name = nameof(Tab.WrapContainer) });
     }
 
     public void OnClosed()
@@ -210,6 +213,53 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
         return label;
     }
 
+    private Control TabCursorShapes()
+    {
+        var box = new BoxContainer
+        {
+            Orientation = BoxContainer.LayoutOrientation.Vertical,
+        };
+        var styleBox = new StyleBoxFlat
+        {
+            BackgroundColor = Color.Black
+        };
+        foreach (var cursorName in Enum.GetNames<CursorShape>())
+        {
+            // Go over names due to duplicate definitions in the enum.
+            var cursor = Enum.Parse<CursorShape>(cursorName);
+            // Wow was I bad at API design.
+            if (cursor == CursorShape.Custom)
+                continue;
+
+            var panel = new PanelContainer
+            {
+                PanelOverride = styleBox,
+                DefaultCursorShape = cursor,
+                MouseFilter = MouseFilterMode.Stop,
+                MinHeight = 30,
+                Children =
+                {
+                    new Label
+                    {
+                        Text = cursorName,
+                        VerticalAlignment = VAlignment.Center,
+                        Margin = new Thickness(4)
+                    }
+                }
+            };
+
+            box.AddChild(panel);
+        }
+
+        return new ScrollContainer
+        {
+            Children = { box },
+            VScrollEnabled = true,
+            HScrollEnabled = false,
+            Name = nameof(Tab.TabCursorShapes),
+        };
+    }
+
     public void SelectTab(Tab tab)
     {
         _tabContainer.CurrentTab = (int)tab;
@@ -226,32 +276,14 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
         TextEdit = 6,
         RichText = 7,
         SpriteView = 8,
+        TabCursorShapes = 9,
+        WrapContainer = 10,
     }
 }
 
-internal sealed class UITestCommand : LocalizedCommands
+internal abstract class BaseUITestCommand : LocalizedCommands
 {
-    public override string Command => "uitest";
-
-    public override void Execute(IConsoleShell shell, string argStr, string[] args)
-    {
-        var window = new DefaultWindow { MinSize = new(800, 600) };
-        var control = new UITestControl();
-        window.OnClose += control.OnClosed;
-        window.Contents.AddChild(control);
-
-        window.OpenCentered();
-    }
-}
-
-internal sealed class UITest2Command : LocalizedCommands
-{
-    [Dependency] private readonly IClyde _clyde = default!;
-    [Dependency] private readonly IUserInterfaceManager _uiMgr = default!;
-
-    public override string Command => "uitest2";
-
-    public override void Execute(IConsoleShell shell, string argStr, string[] args)
+    public sealed override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
         if (args.Length > 1)
         {
@@ -272,18 +304,10 @@ internal sealed class UITest2Command : LocalizedCommands
             control.SelectTab(tab);
         }
 
-        var window = _clyde.CreateWindow(new WindowCreateParameters
-        {
-            Title = Loc.GetString("cmd-uitest2-title"),
-        });
-
-        var root = _uiMgr.CreateWindowRoot(window);
-        window.DisposeOnClose = true;
-        window.RequestClosed += _ => control.OnClosed();
-        root.AddChild(control);
+        CreateWindow(control);
     }
 
-    public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+    public sealed override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
     {
         if (args.Length == 1)
         {
@@ -294,4 +318,35 @@ internal sealed class UITest2Command : LocalizedCommands
 
         return CompletionResult.Empty;
     }
+
+    protected abstract void CreateWindow(UITestControl control);
+}
+
+internal sealed class UITestCommand : BaseUITestCommand
+{
+    public override string Command => "uitest";
+
+    protected override void CreateWindow(UITestControl control)
+    {
+        var window = new DefaultWindow { MinSize = new(800, 600) };
+        window.OnClose += control.OnClosed;
+        window.Contents.AddChild(control);
+        window.OpenCentered();
+    }
+}
+
+internal sealed class UITest2Command : BaseUITestCommand
+{
+    public override string Command => "uitest2";
+
+    protected override void CreateWindow(UITestControl control)
+    {
+        var window = new OSWindow
+        {
+            Title = Loc.GetString("cmd-uitest2-title"),
+        };
+        window.AddChild(control);
+        window.Closed += control.OnClosed;
+        window.Show();
+    }
 }

Robust.Client/Console/Commands/ViewportDebugCommands.cs

@@ -0,0 +1,44 @@
+#if TOOLS
+
+using Robust.Client.Graphics;
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Console.Commands;
+
+internal sealed class ViewportClearAllCachedCommand : IConsoleCommand
+{
+    [Dependency] private readonly IClydeInternal _clyde = default!;
+
+    public string Command => "vp_clear_all_cached";
+    public string Description => "Fires IClydeViewport.ClearCachedResources on all viewports";
+    public string Help => "";
+
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        _clyde.ViewportsClearAllCached();
+    }
+}
+
+internal sealed class ViewportTestFinalizeCommand : IConsoleCommand
+{
+    [Dependency] private readonly IClyde _clyde = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+
+    public string Command => "vp_test_finalize";
+    public string Description => "Creates a viewport, renders it once, then leaks it (finalizes it).";
+    public string Help => "";
+
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        var vp = _clyde.CreateViewport(new Vector2i(1920, 1080), nameof(ViewportTestFinalizeCommand));
+        vp.Eye = _eyeManager.CurrentEye;
+
+        vp.Render();
+
+        // Leak it.
+    }
+}
+
+#endif // TOOLS

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

@@ -0,0 +1,53 @@
+using System;
+using Robust.Client.Graphics;
+using Robust.Shared.IoC;
+using Robust.Shared.Toolshed;
+using Robust.Shared.Toolshed.TypeParsers;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Debugging;
+
+[ToolshedCommand]
+internal sealed class OverlayCommand : ToolshedCommand
+{
+    [Dependency] private readonly IOverlayManager _overlay = default!;
+    [Dependency] private readonly IDynamicTypeFactoryInternal _factory = default!;
+
+    [CommandImplementation("toggle")]
+    internal void Toggle([CommandArgument(customParser:typeof(ReflectionTypeParser<Overlay>))] Type overlay)
+    {
+        if (!overlay.IsSubclassOf(typeof(Overlay)))
+            throw new ArgumentException("Type must be a subclass of overlay");
+
+        if (_overlay.HasOverlay(overlay))
+            Remove(overlay);
+        else
+            Add(overlay);
+    }
+
+    [CommandImplementation("add")]
+    internal void Add([CommandArgument(customParser: typeof(ReflectionTypeParser<Overlay>))] Type overlay)
+    {
+        if (!overlay.IsSubclassOf(typeof(Overlay)))
+            throw new ArgumentException("Type must be a subclass of overlay");
+
+        if (!overlay.HasParameterlessConstructor())
+            throw new ArgumentException("Type must have parameterless constructor");
+
+        if (_overlay.HasOverlay(overlay))
+            return;
+
+        // TODO OVERLAYS Give overlays the ContentAccessAllowedAttribute?
+        var instance = (Overlay) _factory.CreateInstanceUnchecked(overlay, oneOff: true);
+        if (instance is IPostInjectInit init)
+            init.PostInject();
+
+        _overlay.AddOverlay(instance);
+    }
+
+    [CommandImplementation("remove")]
+    public void Remove([CommandArgument(customParser: typeof(ReflectionTypeParser<Overlay>))] Type overlay)
+    {
+        _overlay.RemoveOverlay(overlay);
+    }
+}

Robust.Client/Debugging/Overlays/TileDebugOverlay.cs

@@ -0,0 +1,229 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using JetBrains.Annotations;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.ResourceManagement;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Debugging.Overlays;
+
+/// <summary>
+/// This is an abstract helper class that can be used to create simple debug overlays that need to render tile based data.
+/// </summary>
+[UsedImplicitly]
+public abstract class TileDebugOverlay : Overlay, IPostInjectInit
+{
+    [Dependency] protected readonly IEntityManager Entity = default!;
+    [Dependency] protected readonly IEyeManager Eye = default!;
+    [Dependency] protected readonly IMapManager MapMan = default!;
+    [Dependency] protected readonly IInputManager Input = default!;
+    [Dependency] protected readonly IUserInterfaceManager Ui = default!;
+    [Dependency] protected readonly IResourceCache Cache = default!;
+
+    protected SharedTransformSystem Transform = default!;
+    protected MapSystem Map = default!;
+    protected EntityLookupSystem Lookup = default!;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
+
+    protected Font Font = default!;
+    protected List<Entity<MapGridComponent>> Grids = new();
+
+    public void PostInject()
+    {
+        Transform = Entity.System<SharedTransformSystem>();
+        Map = Entity.System<MapSystem>();
+        Lookup = Entity.System<EntityLookupSystem>();
+        var font = Cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf");
+        Font = new VectorFont(font, 8);
+        Init();
+    }
+
+    protected virtual void Init()
+    {
+    }
+
+    protected internal override void Draw(in OverlayDrawArgs args)
+    {
+        Grids.Clear();
+        if (args.Viewport.Eye?.Position.MapId is not {} map || map == MapId.Nullspace)
+            return;
+
+        MapMan.FindGridsIntersecting(map, args.WorldBounds, ref Grids);
+
+        foreach (var grid in Grids)
+        {
+            switch (args.Space)
+            {
+                case OverlaySpace.ScreenSpace:
+                    DrawScreen(args, grid);
+                    break;
+                case OverlaySpace.WorldSpace:
+                    DrawWorld(args, grid);
+                    break;
+            }
+        }
+
+        Grids.Clear();
+    }
+
+    protected virtual void DrawScreen(in OverlayDrawArgs args, Entity<MapGridComponent> grid)
+    {
+        var handle = args.ScreenHandle;
+        var (_, _, matrix, invMatrix) = Transform.GetWorldPositionRotationMatrixWithInv(grid.Owner);
+        var gridBounds = invMatrix.TransformBox(args.WorldBounds).Enlarged(grid.Comp.TileSize * 2);
+        var tilesEnumerator = Map.GetLocalTilesEnumerator(grid, grid, gridBounds);
+        while (tilesEnumerator.MoveNext(out var tile))
+        {
+            var tileBounds = Lookup.GetLocalBounds(tile, grid.Comp.TileSize);
+            if (!gridBounds.Intersects(tileBounds))
+                continue;
+            var screenTileCentre = Eye.WorldToScreen(Vector2.Transform(tileBounds.Center, matrix));
+            DrawTileText(handle, screenTileCentre, tile.GridIndices, grid);
+        }
+
+        // Draw mouse tooltip
+        DrawTooltip(handle);
+
+    }
+
+    protected virtual void DrawTooltip(DrawingHandleScreen handle)
+    {
+        var mousePos = Input.MouseScreenPosition;
+        if (!mousePos.IsValid)
+            return;
+
+        if (Ui.MouseGetControl(mousePos) is not IViewportControl viewport)
+            return;
+
+        var coords = viewport.PixelToMap(mousePos.Position);
+
+        if (!MapMan.TryFindGridAt(coords, out var grid, out var comp))
+            return;
+
+        var local = Map.WorldToLocal(grid, comp, coords.Position);
+        var x = (int) Math.Floor(local.X / comp.TileSize);
+        var y = (int) Math.Floor(local.Y / comp.TileSize);
+        var indices = new Vector2i(x, y);
+
+        DrawTooltip(handle, mousePos.Position, local, indices, (grid, comp));
+    }
+
+    /// <summary>
+    /// Draw a tooltip around the mouse
+    /// </summary>
+    /// <param name="mouseScreen">The mouse's screen coordinates</param>
+    /// <param name="mouseLocal">The mouse's local grid coordinates</param>
+    /// <param name="indices">The mouse's tile indices</param>
+    /// <param name="grid">The grid that the mouse is hovering over</param>
+    protected virtual void DrawTooltip(DrawingHandleScreen handle, Vector2 mouseScreen, Vector2 mouseLocal, Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        if (GetTooltip(mouseLocal, indices, grid) is not { } text)
+            return;
+
+        var lineHeight = Font.GetLineHeight(1f);
+        var offset = new Vector2(0, lineHeight);
+        handle.DrawString(Font, mouseScreen - offset, text);
+    }
+
+    protected virtual void DrawTileText(DrawingHandleScreen handle, Vector2 tileCentre, Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        if (GetText(indices, grid) is {} text)
+            handle.DrawString(Font, tileCentre, text);
+    }
+
+    protected virtual void DrawWorld(in OverlayDrawArgs args, Entity<MapGridComponent> grid)
+    {
+        var handle = args.WorldHandle;
+        var (_, _, matrix, invMatrix) = Transform.GetWorldPositionRotationMatrixWithInv(grid.Owner);
+        var gridBounds = invMatrix.TransformBox(args.WorldBounds).Enlarged(grid.Comp.TileSize * 2);
+        var tilesEnumerator = Map.GetLocalTilesEnumerator(grid, grid, gridBounds);
+        while (tilesEnumerator.MoveNext(out var tile))
+        {
+            handle.SetTransform(matrix);
+            var tileBounds = Lookup.GetLocalBounds(tile, grid.Comp.TileSize);
+            if (gridBounds.Intersects(tileBounds))
+                DrawTile(handle, tileBounds, tile.GridIndices, grid);
+        }
+
+        handle.SetTransform(Matrix3x2.Identity);
+    }
+
+    protected virtual void DrawTile(DrawingHandleWorld handle, Box2 tile, Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        if (GetColor(indices, grid) is not { } color)
+            return;
+
+        handle.DrawRect(tile, color.Border, filled: false);
+        handle.DrawRect(tile, color.Fill, filled: true);
+    }
+
+    /// <summary>
+    /// Get text that will be rendered in a grid tile.
+    /// </summary>
+    protected abstract string? GetText(Vector2i indices, Entity<MapGridComponent> grid);
+
+    /// <summary>
+    /// Get tooltip text that will be shown next to the mouse.
+    /// </summary>
+    /// <param name="mousePos">The mouse's position relative to the grid.</param>
+    /// <param name="gridIndices">The grid indices corresponding to the mouse's position</param>
+    /// <param name="grid">The grid that the mouse is over.</param>
+    protected abstract string? GetTooltip(Vector2 mousePos, Vector2i indices, Entity<MapGridComponent> grid);
+
+    /// <summary>
+    /// Get a border & fill color that will be used to draw a grid tile.
+    /// </summary>
+    protected abstract (Color Fill, Color Border)? GetColor(Vector2i indices, Entity<MapGridComponent> grid);
+}
+
+/// <summary>
+/// Variant of <see cref="TileDebugOverlay"/> that exists to draw simple float information for each tile.
+/// </summary>
+public abstract class TileFloatDebugOverlay : TileDebugOverlay
+{
+    protected virtual float MinValue => 0;
+    protected virtual float MaxValue => 1;
+    protected abstract float? GetData(Vector2i indices, Entity<MapGridComponent> grid);
+
+    protected override string? GetText(Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        return GetData(indices, grid)?.ToString("F2");
+    }
+
+    protected override string? GetTooltip(Vector2 mousePos, Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        return GetData(indices, grid)?.ToString("F2");
+    }
+
+    protected override (Color Fill, Color Border)? GetColor(Vector2i indices, Entity<MapGridComponent> grid)
+    {
+        if (GetData(indices, grid) is not { } value)
+            return null;
+
+        var color = Gradient(value, MinValue, MaxValue);
+        return (color.WithAlpha(0.2f), color);
+    }
+
+    /// <summary>
+    /// Simple yellow -> orange -> red gradient.
+    /// </summary>
+    public Color Gradient(float value, float min, float max)
+    {
+        // map min to 1, max to 0
+        value = (value - min) / (max - min);
+        return value < 0.5f
+            ? Color.InterpolateBetween(Color.Yellow, Color.Orange, value * 2)
+            : Color.InterpolateBetween(Color.Orange, Color.Red, (value - 0.5f) * 2);
+    }
+}

Robust.Client/GameController/GameController.Standalone.cs

@@ -8,6 +8,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
+using SDL3;
 
 namespace Robust.Client
 {
@@ -93,6 +94,8 @@ namespace Robust.Client
 
         public void Run(DisplayMode mode, GameControllerOptions options, Func<ILogHandler>? logHandlerFactory = null)
         {
+            _displayMode = mode;
+
             if (!StartupSystemSplash(options, logHandlerFactory))
             {
                 _logger.Fatal("Failed to start game controller!");

Robust.Client/GameController/GameController.cs

@@ -110,6 +110,8 @@ namespace Robust.Client
 
         private ResourceManifestData? _resourceManifest;
 
+        private DisplayMode _displayMode;
+
         public void SetCommandLineArgs(CommandLineArgs args)
         {
             _commandLineArgs = args;
@@ -160,6 +162,7 @@ namespace Robust.Client
             }
 
             _serializationManager.Initialize();
+            _loc.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
@@ -182,7 +185,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
@@ -273,6 +275,9 @@ namespace Robust.Client
                 }
             };
 
+            _configurationManager.OnValueChanged(CVars.DisplayMaxFPS, _ => UpdateVsyncConfig());
+            _configurationManager.OnValueChanged(CVars.DisplayVSync, _ => UpdateVsyncConfig(), invokeImmediately: true);
+
             _clyde.Ready();
 
             if (_resourceManifest!.AutoConnect &&
@@ -709,6 +714,30 @@ namespace Robust.Client
         }
 
 
+        private void UpdateVsyncConfig()
+        {
+            if (_displayMode == DisplayMode.Headless)
+                return;
+
+            var vsync = _configurationManager.GetCVar(CVars.DisplayVSync);
+            var maxFps = Math.Clamp(_configurationManager.GetCVar(CVars.DisplayMaxFPS), 0, 10_000);
+
+            _clyde.VsyncEnabled = vsync;
+
+            if (_mainLoop == null)
+                return;
+
+            if (vsync || maxFps == 0)
+            {
+                _mainLoop.SleepMode = SleepMode.None;
+            }
+            else
+            {
+                _mainLoop.SleepMode = SleepMode.Limit;
+                _mainLoop.LimitMinFrameTime = TimeSpan.FromSeconds(1.0 / maxFps);
+            }
+        }
+
         internal enum DisplayMode : byte
         {
             Headless,

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -29,6 +29,9 @@ namespace Robust.Client.GameObjects
         internal event Action? AfterStartup;
         internal event Action? AfterShutdown;
 
+        private readonly Queue<EntityUid> _queuedPredictedDeletions = new();
+        private readonly HashSet<EntityUid> _queuedPredictedDeletionsSet = new();
+
         public override void Initialize()
         {
             SetupNetworking();
@@ -213,6 +216,34 @@ namespace Robust.Client.GameObjects
                 }
             }
 
+            using (histogram?.WithLabels("PredictedQueueDel").NewTimer())
+            {
+                while (_queuedPredictedDeletions.TryDequeue(out var uid))
+                {
+                    if (!MetaQuery.TryGetComponentInternal(uid, out var meta))
+                        continue;
+
+                    if (meta.EntityLifeStage >= EntityLifeStage.Terminating)
+                        continue;
+
+                    var xform = TransformQuery.GetComponentInternal(uid);
+                    if (meta.NetEntity.IsClientSide())
+                    {
+                        DeleteEntity(uid, meta, xform);
+                    }
+                    else
+                    {
+                        _xforms.DetachEntity(uid, xform, meta, null);
+                        // base call bypasses IGameTiming.InPrediction check
+                        // This is pretty janky and there should be a way for the client to dirty an entity outside of prediction
+                        // TODO PREDICTION
+                        base.Dirty(uid, xform, meta);
+                    }
+                }
+
+                _queuedPredictedDeletionsSet.Clear();
+            }
+
             base.TickUpdate(frameTime, noPredictions, histogram);
         }
 
@@ -296,7 +327,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;
@@ -317,18 +348,23 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        /// <inheritdoc />
-        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
-        {
-            if (IsQueuedForDeletion(ent.Owner)
-                || !MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityDeleted
-                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
-            {
-                return;
-            }
+        public override bool IsQueuedForDeletion(EntityUid uid)
+            => QueuedDeletionsSet.Contains(uid) || _queuedPredictedDeletions.Contains(uid);
 
-            if (ent.Comp1.NetEntity.IsClientSide())
+        /// <inheritdoc />
+        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?> ent)
+        {
+            // Some UIs get disposed after entity-manager has shut down and already deleted all entities.
+            if (!Started)
+                return;
+
+            if (IsQueuedForDeletion(ent.Owner))
+                return;
+
+            if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp, false))
+                return;
+
+            if (ent.Comp.NetEntity.IsClientSide())
             {
                 // client-side QueueDeleteEntity re-fetches MetadataComp and checks IsClientSide().
                 // base call to skip that.
@@ -337,7 +373,10 @@ namespace Robust.Client.GameObjects
             }
             else
             {
-                _xforms.DetachEntity(ent.Owner, ent.Comp2);
+                if (!_queuedPredictedDeletionsSet.Add(ent.Owner))
+                    return;
+
+                _queuedPredictedDeletions.Enqueue(ent.Owner);
             }
         }
     }

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

@@ -1,3 +1,4 @@
+using System.Diagnostics.Contracts;
 using Robust.Client.Graphics;
 using Robust.Client.Map;
 using Robust.Client.ResourceManagement;
@@ -9,13 +10,14 @@ namespace Robust.Client.GameObjects;
 
 public sealed class MapSystem : SharedMapSystem
 {
-    protected override MapId GetNextMapId()
+    [Pure]
+    internal override MapId GetNextMapId()
     {
         // Client-side map entities use negative map Ids to avoid conflict with server-side maps.
-        var id = new MapId(--LastMapId);
+        var id = new MapId(LastMapId - 1);
         while (MapExists(id) || UsedIds.Contains(id))
         {
-            id = new MapId(--LastMapId);
+            id = new MapId(id.Value - 1);
         }
         return id;
     }

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);
         }
@@ -28,6 +29,8 @@ namespace Robust.Client.GameObjects
             component.Enabled = state.Enabled;
             component.Offset = state.Offset;
             component.Softness = state.Softness;
+            component.Falloff = state.Falloff;
+            component.CurveFactor = state.CurveFactor;
             component.CastShadows = state.CastShadows;
             component.Energy = state.Energy;
             component.Radius = state.Radius;

Robust.Client/GameObjects/EntitySystems/ScaleVisualsSystem.cs

@@ -1,25 +0,0 @@
-using System.Numerics;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Maths;
-
-namespace Robust.Client.GameObjects;
-
-public sealed class ScaleVisualsSystem : EntitySystem
-{
-    public override void Initialize()
-    {
-        base.Initialize();
-        SubscribeLocalEvent<ScaleVisualsComponent, AppearanceChangeEvent>(OnChangeData);
-    }
-
-    private void OnChangeData(EntityUid uid, ScaleVisualsComponent component, ref AppearanceChangeEvent ev)
-    {
-        if (!ev.AppearanceData.TryGetValue(ScaleVisuals.Scale, out var scale) ||
-            ev.Sprite == null) return;
-
-        var vecScale = (Vector2)scale;
-
-        // Set it directly because prediction may call this multiple times.
-        ev.Sprite.Scale = vecScale;
-    }
-}

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,67 @@ 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;
+        target.Comp.Loop = source.Comp.Loop;
+
+        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/GameStateProcessor.cs

@@ -220,24 +220,34 @@ Had full state: {LastFullState != null}"
                 {
                     var compState = change.State;
 
-                    if (compState is IComponentDeltaState delta
-                        && compData.TryGetValue(change.NetID, out var old)) // May fail if relying on implicit data
+                    if (compState is not IComponentDeltaState delta)
                     {
-                        DebugTools.Assert(old is not IComponentDeltaState, "last state is not a full state");
-
-                        if (cloneDelta)
-                        {
-                            compState = delta.CreateNewFullState(old!);
-                        }
-                        else
-                        {
-                            delta.ApplyToFullState(old!);
-                            compState = old;
-                        }
-                        DebugTools.Assert(compState is not IComponentDeltaState, "newly constructed state is not a full state");
+                        compData[change.NetID] = compState;
+                        continue;
                     }
 
-                    compData[change.NetID] = compState;
+                    if (!compData.TryGetValue(change.NetID, out var old))
+                    {
+                        // Either the server needs to ensure that the initial state it sends to a client is a full
+                        // state, or the client needs to be able to construct an implicit full state (i.e., get-state
+                        // code needs to be in shared code).
+                        //
+                        // Without this, the client won't be able to reset predicted changes made to this component.
+                        DebugTools.Assert("Received delta state without having received or constructed an implicit full state");
+                        continue;
+                    }
+
+                    DebugTools.Assert(old is not IComponentDeltaState, "last state is not a full state");
+
+                    if (!cloneDelta)
+                    {
+                        delta.ApplyToFullState(old!);
+                        continue;
+                    }
+
+                    var newFull = delta.CreateNewFullState(old!);
+                    compData[change.NetID] = newFull;
+                    DebugTools.Assert(newFull is not IComponentDeltaState, "constructed state is not a full state");
                 }
 
                 if (entityState.NetComponents == null)

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.GLContext.cs

@@ -1,6 +1,5 @@
 using System;
 using Robust.Shared;
-using Robust.Shared.Log;
 
 namespace Robust.Client.Graphics.Clyde
 {

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

@@ -121,6 +121,19 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
+        public void RenderNow(IRenderTarget renderTarget, Action<IRenderHandle> callback)
+        {
+            ClearRenderState();
+
+            _renderHandle.RenderInRenderTarget(
+                renderTarget,
+                () =>
+                {
+                    callback(_renderHandle);
+                },
+                null);
+        }
+
         private void RenderSingleWorldOverlay(Overlay overlay, Viewport vp, OverlaySpace space, in Box2 worldBox, in Box2Rotated worldBounds)
         {
             // Check that entity manager has started.
@@ -318,7 +331,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 +382,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
 {
@@ -452,6 +451,8 @@ namespace Robust.Client.Graphics.Clyde
             var lastPower = float.NaN;
             var lastColor = new Color(float.NaN, float.NaN, float.NaN, float.NaN);
             var lastSoftness = float.NaN;
+            var lastFalloff = float.NaN;
+            var lastCurveFactor = float.NaN;
             Texture? lastMask = null;
 
             using (_prof.Group("Draw Lights"))
@@ -505,6 +506,18 @@ namespace Robust.Client.Graphics.Clyde
                         lightShader.SetUniformMaybe("lightSoftness", lastSoftness);
                     }
 
+                    if (!MathHelper.CloseToPercent(lastFalloff, component.Falloff))
+                    {
+                        lastFalloff = component.Falloff;
+                        lightShader.SetUniformMaybe("lightFalloff", lastFalloff);
+                    }
+
+                    if (!MathHelper.CloseToPercent(lastCurveFactor, component.CurveFactor))
+                    {
+                        lastCurveFactor = component.CurveFactor;
+                        lightShader.SetUniformMaybe("lightCurveFactor", lastCurveFactor);
+                    }
+
                     lightShader.SetUniformMaybe("lightCenter", lightPos);
                     lightShader.SetUniformMaybe("lightIndex",
                         component.CastShadows ? (i + 0.5f) / ShadowTexture.Height : -1);

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

@@ -209,6 +209,7 @@ namespace Robust.Client.Graphics.Clyde
             var pressure = estPixSize * size.X * size.Y;
 
             var handle = AllocRid();
+            var renderTarget = new RenderTexture(size, textureObject, this, handle);
             var data = new LoadedRenderTarget
             {
                 IsWindow = false,
@@ -220,10 +221,11 @@ namespace Robust.Client.Graphics.Clyde
                 MemoryPressure = pressure,
                 ColorFormat = format.ColorFormat,
                 SampleParameters = sampleParameters,
+                Instance = new WeakReference<RenderTargetBase>(renderTarget),
+                Name = name,
             };
 
             //GC.AddMemoryPressure(pressure);
-            var renderTarget = new RenderTexture(size, textureObject, this, handle);
             _renderTargets.Add(handle, data);
             return renderTarget;
         }
@@ -301,10 +303,22 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private sealed class LoadedRenderTarget
+        public IEnumerable<(RenderTargetBase, LoadedRenderTarget)> GetLoadedRenderTextures()
+        {
+            foreach (var loaded in _renderTargets.Values)
+            {
+                if (!loaded.Instance.TryGetTarget(out var instance))
+                    continue;
+
+                yield return (instance, loaded);
+            }
+        }
+
+        internal sealed class LoadedRenderTarget
         {
             public bool IsWindow;
             public WindowId WindowId;
+            public string? Name;
 
             public Vector2i Size;
             public bool IsSrgb;
@@ -325,9 +339,11 @@ namespace Robust.Client.Graphics.Clyde
             public long MemoryPressure;
 
             public TextureSampleParameters? SampleParameters;
+
+            public required WeakReference<RenderTargetBase> Instance;
         }
 
-        private abstract class RenderTargetBase : IRenderTarget
+        internal abstract class RenderTargetBase : IRenderTarget
         {
             protected readonly Clyde Clyde;
             private bool _disposed;
@@ -389,7 +405,7 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private sealed class RenderTexture : RenderTargetBase, IRenderTexture
+        internal sealed class RenderTexture : RenderTargetBase, IRenderTexture
         {
             public RenderTexture(Vector2i size, ClydeTexture texture, Clyde clyde, ClydeHandle handle)
                 : base(clyde, handle)

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);