Version: 255.0.2

(cherry picked from commit 51bbc5dc45)

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

@@ -1,34 +0,0 @@
-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]
+        os: [ubuntu-latest, windows-latest] # , macos-latest] - temporarily disabled due to libfreetype.dll errors.
 
     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
+        run: Tools/package_client_build.py -p windows mac linux
 
       - name: Shuffle files around
         run: |

Directory.Packages.props

@@ -44,11 +44,10 @@
     <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.Audio.OpenAL" Version="4.9.4" />
+    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
     <PackageVersion Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
     <PackageVersion Include="Pidgin" Version="3.3.0" />
-    <PackageVersion Include="Robust.Natives" Version="0.2.1" />
-    <PackageVersion Include="Robust.Natives.Zstd" Version="0.1.0-zstd1.5.7" />
+    <PackageVersion Include="Robust.Natives" Version="0.1.1" />
     <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" />
@@ -56,14 +55,11 @@
     <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.11" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.7" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
     <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
-    <PackageVersion Include="SpaceWizards.Sdl" Version="1.0.0" />
-    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.1.0" />
+    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
     <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,10 +16,7 @@
 
   <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">
-      <SetConfiguration Condition="'$(Configuration)' == 'DebugOpt'">Configuration=Debug</SetConfiguration>
-      <SetConfiguration Condition="'$(Configuration)' == 'Tools'">Configuration=Release</SetConfiguration>
-    </ProjectReference>
+    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\Robust.Client.Injectors.csproj" ReferenceOutputAssembly="false"/>
   </ItemGroup>
 
   <!-- XamlIL does not make use of special Robust configurations like DebugOpt. Convert these down. -->
@@ -74,6 +71,6 @@
     </PropertyGroup>
     <Exec
       Condition="'$(_RobustUseExternalMSBuild)' == 'true'"
-      Command="&quot;$(DOTNET_HOST_PATH)&quot; msbuild /nodereuse:false $(MSBuildProjectFile) /t:CompileRobustXaml /p:_RobustForceInternalMSBuild=true /p:Configuration=$(Configuration) /p:RuntimeIdentifier=$(RuntimeIdentifier) /p:TargetFramework=$(TargetFramework) /p:BuildProjectReferences=false /p:IntermediateOutputPath=&quot;$(IntermediateOutputPath.TrimEnd('\'))/&quot;"/>
+      Command="&quot;$(DOTNET_HOST_PATH)&quot; msbuild /nodereuse:false $(MSBuildProjectFile) /t:CompileRobustXaml /p:_RobustForceInternalMSBuild=true /p:Configuration=$(Configuration) /p:RuntimeIdentifier=$(RuntimeIdentifier) /p:TargetFramework=$(TargetFramework) /p:BuildProjectReferences=false"/>
   </Target>
 </Project>

RELEASE-NOTES.md

@@ -54,608 +54,10 @@ END TEMPLATE-->
 *None yet*
 
 
-## 267.2.2
+## 255.0.2
 
 
-## 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.
-* 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.
-* Fix CompileRobustXamlTask for benchmarks.
-* .ftl files will now hot reload.
-* Fix placementmanager sometimes not clearing.
-
-### Other
-
-* Container events are now documented.
+## 255.0.1
 
 
 ## 255.0.0

Resources/Locale/en-US/_engine_lib.ftl

@@ -21,8 +21,7 @@ zzzz-object-pronoun = { GENDER($ent) ->
    }
 
 # Used internally by the DAT-OBJ() function.
-# Not used in en-US. Created to support other languages.
-# (e.g., "to him," "for her")
+# Not used in en-US. Created for supporting other languages.
 zzzz-dat-object = { GENDER($ent) ->
     [male] him
     [female] her
@@ -30,16 +29,6 @@ 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

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

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

@@ -1,33 +0,0 @@
-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

@@ -411,6 +411,9 @@ cmd-spawn-help = spawn <prototype> OR spawn <prototype> <relative entity ID> OR
 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-dumpentities-desc = Dump entity list.
 cmd-dumpentities-help = Dumps entity list of UIDs and prototype.
 
@@ -577,5 +580,3 @@ cmd-localization_set_culture-desc = Set DefaultCulture for the client Localizati
 cmd-localization_set_culture-help = Usage: localization_set_culture <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,13 +1,14 @@
 ## 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
 
@@ -20,5 +21,3 @@ 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

@@ -1,25 +0,0 @@
-## "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,7 +2,6 @@ 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
@@ -71,8 +70,8 @@ input-key-MouseButton9 = Mouse 9
 
 input-key-LSystem-win = Left Win
 input-key-RSystem-win = Right Win
-input-key-LSystem-mac = Left ⌘
-input-key-RSystem-mac = Right ⌘
+input-key-LSystem-mac = Left Cmd
+input-key-RSystem-mac = Right Cmd
 input-key-LSystem-linux = Left Meta
 input-key-RSystem-linux = Right Meta
 

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

@@ -195,8 +195,6 @@ 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 =

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

@@ -25,9 +25,3 @@ 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,8 +14,6 @@ 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;
 
@@ -49,15 +47,8 @@ void fragment()
         discard;
     }
 
-    // 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);
+    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);
 
     val *= lightPower;
     val *= mask;

Robust.Analyzers.Tests/AfterAutoHandleStateAnalyzerTest.cs

@@ -1,110 +0,0 @@
-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,48 +126,6 @@ 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,53 +21,47 @@ 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 NoVVReadOnlyTest()
+    public async Task Test()
     {
         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
             {
@@ -89,8 +83,8 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /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")
+            // /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")
         );
     }
 
@@ -98,8 +92,16 @@ 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
             {
@@ -112,63 +114,8 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /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")
+            // /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")
         );
     }
 
@@ -176,8 +123,16 @@ 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
             {
@@ -190,67 +145,8 @@ public sealed class DataDefinitionAnalyzerTest
             """;
 
         await Verifier(code,
-            // /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")
+            // /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")
         );
     }
 }

Robust.Analyzers.Tests/PrototypeInstantiationAnalyzerTest.cs

@@ -1,64 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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,7 +10,6 @@
   <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" />
@@ -18,10 +17,6 @@
     <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

@@ -1,85 +0,0 @@
-#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,11 +18,10 @@ 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";
 
-    public static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
+    private static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
         Diagnostics.IdDataDefinitionPartial,
         "Type must be partial",
         "Type {0} is a DataDefinition but is not partial",
@@ -32,7 +31,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to mark any type that is a data definition as partial."
     );
 
-    public static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
+    private static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
         Diagnostics.IdNestedDataDefinitionPartial,
         "Type must be partial",
         "Type {0} contains nested data definition {1} but is not partial",
@@ -62,7 +61,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to add a setter."
     );
 
-    public static readonly DiagnosticDescriptor DataFieldRedundantTagRule = new(
+    private 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",
@@ -82,19 +81,9 @@ 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, DataFieldYamlSerializableRule
+        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -102,31 +91,23 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
 
-        context.RegisterSymbolStartAction(symbolContext =>
-        {
-            if (symbolContext.Symbol is not INamedTypeSymbol typeSymbol)
-                return;
+        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);
 
-            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);
+        context.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
+        context.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
     }
 
-    private static void AnalyzeDataDefinition(SyntaxNodeAnalysisContext context)
+    private void AnalyzeDataDefinition(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not TypeDeclarationSyntax declaration)
             return;
 
-        if (context.ContainingSymbol is not INamedTypeSymbol type)
+        var type = context.SemanticModel.GetDeclaredSymbol(declaration)!;
+        if (!IsDataDefinition(type))
             return;
 
         if (!IsPartial(declaration))
@@ -137,7 +118,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));
@@ -147,31 +128,32 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         }
     }
 
-    private static void AnalyzeDataField(SyntaxNodeAnalysisContext context)
+    private void AnalyzeDataField(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not FieldDeclarationSyntax field)
             return;
 
-        if (context.ContainingSymbol?.ContainingType is not INamedTypeSymbol type)
+        var typeDeclaration = field.FirstAncestorOrSelf<TypeDeclarationSyntax>();
+        if (typeDeclaration == null)
+            return;
+
+        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
+        if (!IsDataDefinition(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, datafieldAttribute))
+            if (HasRedundantTag(fieldSymbol))
             {
                 TryGetAttributeLocation(field, DataFieldAttributeName, out var location);
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, fieldSymbol.Name, type.Name));
@@ -182,51 +164,33 @@ 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 static void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
+    private void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
     {
         if (context.Node is not PropertyDeclarationSyntax property)
             return;
 
-        if (context.ContainingSymbol is not IPropertySymbol propertySymbol)
+        var typeDeclaration = property.FirstAncestorOrSelf<TypeDeclarationSyntax>();
+        if (typeDeclaration == null)
             return;
 
-        if (propertySymbol.ContainingType is not INamedTypeSymbol type)
-            return;
-
-        if (type.IsRecord || type.IsValueType)
+        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
+        if (!IsDataDefinition(type) || 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, datafieldAttribute))
+        if (HasRedundantTag(propertySymbol))
         {
             TryGetAttributeLocation(property, DataFieldAttributeName, out var location);
             context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, propertySymbol.Name, type.Name));
@@ -237,25 +201,13 @@ 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);
     }
 
@@ -380,14 +332,17 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
-    private static bool HasRedundantTag(ISymbol symbol, AttributeData datafieldAttribute)
+    private static bool HasRedundantTag(ISymbol symbol)
     {
+        if (!IsDataField(symbol, out var _, out var attribute))
+            return false;
+
         // No args, no problem
-        if (datafieldAttribute.ConstructorArguments.Length == 0)
+        if (attribute.ConstructorArguments.Length == 0)
             return false;
 
         // If a tag is explicitly specified, it will be the first argument...
-        var tagArgument = datafieldAttribute.ConstructorArguments[0];
+        var tagArgument = attribute.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)
@@ -402,6 +357,9 @@ 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())
@@ -425,11 +383,6 @@ 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

@@ -1,48 +0,0 @@
-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

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

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

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

Robust.Client.WebView/Headless/WebViewManagerHeadless.cs

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

Robust.Client.WebView/IWebViewControlImpl.cs

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

Robust.Client.WebView/WCVars.cs

@@ -26,16 +26,4 @@ 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,7 +14,6 @@ namespace Robust.Client.WebView
         [Dependency] private readonly IWebViewManagerInternal _webViewManager = default!;
 
         private readonly IWebViewControlImpl _controlImpl;
-        private bool _alwaysActive;
 
         [ViewVariables(VVAccess.ReadWrite)]
         public string Url
@@ -23,21 +22,6 @@ 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()
@@ -55,16 +39,14 @@ namespace Robust.Client.WebView
         {
             base.EnteredTree();
 
-            if (!_controlImpl.IsOpen)
-                _controlImpl.StartBrowser();
+            _controlImpl.EnteredTree();
         }
 
         protected override void ExitedTree()
         {
             base.ExitedTree();
 
-            if (!_alwaysActive)
-                _controlImpl.CloseBrowser();
+            _controlImpl.ExitedTree();
         }
 
         protected internal override void MouseMove(GUIMouseMoveEventArgs args)

Robust.Client/Animations/AnimationTrackProperty.cs

@@ -3,6 +3,8 @@ 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
 {
@@ -11,7 +13,7 @@ namespace Robust.Client.Animations
     /// </summary>
     public abstract class AnimationTrackProperty : AnimationTrack
     {
-        public List<KeyFrame> KeyFrames { get; set; } = new();
+        public List<KeyFrame> KeyFrames { get; protected set; } = new();
 
         /// <summary>
         ///     How to interpolate values when between two keyframes.
@@ -54,14 +56,8 @@ namespace Robust.Client.Animations
             }
             else
             {
-                var next = KeyFrames[nextKeyFrame];
-
                 // Get us a scale 0 -> 1 here.
-                var t = playingTime / next.KeyTime;
-
-                // Apply easing to time parameter, if one was specified
-                if (next.Easing != null)
-                    t = next.Easing(t);
+                var t = playingTime / KeyFrames[nextKeyFrame].KeyTime;
 
                 switch (InterpolationMode)
                 {
@@ -126,9 +122,9 @@ namespace Robust.Client.Animations
                 case Vector2 vector2:
                     return Vector2Helpers.InterpolateCubic((Vector2) preA, vector2, (Vector2) b, (Vector2) postB, t);
                 case Vector3 vector3:
-                    return VectorHelpers.InterpolateCubic((Vector3) preA, vector3, (Vector3) b, (Vector3) postB, t);
+                    return Vector3.InterpolateCubic((Vector3) preA, vector3, (Vector3) b, (Vector3) postB, t);
                 case Vector4 vector4:
-                    return VectorHelpers.InterpolateCubic((Vector4) preA, vector4, (Vector4) b, (Vector4) postB, t);
+                    return Vector4.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:
@@ -153,20 +149,10 @@ namespace Robust.Client.Animations
             /// </summary>
             public readonly 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)
+            public KeyFrame(object value, float keyTime)
             {
                 Value = value;
                 KeyTime = keyTime;
-                Easing = easing;
             }
         }
     }

Robust.Client/Audio/AudioManager.cs

@@ -3,6 +3,7 @@ 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;
@@ -56,8 +57,8 @@ internal sealed partial class AudioManager : IAudioInternal
         _checkAlError();
 
         // Load up AL context extensions.
-        var s = ALC.GetString(_openALDevice, AlcGetString.Extensions) ?? "";
-        foreach (var extension in s.Split(' ', StringSplitOptions.RemoveEmptyEntries))
+        var s = ALC.GetString(ALDevice.Null, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' '))
         {
             _alContextExtensions.Add(extension);
         }
@@ -144,7 +145,7 @@ internal sealed partial class AudioManager : IAudioInternal
     private static void RemoveEfx((int sourceHandle, int filterHandle) handles)
     {
         if (handles.filterHandle != 0)
-            ALC.EFX.DeleteFilter(handles.filterHandle);
+            EFX.DeleteFilter(handles.filterHandle);
     }
 
     private void _checkAlcError(ALDevice device,

Robust.Client/Audio/AudioSystem.Effects.cs

@@ -1,3 +1,4 @@
+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, parentUid);
+            var occlusion = GetOcclusion(listener, delta, distance, entity);
             component.Occlusion = occlusion;
         }
 
@@ -420,11 +420,11 @@ public sealed partial class AudioSystem : SharedAudioSystem
         component.Position = worldPos;
 
         // Make race cars go NYYEEOOOOOMMMMM
-        if (_physicsQuery.TryGetComponent(parentUid, out var physicsComp))
+        if (_physicsQuery.TryGetComponent(entity, 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(parentUid, physicsComp);
+            var velocity = _physics.GetMapLinearVelocity(entity, physicsComp, xform);
             component.Velocity = velocity;
         }
     }
@@ -582,18 +582,13 @@ public sealed partial class AudioSystem : SharedAudioSystem
     {
         if (TerminatingOrDeleted(entity))
         {
-            LogAudioPlaybackOnInvalidEntity(specifier, entity);
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(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;
     }
 
@@ -631,16 +626,12 @@ public sealed partial class AudioSystem : SharedAudioSystem
     {
         if (TerminatingOrDeleted(coordinates.EntityId))
         {
-            LogAudioPlaybackOnInvalidEntity(specifier, coordinates.EntityId);
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(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;
     }
 
@@ -723,6 +714,8 @@ 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);
     }
@@ -760,12 +753,6 @@ 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,6 +1,5 @@
 using System;
-using System.Numerics;
-using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Effects;
 using Robust.Shared.Maths;
@@ -16,16 +15,16 @@ internal sealed class AudioEffect : IAudioEffect
 
     public AudioEffect(IAudioInternal manager)
     {
-        Handle = ALC.EFX.GenEffect();
+        Handle = EFX.GenEffect();
         _master = manager;
-        ALC.EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
+        EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
     }
 
     public void Dispose()
     {
         if (Handle != 0)
         {
-            ALC.EFX.DeleteEffect(Handle);
+            EFX.DeleteEffect(Handle);
             Handle = 0;
         }
     }
@@ -44,14 +43,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
             _master._checkAlError();
         }
     }
@@ -62,14 +61,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
             _master._checkAlError();
         }
     }
@@ -80,14 +79,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
             _master._checkAlError();
         }
     }
@@ -98,14 +97,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
             _master._checkAlError();
         }
     }
@@ -116,14 +115,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
             _master._checkAlError();
         }
     }
@@ -134,14 +133,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
             _master._checkAlError();
         }
     }
@@ -152,14 +151,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
             _master._checkAlError();
         }
     }
@@ -170,14 +169,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
             _master._checkAlError();
         }
     }
@@ -188,14 +187,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
             _master._checkAlError();
         }
     }
@@ -206,14 +205,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
             _master._checkAlError();
         }
     }
@@ -224,7 +223,7 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            var value = ALC.EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
             _master._checkAlError();
             return new Vector3(value.X, value.Z, value.Y);
         }
@@ -232,7 +231,7 @@ internal sealed class AudioEffect : IAudioEffect
         {
             _checkDisposed();
             var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
-            ALC.EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
+            EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
             _master._checkAlError();
         }
     }
@@ -243,14 +242,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
             _master._checkAlError();
         }
     }
@@ -261,14 +260,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
             _master._checkAlError();
         }
     }
@@ -279,7 +278,7 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            var value = ALC.EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
             _master._checkAlError();
             return new Vector3(value.X, value.Z, value.Y);
         }
@@ -287,7 +286,7 @@ internal sealed class AudioEffect : IAudioEffect
         {
             _checkDisposed();
             var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
-            ALC.EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
+            EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
             _master._checkAlError();
         }
     }
@@ -298,14 +297,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
             _master._checkAlError();
         }
     }
@@ -316,14 +315,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
             _master._checkAlError();
         }
     }
@@ -334,14 +333,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
             _master._checkAlError();
         }
     }
@@ -352,14 +351,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
             _master._checkAlError();
         }
     }
@@ -370,14 +369,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
             _master._checkAlError();
         }
     }
@@ -388,14 +387,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
             _master._checkAlError();
         }
     }
@@ -406,14 +405,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
             _master._checkAlError();
         }
     }
@@ -424,14 +423,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
+            EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
             _master._checkAlError();
         }
     }
@@ -442,14 +441,14 @@ internal sealed class AudioEffect : IAudioEffect
         get
         {
             _checkDisposed();
-            ALC.EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
+            EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
             _master._checkAlError();
             return value;
         }
         set
         {
             _checkDisposed();
-            ALC.EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
+            EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
             _master._checkAlError();
         }
     }

Robust.Client/Audio/Effects/AuxiliaryAudio.cs

@@ -1,4 +1,4 @@
-using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 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 = ALC.EFX.GenAuxiliaryEffectSlot();
+    internal int Handle = EFX.GenAuxiliaryEffectSlot();
 
     public void Dispose()
     {
         if (Handle != -1)
         {
-            ALC.EFX.DeleteAuxiliaryEffectSlot(Handle);
+            EFX.DeleteAuxiliaryEffectSlot(Handle);
             Handle = -1;
         }
     }
@@ -22,11 +22,11 @@ internal sealed class AuxiliaryAudio : IAuxiliaryAudio
     {
         if (effect is AudioEffect audEffect)
         {
-            ALC.EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
         }
         else
         {
-            ALC.EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
         }
     }
 }

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -6,7 +6,6 @@ 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;
 
@@ -157,13 +156,8 @@ 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>
@@ -213,6 +207,4 @@ 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

@@ -1,262 +0,0 @@
-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 _physics = default!;
+    private SharedPhysicsSystem _broadPhaseSystem = 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 _gainDirty = true;
+    private bool _volumeDirty = 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);
-            _gainDirty = true;
+            _volumeDirty = true;
         }
     }
 
@@ -114,13 +114,12 @@ 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 static readonly ResPath FallbackSoundfont = new ResPath("/Midi/fallback.sf2");
+    private const string FallbackSoundfont = "/Midi/fallback.sf2";
 
     private const string ContentCustomSoundfontDirectory = "/Audio/MidiCustom/";
 
@@ -146,13 +145,11 @@ internal sealed partial class MidiManager : IMidiManager
     {
         if (FluidsynthInitialized || _failedInitialize) return;
 
-        _cfgMan.OnValueChanged(CVars.MidiVolume,
-            value =>
-            {
-                _gain = value;
-                _gainDirty = true;
-            },
-            true);
+        _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
+        {
+            _gain = value;
+            _volumeDirty = true;
+        }, true);
 
         _midiSawmill = _logger.GetSawmill("midi");
 #if DEBUG
@@ -170,15 +167,13 @@ 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;
@@ -198,7 +193,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}");
@@ -224,7 +219,7 @@ internal sealed partial class MidiManager : IMidiManager
         };
 
         _audioSys = _entityManager.EntitySysManager.GetEntitySystem<AudioSystem>();
-        _physics = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
+        _broadPhaseSystem = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
         _xformSystem = _entityManager.System<SharedTransformSystem>();
         _entityManager.GetEntityQuery<PhysicsComponent>();
         _entityManager.GetEntityQuery<TransformComponent>();
@@ -268,10 +263,83 @@ 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);
 
-            LoadSoundFontSetup(renderer);
+            _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());
+            }
 
             renderer.Source.Gain = _gain;
 
@@ -279,7 +347,6 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 _renderers.Add(renderer);
             }
-
             return renderer;
         }
         finally
@@ -316,23 +383,99 @@ internal sealed partial class MidiManager : IMidiManager
 
         _updateSemaphore.Release();
 
-        _gainDirty = false;
+        _volumeDirty = false;
     }
 
     private void UpdateRenderer(IMidiRenderer renderer, MapCoordinates listener)
     {
+        // TODO: This should be sharing more code with AudioSystem.
         try
         {
             if (renderer.Disposed)
                 return;
 
-            if (!renderer.Mono)
-                renderer.Source.Global = true;
+            if (_volumeDirty)
+            {
+                renderer.Source.Gain = Gain;
+            }
 
-            if (!renderer.Source.Global)
-                UpdateLocalRenderer(renderer, listener);
+            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;
+            }
             else
-                UpdateGlobalRenderer(renderer);
+            {
+                renderer.Source.Velocity = Vector2.Zero;
+            }
+
+            // Update occlusion
+            var occlusion = _audioSys.GetOcclusion(listener, delta, distance, renderer.TrackingEntity);
+            renderer.Source.Occlusion = occlusion;
         }
         catch (Exception ex)
         {
@@ -340,58 +483,6 @@ 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>
@@ -411,7 +502,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();
@@ -481,6 +572,130 @@ 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

@@ -1,45 +0,0 @@
-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 partial class MidiRenderer : IMidiRenderer
+internal sealed class MidiRenderer : IMidiRenderer
 {
     private readonly IMidiManager _midiManager;
     private readonly ITaskManager _taskManager;
@@ -214,11 +214,6 @@ internal sealed partial 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;
 
@@ -440,6 +435,15 @@ internal sealed partial 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();
@@ -544,7 +548,14 @@ internal sealed partial class MidiRenderer : IMidiRenderer
                     if (velocity <= 0)
                         continue;
 
-                    _synth.TryNoteOn(channel, key, velocity);
+                    try
+                    {
+                        _synth.NoteOn(channel, key, velocity);
+                    }
+                    catch (FluidSynthInteropException e)
+                    {
+                        _midiSawmill.Error($"CH:{channel} KEY:{key} VEL:{velocity} {e.ToStringBetter()}");
+                    }
                 }
             }
 
@@ -572,32 +583,19 @@ internal sealed partial class MidiRenderer : IMidiRenderer
                 {
                     case RobustMidiCommand.NoteOff:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = 0;
-                        _synth.TryNoteOff(midiEvent.Channel, midiEvent.Key);
-
+                        _synth.NoteOff(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;
 
-                        if (MinVolume > 0)
-                            velocity = (byte)Math.Floor(MathHelper.Lerp(MinVolume, 127, (float)velocity / 127));
-
-                        velocity = VelocityOverride ?? velocity;
+                        var velocity = VelocityOverride ?? midiEvent.Velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
-                        _synth.TryNoteOn(midiEvent.Channel, midiEvent.Key, velocity);
-
+                        _synth.NoteOn(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,6 +1,7 @@
 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;
@@ -76,7 +77,7 @@ internal sealed class AudioSource : BaseAudioSource
         else
         {
             if (FilterHandle != 0)
-                ALC.EFX.DeleteFilter(FilterHandle);
+                EFX.DeleteFilter(FilterHandle);
 
             AL.DeleteSource(SourceHandle);
             Master.RemoveAudioSource(SourceHandle);

Robust.Client/Audio/Sources/BaseAudioSource.cs

@@ -1,6 +1,7 @@
 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;
@@ -81,9 +82,9 @@ public abstract class BaseAudioSource : IAudioSource
         get
         {
             _checkDisposed();
-            var state = AL.GetSource(SourceHandle, ALGetSourcei.SourceState);
+            var state = AL.GetSourceState(SourceHandle);
             Master._checkAlError();
-            return state == (int)ALSourceState.Playing;
+            return state == ALSourceState.Playing;
         }
         set
         {
@@ -361,11 +362,11 @@ public abstract class BaseAudioSource : IAudioSource
 
         if (audio is AuxiliaryAudio impAudio)
         {
-            ALC.EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, impAudio.Handle, 0, 0);
+            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, impAudio.Handle, 0, 0);
         }
         else
         {
-            ALC.EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, 0, 0, 0);
+            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, 0, 0, 0);
         }
 
         Master._checkAlError();
@@ -375,12 +376,12 @@ public abstract class BaseAudioSource : IAudioSource
     {
         if (FilterHandle == 0)
         {
-            FilterHandle = ALC.EFX.GenFilter();
-            ALC.EFX.Filter(FilterHandle, FilterInteger.FilterType, (int) FilterType.Lowpass);
+            FilterHandle = EFX.GenFilter();
+            EFX.Filter(FilterHandle, FilterInteger.FilterType, (int) FilterType.Lowpass);
         }
 
-        ALC.EFX.Filter(FilterHandle, FilterFloat.LowpassGain, gain);
-        ALC.EFX.Filter(FilterHandle, FilterFloat.LowpassGainHF, cutoff);
+        EFX.Filter(FilterHandle, FilterFloat.LowpassGain, gain);
+        EFX.Filter(FilterHandle, FilterFloat.LowpassGainHF, cutoff);
         AL.Source(SourceHandle, ALSourcei.EfxDirectFilter, FilterHandle);
     }
 

Robust.Client/Audio/Sources/BufferedAudioSource.cs

@@ -1,6 +1,7 @@
 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;
@@ -36,9 +37,9 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         get
         {
             _checkDisposed();
-            var state = AL.GetSource(SourceHandle, ALGetSourcei.SourceState);
+            var state = AL.GetSourceState(SourceHandle);
             _master._checkAlError();
-            return state == (int)ALSourceState.Playing;
+            return state == ALSourceState.Playing;
         }
         set
         {
@@ -83,7 +84,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         else
         {
             if (FilterHandle != 0)
-                ALC.EFX.DeleteFilter(FilterHandle);
+                EFX.DeleteFilter(FilterHandle);
 
             AL.DeleteSource(SourceHandle);
             AL.DeleteBuffers(BufferHandles);

Robust.Client/ClientIoC.cs

@@ -10,7 +10,6 @@ using Robust.Client.Graphics;
 using Robust.Client.Graphics.Clyde;
 using Robust.Client.HWId;
 using Robust.Client.Input;
-using Robust.Client.Localization;
 using Robust.Client.Map;
 using Robust.Client.Placement;
 using Robust.Client.Player;
@@ -37,7 +36,6 @@ using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Physics;
@@ -106,8 +104,6 @@ namespace Robust.Client
             deps.Register<IGamePrototypeLoadManager, GamePrototypeLoadManager>();
             deps.Register<NetworkResourceManager>();
             deps.Register<IReloadManager, ReloadManager>();
-            deps.Register<ILocalizationManager, ClientLocalizationManager>();
-            deps.Register<ILocalizationManagerInternal, ClientLocalizationManager>();
 
             switch (mode)
             {
@@ -144,7 +140,6 @@ namespace Robust.Client
             deps.Register<IViewVariablesManager, ClientViewVariablesManager>();
             deps.Register<IClientViewVariablesManager, ClientViewVariablesManager>();
             deps.Register<IClientViewVariablesManagerInternal, ClientViewVariablesManager>();
-            deps.Register<IViewVariableControlFactory, ViewVariableControlFactory>();
             deps.Register<IClientConGroupController, ClientConGroupController>();
             deps.Register<IScriptClient, ScriptClient>();
             deps.Register<IRobustSerializer, ClientRobustSerializer>();

Robust.Client/ComponentTrees/SpriteTreeSystem.cs

@@ -2,7 +2,6 @@ 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;
 
@@ -10,7 +9,25 @@ namespace Robust.Client.ComponentTrees;
 
 public sealed class SpriteTreeSystem : ComponentTreeSystem<SpriteTreeComponent, SpriteComponent>
 {
-    [Dependency] private readonly SpriteSystem _sprite = default!;
+    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;
+        }
+    }
 
     #region Component Tree Overrides
     protected override bool DoFrameUpdate => true;
@@ -19,11 +36,6 @@ public sealed class SpriteTreeSystem : ComponentTreeSystem<SpriteTreeComponent,
     protected override int InitialCapacity => 1024;
 
     protected override Box2 ExtractAabb(in ComponentTreeEntry<SpriteComponent> entry, Vector2 pos, Angle rot)
-    {
-        // 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();
-    }
-
+        => entry.Component.CalculateRotatedBoundingBox(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 || !NetManager.IsConnected)
+        if ((flags & CVar.REPLICATED) == 0)
             return;
 
         var msg = new MsgConVars();

Robust.Client/Console/ClientConsoleHost.cs

@@ -191,16 +191,8 @@ namespace Robust.Client.Console
             var shell = new ConsoleShell(this, session ?? _player.LocalSession, session == null);
             var cmdArgs = args.ToArray();
 
-            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}");
-            }
+            AnyCommandExecuted?.Invoke(shell, commandName, command, cmdArgs);
+            cmd.Execute(shell, command, cmdArgs);
         }
 
         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 TOOLS
+#if DEBUG
     internal sealed class DumpMetadataMembersCommand : LocalizedCommands
     {
         public override string Command => "dmetamem";

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

@@ -1,124 +0,0 @@
-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,6 +4,8 @@ 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;
 
@@ -42,10 +44,7 @@ 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
-        {
-            ToolTip = "This button has a tooltip. Spooky!"
-        };
+        var optionButton = new OptionButton();
         optionButton.AddItem("Honk");
         optionButton.AddItem("Foo");
         optionButton.AddItem("Bar");
@@ -155,8 +154,6 @@ 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()
@@ -213,53 +210,6 @@ 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;
@@ -276,14 +226,32 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
         TextEdit = 6,
         RichText = 7,
         SpriteView = 8,
-        TabCursorShapes = 9,
-        WrapContainer = 10,
     }
 }
 
-internal abstract class BaseUITestCommand : LocalizedCommands
+internal sealed class UITestCommand : LocalizedCommands
 {
-    public sealed override void Execute(IConsoleShell shell, string argStr, string[] args)
+    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)
     {
         if (args.Length > 1)
         {
@@ -304,10 +272,18 @@ internal abstract class BaseUITestCommand : LocalizedCommands
             control.SelectTab(tab);
         }
 
-        CreateWindow(control);
+        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);
     }
 
-    public sealed override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+    public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
     {
         if (args.Length == 1)
         {
@@ -318,35 +294,4 @@ internal abstract class BaseUITestCommand : 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

@@ -1,44 +0,0 @@
-#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(new Vector4(0f, 0f, 0.8f, 1f));
+                var dim = Color.FromHsl((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 (TryComp(ent, out MetaDataComponent? meta))
+                if (EntityManager.TryGetComponent<MetaDataComponent>(ent, out var meta))
                 {
                     text.AppendLine($"uid: {ent}, {meta.EntityName}");
                 }

Robust.Client/GameController/GameController.Standalone.cs

@@ -8,7 +8,6 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
-using SDL3;
 
 namespace Robust.Client
 {
@@ -94,8 +93,6 @@ 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

@@ -31,7 +31,6 @@ using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Exceptions;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
@@ -95,7 +94,6 @@ namespace Robust.Client
         [Dependency] private readonly IReplayRecordingManagerInternal _replayRecording = default!;
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
         [Dependency] private readonly IReloadManager _reload = default!;
-        [Dependency] private readonly ILocalizationManager _loc = default!;
 
         private IWebViewManagerHook? _webViewHook;
 
@@ -110,8 +108,6 @@ namespace Robust.Client
 
         private ResourceManifestData? _resourceManifest;
 
-        private DisplayMode _displayMode;
-
         public void SetCommandLineArgs(CommandLineArgs args)
         {
             _commandLineArgs = args;
@@ -162,7 +158,6 @@ namespace Robust.Client
             }
 
             _serializationManager.Initialize();
-            _loc.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
@@ -275,9 +270,6 @@ namespace Robust.Client
                 }
             };
 
-            _configurationManager.OnValueChanged(CVars.DisplayMaxFPS, _ => UpdateVsyncConfig());
-            _configurationManager.OnValueChanged(CVars.DisplayVSync, _ => UpdateVsyncConfig(), invokeImmediately: true);
-
             _clyde.Ready();
 
             if (_resourceManifest!.AutoConnect &&
@@ -714,30 +706,6 @@ 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,9 +29,6 @@ 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();
@@ -216,34 +213,6 @@ 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);
         }
 
@@ -327,7 +296,7 @@ namespace Robust.Client.GameObjects
         public override void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
         {
             if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityLifeStage >= EntityLifeStage.Terminating
+                || ent.Comp1.EntityDeleted
                 || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
             {
                 return;
@@ -348,23 +317,18 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        public override bool IsQueuedForDeletion(EntityUid uid)
-            => QueuedDeletionsSet.Contains(uid) || _queuedPredictedDeletions.Contains(uid);
-
         /// <inheritdoc />
-        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?> ent)
+        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
         {
-            // Some UIs get disposed after entity-manager has shut down and already deleted all entities.
-            if (!Started)
+            if (IsQueuedForDeletion(ent.Owner)
+                || !MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
+                || ent.Comp1.EntityDeleted
+                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
+            {
                 return;
+            }
 
-            if (IsQueuedForDeletion(ent.Owner))
-                return;
-
-            if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp, false))
-                return;
-
-            if (ent.Comp.NetEntity.IsClientSide())
+            if (ent.Comp1.NetEntity.IsClientSide())
             {
                 // client-side QueueDeleteEntity re-fetches MetadataComp and checks IsClientSide().
                 // base call to skip that.
@@ -373,10 +337,7 @@ namespace Robust.Client.GameObjects
             }
             else
             {
-                if (!_queuedPredictedDeletionsSet.Add(ent.Owner))
-                    return;
-
-                _queuedPredictedDeletions.Enqueue(ent.Owner);
+                _xforms.DetachEntity(ent.Owner, ent.Comp2);
             }
         }
     }

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

@@ -1,11 +1,9 @@
-using System;
-using Robust.Shared.GameObjects;
+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,5 +1,6 @@
 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,7 +24,9 @@ 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;
 
@@ -40,7 +42,7 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     DebugTools.AssertNull(_overlay);
-                    _overlay = new SpriteBoundsOverlay(EntityManager);
+                    _overlay = new SpriteBoundsOverlay(_spriteTree, _xformSystem);
                     _overlayManager.AddOverlay(_overlay);
                 }
                 else
@@ -55,13 +57,18 @@ namespace Robust.Client.GameObjects
         private bool _enabled;
     }
 
-    public sealed class SpriteBoundsOverlay(IEntityManager entMan) : Overlay
+    public sealed class SpriteBoundsOverlay : Overlay
     {
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        private readonly SharedTransformSystem _xformSystem = entMan.System<SharedTransformSystem>();
-        private readonly SpriteSystem _spriteSystem = entMan.System<SpriteSystem>();
-        private readonly SpriteTreeSystem _renderTree = entMan.System<SpriteTreeSystem>();
+        private readonly SharedTransformSystem _xformSystem;
+        private SpriteTreeSystem _renderTree;
+
+        public SpriteBoundsOverlay(SpriteTreeSystem renderTree, SharedTransformSystem xformSystem)
+        {
+            _renderTree = renderTree;
+            _xformSystem = xformSystem;
+        }
 
         protected internal override void Draw(in OverlayDrawArgs args)
         {
@@ -69,11 +76,10 @@ namespace Robust.Client.GameObjects
             var currentMap = args.MapId;
             var viewport = args.WorldBounds;
 
-            foreach (var entry in _renderTree.QueryAabb(currentMap, viewport))
+            foreach (var (sprite, xform) in _renderTree.QueryAabb(currentMap, viewport))
             {
-                var (sprite, xform) = entry;
                 var (worldPos, worldRot) = _xformSystem.GetWorldPositionRotation(xform);
-                var bounds = _spriteSystem.CalculateBounds((entry.Uid, sprite), worldPos, worldRot, args.Viewport.Eye?.Rotation ?? default);
+                var bounds = sprite.CalculateRotatedBoundingBox(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,9 +14,7 @@ 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()
         {
@@ -97,7 +95,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 ??= EnsureComp<AnimationPlayerComponent>(uid);
+            component ??= EntityManager.EnsureComponent<AnimationPlayerComponent>(uid);
             Play(new Entity<AnimationPlayerComponent>(uid, component), animation, key);
         }
 
@@ -158,7 +156,7 @@ namespace Robust.Client.GameObjects
 
         public bool HasRunningAnimation(EntityUid uid, string key)
         {
-            return TryComp(uid, out AnimationPlayerComponent? component) &&
+            return EntityManager.TryGetComponent(uid, out AnimationPlayerComponent? component) &&
                    component.PlayingAnimations.ContainsKey(key);
         }
 

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -1,14 +1,15 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
+using System;
 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.Serialization;
 using Robust.Shared.Utility;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Robust.Shared.Serialization;
 using static Robust.Shared.Containers.ContainerManagerComponent;
 
 namespace Robust.Client.GameObjects
@@ -57,7 +58,7 @@ namespace Robust.Client.GameObjects
             if (!RemoveExpectedEntity(meta.NetEntity, out var container))
                 return;
 
-            Insert((uid, TransformQuery.GetComponent(uid), MetaQuery.GetComponent(uid), null), container, force: true);
+            Insert((uid, TransformQuery.GetComponent(uid), MetaQuery.GetComponent(uid), null), container);
         }
 
         public override void ShutdownContainer(BaseContainer container)
@@ -231,7 +232,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            Insert(message.Entity, container, force: true);
+            Insert(message.Entity, container);
         }
 
         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 || !Exists(entity))
+            if(entity == default || !EntityManager.EntityExists(entity))
                 throw new ArgumentNullException(nameof(entity));
 
-            if (!TryComp(entity, out InputComponent? inputComp))
+            if (!EntityManager.TryGetComponent(entity, out InputComponent? inputComp))
             {
-                _sawmillInputContext.Debug($"AttachedEnt has no InputComponent: entId={entity}, entProto={Comp<MetaDataComponent>(entity).EntityPrototype}. Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                _sawmillInputContext.Debug($"AttachedEnt has no InputComponent: entId={entity}, entProto={EntityManager.GetComponent<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={Comp<MetaDataComponent>(entity).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
+                _sawmillInputContext.Error($"Unknown context: entId={entity}, entProto={EntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype}, context={inputComp.ContextName}. . Setting default \"{InputContextContainer.DefaultContextName}\" context...");
                 inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
             }
         }

Robust.Client/GameObjects/EntitySystems/MapSystem.cs

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

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

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

@@ -0,0 +1,25 @@
+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 || !TryComp(player.Value, out PhysicsComponent? body))
+        if (player == null || !EntityManager.TryGetComponent(player.Value, out PhysicsComponent? body))
         {
             _label.Visible = false;
             return;

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

@@ -1,149 +0,0 @@
-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,8 +1,4 @@
-using System;
-using System.Collections.Generic;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Maths;
-using Robust.Shared.Utility;
+using System.Linq;
 
 namespace Robust.Client.GameObjects;
 
@@ -45,67 +41,4 @@ 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,208 +1,11 @@
-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

@@ -1,257 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,299 +0,0 @@
-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

@@ -1,605 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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

@@ -1,166 +0,0 @@
-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

@@ -0,0 +1,137 @@
+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,9 +13,10 @@ 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;
@@ -34,25 +35,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!;
-        private EntityQuery<SpriteComponent> _query;
+
+        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);
+        }
 
         public override void Initialize()
         {
@@ -61,11 +62,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)
@@ -84,6 +85,18 @@ 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,7 +11,6 @@ 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 ((meta.Flags & MetaDataFlags.Detached) == 0 && compState != null)
+                        if (compState != null)
                         {
                             var handleState = new ComponentHandleState(compState, null);
                             _entities.EventBus.RaiseComponentEvent(entity, comp, ref handleState);
@@ -1306,11 +1306,6 @@ 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);
@@ -1331,13 +1326,6 @@ 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,34 +220,24 @@ Had full state: {LastFullState != null}"
                 {
                     var compState = change.State;
 
-                    if (compState is not IComponentDeltaState delta)
+                    if (compState is IComponentDeltaState delta
+                        && compData.TryGetValue(change.NetID, out var old)) // May fail if relying on implicit data
                     {
-                        compData[change.NetID] = compState;
-                        continue;
+                        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");
                     }
 
-                    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");
+                    compData[change.NetID] = compState;
                 }
 
                 if (entityState.NetComponents == null)

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -13,8 +13,6 @@ 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!;
@@ -34,7 +32,7 @@ namespace Robust.Client.GameStates
         {
             IoCManager.InjectDependencies(this);
             _lookup = lookup;
-            _shader = _prototypeManager.Index(UnshadedShader).Instance();
+            _shader = _prototypeManager.Index<ShaderPrototype>("unshaded").Instance();
             _container = _entityManager.System<SharedContainerSystem>();
             _xform = _entityManager.System<SharedTransformSystem>();
         }

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

@@ -1,10 +1,6 @@
 using System;
-using System.Runtime.InteropServices;
 using Robust.Shared;
-#if WINDOWS
-using TerraFX.Interop.Windows;
-using TerraFX.Interop.DirectX;
-#endif
+using Robust.Shared.Log;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -17,8 +13,6 @@ namespace Robust.Client.Graphics.Clyde
 
         private void InitGLContextManager()
         {
-            CheckForceCompatMode();
-
             // Advanced GL contexts currently disabled due to lack of testing etc.
             if (OperatingSystem.IsWindows() && _cfg.GetCVar(CVars.DisplayAngle))
             {
@@ -61,74 +55,6 @@ namespace Robust.Client.Graphics.Clyde
             _glContext = new GLContextWindow(this);
         }
 
-        private void CheckForceCompatMode()
-        {
-#if WINDOWS
-            // Qualcomm (Snapdragon/Adreno) devices have broken OpenGL drivers on Windows.
-
-            if (CheckIsQualcommDevice())
-            {
-                _sawmillOgl.Info("We appear to be on a Qualcomm device. Enabling compat mode due to broken OpenGL driver");
-                _cfg.OverrideDefault(CVars.DisplayCompat, true);
-            }
-#endif
-        }
-
-#if WINDOWS
-        private static unsafe bool CheckIsQualcommDevice()
-        {
-            // Ideally we would check the OpenGL driver instead... but OpenGL is terrible so that's impossible.
-            // Let's just check with DXGI instead.
-
-            IDXGIFactory1* dxgiFactory;
-            ThrowIfFailed(
-                nameof(DirectX.CreateDXGIFactory1),
-                DirectX.CreateDXGIFactory1(Windows.__uuidof<IDXGIFactory1>(), (void**) &dxgiFactory));
-
-            try
-            {
-                uint idx = 0;
-                IDXGIAdapter* adapter;
-                while (dxgiFactory->EnumAdapters(idx, &adapter) != DXGI.DXGI_ERROR_NOT_FOUND)
-                {
-                    try
-                    {
-                        DXGI_ADAPTER_DESC desc;
-                        ThrowIfFailed("GetDesc", adapter->GetDesc(&desc));
-
-                        var descString = ((ReadOnlySpan<char>)desc.Description).TrimEnd('\0');
-                        if (descString.Contains("qualcomm", StringComparison.OrdinalIgnoreCase) ||
-                            descString.Contains("snapdragon", StringComparison.OrdinalIgnoreCase) ||
-                            descString.Contains("adreno", StringComparison.OrdinalIgnoreCase))
-                        {
-                            return true;
-                        }
-                    }
-                    finally
-                    {
-                        adapter->Release();
-                    }
-
-                    idx += 1;
-                }
-            }
-            finally
-            {
-                dxgiFactory->Release();
-            }
-
-            return false;
-        }
-
-        private static void ThrowIfFailed(string methodName, HRESULT hr)
-        {
-            if (Windows.FAILED(hr))
-            {
-                Marshal.ThrowExceptionForHR(hr);
-            }
-        }
-#endif
-
         private struct GLContextSpec
         {
             public int Major;

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

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Numerics;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
@@ -255,11 +254,7 @@ namespace Robust.Client.Graphics.Clyde
                             region = regionMaybe[tile.Variant];
                         }
 
-                        var rotationMirroring = (_tileDefinitionManager.TryGetDefinition(tile.TypeId, out var tileDef) && tileDef.AllowRotationMirror) ?
-                                                    tile.RotationMirroring
-                                                    : 0;
-
-                        WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region, rotationMirroring);
+                        WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region);
                         i += 1;
                     }
                 }
@@ -330,7 +325,7 @@ namespace Robust.Client.Graphics.Clyde
                                 continue;
 
                             var region = regionMaybe[0];
-                            WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region, 0);
+                            WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region);
                             i += 1;
                         }
                     }
@@ -413,11 +408,8 @@ namespace Robust.Client.Graphics.Clyde
         private void _updateTileMapOnUpdate(ref TileChangedEvent args)
         {
             var gridData = _mapChunkData.GetOrNew(args.Entity);
-            foreach (var change in args.Changes)
-            {
-                if (gridData.TryGetValue(change.ChunkIndex, out var data))
-                    data.Dirty = true;
-            }
+            if (gridData.TryGetValue(args.ChunkIndex, out var data))
+                data.Dirty = true;
         }
 
         private void _updateOnGridCreated(GridStartupEvent ev)
@@ -453,57 +445,13 @@ namespace Robust.Client.Graphics.Clyde
             int gridY,
             Span<Vertex2D> vertexBuffer,
             Span<ushort> indexBuffer,
-            Box2 region,
-            int rotationMirroring)
+            Box2 region)
         {
-            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, 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);
+            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);
             var nIdx = i * GetQuadBatchIndexCount();
             var tIdx = (ushort)(i * 4);
             QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);

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

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

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

@@ -4,6 +4,7 @@ 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,6 +18,7 @@ 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
 {
@@ -451,8 +452,6 @@ 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"))
@@ -506,18 +505,6 @@ 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,7 +209,6 @@ 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,
@@ -221,11 +220,10 @@ 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;
         }
@@ -303,22 +301,10 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        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
+        private sealed class LoadedRenderTarget
         {
             public bool IsWindow;
             public WindowId WindowId;
-            public string? Name;
 
             public Vector2i Size;
             public bool IsSrgb;
@@ -339,11 +325,9 @@ namespace Robust.Client.Graphics.Clyde
             public long MemoryPressure;
 
             public TextureSampleParameters? SampleParameters;
-
-            public required WeakReference<RenderTargetBase> Instance;
         }
 
-        internal abstract class RenderTargetBase : IRenderTarget
+        private abstract class RenderTargetBase : IRenderTarget
         {
             protected readonly Clyde Clyde;
             private bool _disposed;
@@ -405,7 +389,7 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        internal sealed class RenderTexture : RenderTargetBase, IRenderTexture
+        private 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,6 +11,8 @@ 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
 {
@@ -539,7 +541,7 @@ namespace Robust.Client.Graphics.Clyde
                     case Matrix3x2 matrix3:
                         program.SetUniform(name, matrix3);
                         break;
-                    case Matrix4x4 matrix4:
+                    case Matrix4 matrix4:
                         program.SetUniform(name, matrix4);
                         break;
                     case ClydeTexture clydeTexture:
@@ -611,8 +613,6 @@ namespace Robust.Client.Graphics.Clyde
             EnsureBatchSpaceAvailable(4, GetQuadBatchIndexCount());
             EnsureBatchState(texture, true, GetQuadBatchPrimitiveType(), _queuedShader);
 
-            // TODO RENDERING
-            // It's probably better to do this on the GPU.
             bl = Vector2.Transform(bl, _currentMatrixModel);
             br = Vector2.Transform(br, _currentMatrixModel);
             tr = Vector2.Transform(tr, _currentMatrixModel);

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

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

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

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

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

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

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

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