Version: 248.0.2-source-gen-debug

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

Directory.Packages.props

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

MSBuild/Robust.Engine.Version.props

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

MSBuild/XamlIL.targets

@@ -71,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

@@ -1,4 +1,4 @@
-# Release notes for RobustToolbox.
+# Release notes for RobustToolbox.
 
 <!--
 NOTE: automatically updated sometimes by version.py.
@@ -54,583 +54,7 @@ END TEMPLATE-->
 *None yet*
 
 
-## 265.0.4
-
-
-## 265.0.3
-
-
-## 265.0.2
-
-
-## 265.0.1
-
-
-## 265.0.0
-
-### Breaking changes
-
-* More members in `IntegrationInstance` now enforce that the instance is idle before accessing it.
-* `Prototype.ValidateDirectory` now requires that prototype IDs have no spaces or periods in them.
-* `IPrototypeManager.TryIndex` no longer logs errors unless using the overload with an optional parameter. Use `Resolve()` instead if error logging is desired.
-* `LocalizedCommands` now has a `Loc` property that refers to `LocalizationManager`. This can cause compile failures if you have static methods in child types that referenced static `Loc`.
-* `[AutoGenerateComponentState]` now works on parent members for inherited classes. This can cause compile failures in certain formerly silently broken cases with overriden properties.
-* `Vector3`, `Vector4`, `Quaternion`, and `Matrix4` have been removed from `Robust.Shared.Maths`. Use the `System.Numerics` types instead.
-
-### New features
-
-* `RobustClientPackaging.WriteClientResources()` and `RobustServerPackaging.WriteServerResources()` now have an overload taking in a set of things to ignore in the content resources directory.
-* Added `IPrototypeManager.Resolve()`, which logs an error if the resolved prototype does not exist. This is effectively the previous (but not original) default behavior of `IPrototypeManager.TryIndex`.
-* There's now a ViewVariables property editor for tuples.
-* Added `ColorNaming` helper functions for getting textual descriptions of color values.
-* Added Oklab/Oklch conversion functions for `Color`.
-* `ColorSelectorSliders` now displays textual descriptions of color values.
-* Added `TimeSpanExt.TryTimeSpan` to parse `TimeSpan`s with the `1.5h` format available in YAML.
-* Added `ITestContextLike` and related classes to allow controlling pooled integration instances better.
-* `EntProtoId` VV prop editors now don't allow setting invalid prototype IDs, inline with `ProtoId<T>`.
-* Custom VV controls can now be registered using `IViewVariableControlFactory`.
-* The entity spawn window now shows all placement modes registered with `IPlacementManager`.
-* Added `VectorHelpers.InterpolateCubic` for `System.Numerics` `Vector3` and `Vector4`.
-* Added deconstruct helpers for `System.Numerics` `Vector3` and `Vector4`.
-
-### Bugfixes
-
-* Pooled integration instances returned by `RobustIntegrationTest` are now treated as non-idle, for consistency with non-pooled startups.
-* `SharedAudioSystem.SetState` no longer calls `DirtyField` on `PlaybackPosition`, an unnetworked field.
-* Fix loading texture files from the root directory.
-* Fix integration test pooling leaking non-reusable instances.
-* Fix multiple bugs where VV displayed the wrong property editor for remote values.
-* VV displays group headings again in member list.
-* Fix a stack overflow that could occur with `ColorSelectorSliders`.
-* `MidiRenderer` now properly handles `NoteOn` events with 0 velocity (which should actually be treated as `NoteOff` events).
-
-### Other
-
-* The debug assert for `RobustRandom.Next(TimeSpan, TimeSpan)` now allows for the two arguments to be equal.
-* The configuration system will now report an error instead of warning if it fails to load the config file.
-* Members in `IntegrationInstance` that enforce the instance is idle now always allow access from the instance's thread (e.g. from a callback).
-* `IPrototypeManager` methods now have `[ForbidLiteral]` where appropriate.
-* Performance improvements to physics system.
-* `[ValidatePrototypeIdAttribute]` has been marked as obsolete.
-* `ParallelManager` no longer cuts out exception information for caught job exceptions.
-* Improved logging for PVS uninitialized/deleted entity errors.
-
-### Internal
-
-* General code & warning cleanup.
-* Fix `VisibilityTest` being unreliable.
-* `ColorSelectorSliders` has been internally refactored.
-* Added CI workflows that test all RT build configurations.
-
-## 264.0.0
-
-### Breaking changes
-
-* `IPrototypeManager.Index(Type kind, string id)` now throws `UnknownPrototypeException` instead of `KeyNotFoundException`, for consistency with `IPrototypeManager.Index<T>`.
-
-### New features
-
-* Types can now implement the new interface `IRobustCloneable<T>` to be cloned by the component state source generator.
-* Added extra Roslyn Analyzers to detect some misuse of prototypes:
-  * Network serializing prototypes (tagging them with `[Serializable, NetSerializable]`).
-  * Constructing new instances of prototypes directly.
-* Add `PrototypeManagerExt.Index` helper function that takes a nullable `ProtoId<T>`, returning null if the ID is null.
-* Added an `AlwaysActive` field to `WebViewControl` to make a browser window active even when not in the UI tree.
-* Made some common dependencies accessible through `IPlacementManager`.
-* Added a new `GENITIVE()` localization helper function, which is useful for certain languages.
-
-### Bugfixes
-
-* Sprite scale is now correctly applied to sprite boundaries in `SpriteSystem.GetLocalBounds`.
-* Fixed documentation for `IPrototypeManager.Index<T>` stating that `KeyNotFoundException` gets thrown, when in actuality `UnknownPrototypeException` gets thrown.
-
-### Other
-
-* More tiny optimizations to `DataDefinitionAnalyzer`.
-* NetSerializer has been updated. On debug, it will now report *where* a type that can't be serialized is referenced from.
-
-### Internal
-
-* Minor internal code cleanup.
-
-
-## 263.0.0
-
-### Breaking changes
-
-* Fully removed some non-`Entity<T>` container methods.
-
-### New features
-
-* `IMidiRenderer.LoadSoundfont` has been split into `LoadSoundfontResource` and `LoadSoundfontUser`, the original now being deprecated.
-* Client command execution now properly catches errors instead of letting them bubble up through the input stack.
-* Added `CompletionHelper.PrototypeIdsLimited` API to allow commands to autocomplete entity prototype IDs.
-* Added `spawn:in` Toolshed command.
-* Added `MapLoaderSystem.TryLoadGeneric` overload to load from a `Stream`.
-* Added `OutputPanel.GetMessage()` and `OutputPanel.SetMessage()` to allow replacing individual messages.
-
-### Bugfixes
-
-* Fixed debug asserts when using MIDI on Windows.
-* Fixed an error getting logged on startup on macOS related to window icons.
-* `CC-BY-NC-ND-4.0` is now a valid license for the RGA validator.
-* Fixed `TabContainer.CurrentTab` clamping against the wrong value.
-* Fix culture-based parsing in `TimespanSerializer`.
-* Fixed grid rendering blowing up on tile IDs that aren't registered.
-* Fixed debug assert when loading MIDI soundfonts on Windows.
-* Make `ColorSelectorSliders` properly update the dropdown when changing `SelectorType`.
-* Fixed `tpto` allowing teleports to oneself, thereby causing them to be deleted.
-* Fix OpenAL extensions being requested incorrectly, causing an error on macOS.
-* Fixed horizontal measuring of markup controls in rich text.
-
-### Other
-
-* Improved logging for some audio entity errors.
-* Avoided more server stutters when using `csci`.
-* Improved physics performance.
-* Made various localization functions like `GENDER()` not throw if passed a string instead of an `EntityUid`.
-* The generic clause on `EntitySystem.AddComp<T>` has been changed to `IComponent` (from `Component`) for consistency with `IEntityManager.AddComponent<T>`.
-* `DataDefinitionAnalyzer` has been optimized somewhat.
-* Improved assert logging error message when static data fields are encountered.
-
-### Internal
-
-* Warning cleanup.
-* Added more tests for `DataDefinitionAnalyzer`.
-* Consistently use `EntitySystem` proxy methods in engine.
-
-
-## 262.0.0
-
-### Breaking changes
-
-* Toolshed commands will now validate that each non-generic command argument is parseable (i.e., has a corresponding type parser). This check can be disabled by explicitly marking the argument as unparseable via `CommandArgumentAttribute.Unparseable`.
-
-### New features
-
-* `ToolshedManager.TryParse` now also supports nullable value types.
-* Add an ignoredComponents arg to IsDefault.
-
-### Bugfixes
-
-* Fix `SpriteComponent.Layer.Visible` setter not marking a sprite's bounding box as dirty.
-* The audio params in the passed SoundSpecifier for PlayStatic(SoundSpecifier, Filter, ...) will now be used as a default like other PlayStatic overrides.
-* Fix windows not saving their positions correctly when their x position is <= 0.
-* Fix transform state handling overriding PVS detachment.
-
-
-## 261.2.0
-
-### New features
-
-* Implement IEquatable for ResolvedPathSpecifier & ResolvedCollectionSpecifier.
-* Add NearestChunkEnumerator.
-
-### Bugfixes
-
-* Fix static entities not having the center of mass updated.
-* Fix TryQueueDelete.
-* Fix tpto potentially parenting grids to non-map entities.
-
-### Other
-
-* TileChangedEvent is now raised once in clientside grid state handling rather than per tile.
-* Removed ITileDefinition.ID as it was redundant.
-* Change the lifestage checks on predicted entity deletion to check for terminating.
-
-### Internal
-
-* Update some `GetComponentName<T>` uses to generic.
-
-
-## 261.1.0
-
-### New features
-
-* Automatically create logger sawmills for `UIController`s similar to `EntitySystem`s.
-
-### Bugfixes
-
-* Fix physics forces not auto-clearing / respecting the cvar.
-
-### Internal
-
-* Cleanup more compiler warnings in unit tests.
-
-
-## 261.0.0
-
-### Breaking changes
-
-* Remove unused TryGetContainingContainer override.
-* Stop recursive FrameUpdates for controls that are not visible.
-* Initialize LocMgr earlier in the callstack for GameController.
-* Fix FastNoiseLise fractal bounding and remove its DataField property as it should be derived on other properties updating.
-* Make RaiseMoveEvent internal.
-* MovedGridsComponent and PhysicsMapComponent are now purged and properties on `SharedPhysicsSystem`. Additionally the TransformComponent for Awake entities is stored alongside the PhysicsComponent for them.
-* TransformComponent is now stored on physics contacts.
-* Gravity2DComponent and Gravity2DController were moved to SharedPhysicsSystem.
-
-### New features
-
-* `IFileDialogManager` now allows specifying `FileAccess` and `FileShare` modes.
-* Add Intersects and Enlarged to Box2i in line with Box2.
-* Make `KeyFrame`s on `AnimationTrackProperty` public settable.
-* Add the spawned entities to a returned array from `SpawnEntitiesAttachedTo`.
-
-### Bugfixes
-
-* Fixed SDL3 file dialog implementation having a memory leak and not opening files read-write.
-* Fix GetMapLinearVelocity.
-
-### Other
-
-* `uploadfile` and `loadprototype` commands now only open files with read access.
-* Optimize `ToMapCoordinates`.
-
-### Internal
-
-* Cleanup on internals of `IFileDialogManager`, removing duplicate code.
-* Fix Contacts not correctly being marked as `Touching` while contact is ongoing.
-
-
-## 260.2.0
-
-### New features
-
-* Add `StringBuilder.Insert(int, string)` to sandbox.
-* Add the WorldNormal to the StartCollideEvent.
-
-
-## 260.1.0
-
-### New features
-
-* `ComponentFactory` is now exposed to `EntitySystem` as `Factory`
-
-### Other
-
-* Cleanup warnings in PLacementManager
-* Cleanup warnings in Clide.Sprite
-
-## 260.0.0
-
-### Breaking changes
-
-* Fix / change `StartCollideEvent.WorldPoint` to return all points for the collision which may be up to 2 instead of 1.
-
-### New features
-
-* Add SpriteSystem dependency to VisualizerSystem.
-* Add Vertical property to progress bars
-* Add some `EntProtoId` overloads for group entity spawn methods.
-
-
-## 259.0.0
-
-### Breaking changes
-
-* TileChangedEvent now has an array of tile changed entries rather than raising an individual event for every single tile changed.
-
-### Other
-
-* `Entity<T>` methods were marked as `readonly` as appropriate.
-
-
-## 258.0.1
-
-### Bugfixes
-
-* Fix static physics bodies not generating contacts if they spawn onto sleeping bodies.
-
-
-## 258.0.0
-
-### Breaking changes
-
-* `IMarkupTag` and related methods in `MarkupTagManager` have been obsoleted and should be replaced with the new `IMarkupTagHandler` interface. Various engine tags (e.g., `BoldTag`, `ColorTag`, etc) no longer implement the old interface.
-
-### New features
-
-* Add IsValidPath to ResPath and make some minor performance improvements.
-
-### Bugfixes
-
-* OutputPanel and RichTextLabel now remove controls associated with rich text tags when the text is updated.
-* Fix `SpriteComponent.Visible` datafield not being read from yaml.
-* Fix container state handling not forcing inserts.
-
-### Other
-
-* `SpriteSystem.LayerMapReserve()` no longer throws an exception if the specified layer already exists. This makes it behave like the obsoleted `SpriteComponent.LayerMapReserveBlank()`.
-
-
-## 257.0.2
-
-### Bugfixes
-
-* Fix unshaded sprite layers not rendering correctly.
-
-
-## 257.0.1
-
-### Bugfixes
-
-* Fix sprite layer bounding box calculations. This was causing various sprite rendering & render-tree lookup issues.
-
-
-## 257.0.0
-
-### Breaking changes
-
-* The client will now automatically pause any entities that leave their PVS range.
-* Contacts for terminating entities no longer raise wake events.
-
-### New features
-
-* Added `IPrototypeManager.IsIgnored()` for checking whether a given prototype kind has been marked as ignored via `RegisterIgnore()`.
-* Added `PoolManager` & `TestPair` classes to `Robust.UnitTesting`. These classes make it easier to create & use pooled server/client instance pairs in integration tests.
-* Catch NotYamlSerializable DataFields with an analyzer.
-* Optimized RSI preloading and texture atlas creation.
-
-### Bugfixes
-
-* Fix clients unintentionally un-pausing paused entities that re-enter pvs range
-
-### Other
-
-* The yaml prototype id serialiser now provides better feedback when trying to validate an id for a prototype kind that has been ignored via `IPrototypeManager.RegisterIgnore()`
-* Several SpriteComponent methods have been marked as obsolete, and should be replaced with new methods in SpriteSystem.
-* Rotation events no longer check for grid traversal.
-
-
-## 256.0.0
-
-### Breaking changes
-
-* `ITypeReaderWriter<TType, TNode>` has been removed due to being unused. Implement `ITypeSerializer<TType, TNode>` instead
-* Moved AsNullable extension methods to the Entity struct.
-
-### New features
-
-* Add DevWindow tab to show all loaded textures.
-* Add Vector2i / bitmask converfsion helpers.
-* Allow texture preload to be skipped for some textures.
-* Check audio file signatures instead of extensions.
-* Add CancellationTokenRegistration to sandbox.
-* Add the ability to serialize TimeSpan from text.
-* Add support for rotated / mirrored tiles.
-
-### Bugfixes
-
-* Fix yaml hot reloading.
-* Fix a linear dictionary lookup in PlacementManager.
-
-### Other
-
-* Make ItemList not run deselection callback on all items if they aren't selected.
-* Cleanup warnings for CS0649 & CS0414.
-
-### Internal
-
-* Move PointLight component states to shared.
-
-
-## 255.1.0
-
-### New features
-
-* The client localisation manager now supports hot-reloading ftl files.
-* 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.0
-
-### Breaking changes
-
-* `RobustIntegrationTest` now pools server/client instances by default. If a custom settings class is provided, it will still disable pooling unless explicitly enabled.
-  * Server/Client instances that are returned to the pool should be disconnected. This might require you to update some tests.
-  * Pooled instances also require you to use `RobustIntegrationTest` methods like `WaitPost()` to ensure the correct thread is used.
-
-### Bugfixes
-
-* Fix `EntityDeserializer` improperly setting entity lifestages when loading a post-mapinit map.
-* Fix `EntityManager.PredictedDeleteEntity()` not deleting pure client-side entities.
-* Fix grid fixtures using a locale dependent id. This could cause some clients to crash/freeze when connected to a server with a different locale.
-
-### Other
-
-* Add logic to block cycles in master MIDI renderers, which could otherwise cause client freezes.
-
-
-## 254.1.0
-
-### New features
-
-* Add CC ND licences to the RGA validator.
-* Add entity spawn prediction and entity deletion prediction. This is currently limited as you are unable to predict interactions with these entities. These are done via the new methods prefixed with "Predicted". You can also manually flag an entity as a predicted spawn with the `FlagPredicted` method which will clean it up when prediction is reset.
-
-### Bugfixes
-
-* Fix tile edge rendering for neighbor tiles being the same priority.
-
-### Other
-
-* Fix SpawnAttachedTo's system proxy method not the rotation arg like EntityManager.
-
-
-## 254.0.0
-
-### Breaking changes
-
-* Yaml mappings/dictionaries now only support string keys instead of generic nodes
-  * Several MappingDataNode method arguments or return values now use strings instead of a DataNode object
-  * The MappingDataNode class has various helper methods that still accept a ValueDataNode, but these methods are marked as obsolete and may be removed in the future.
-  * yaml validators should use `MappingDataNode.GetKeyNode()` when validating mapping keys, so that errors can print node start & end information
-* ValueTuple yaml serialization has changed
-  * Previously they would get serialized into a single mapping with one entry (i.e., `{foo : bar }`)
-  * Now they serialize into a sequence (i.e., `[foo, bar]`)
-  * The ValueTuple serializer will still try to read mappings, but due to the MappingDataNode this may fail if the previously serialized "key" can't be read as a simple string
-
-### New features
-
-* Add cvar to disable tile edges.
-* Add GetContainingContainers method to ContainerSystem to recursively get containers upwards on an entity.
-
-### Internal
-
-* Make component lifecycle methods use generics.
-
-
-## 253.0.0
-
-### New features
-
-* Add a new `SerializationManager.PushComposition()` overload that takes in a single parent instead of an array of parents.
-* `BoundUserInterfaceMessageAttempt` once again gets raised as a broadcast event, in addition to being directed.
-  * This effectively reverts the breaking part of the changes made in v252.0.0
-* Fix CreateDistanceJoint using an int instead of a float for minimum distance.
-
-### Bugfixes
-
-* Fix deferred component removal not setting the component's life stage to `ComponentLifeStage.Stopped` if the component has not yet been initialised.
-* Fix some `EntitySystem.Resolve()` overloads not respecting the optional `logMissing` argument.
-* Fix screen-space overlays not being useable without first initializing/starting entity manager & systems
-* ItemList is now significantly optimized. VV's `AddComponent` window in particular should be much faster.
-* Fix some more MapValidator fields.
-* Fix popup text overflowing the sides of the screen.
-* Improve location reporting for non-writeable datafields via analyzer.
-
-### Other
-
-* TestPoint now uses generics rather than IPhysShape directly.
-
-
-## 252.0.0
-
-### Breaking changes
-
-* BoundUserInterfaceMessageAttempt is raised directed against entities and no longer broadcast.
-
-
-## 251.0.0
-
-### Breaking changes
-
-* Localization is now separate between client and server and is handled via cvar.
-* Contacting entities no longer can be disabled for CollisionWake to avoid destroying the contacts unnecessarily.
-
-### New features
-
-* Added `DirectionExtensions.AllDirections`, which contains a list of all `Direction`s for easy enumeration.
-* Add ForbidLiteralAttribute.
-* Log late MsgEntity again.
-* Show entity name in `physics shapeinfo` output.
-* Make SubscribeLocalEvent not require EntityEventArgs.
-* Add autocomplete to `tp` command.
-* Add button to jump to live chat when scrolled up.
-* Add autocomplete to `savemap` and `savegrid`.
-
-### Bugfixes
-
-* Fix velocity not re-applying correctly on re-parenting.
-* Fix Equatable on FormattedMessage.
-* Fix SharedTransformSystem methods logging errors on resolves.
-
-### Other
-
-* Significantly optimized tile edge rendering.
-
-### Internal
-
-* Remove duplicate GetMassData method.
-* Inline manifold points for physics.
-
-
-## 250.0.0
-
-### Breaking changes
-
-* The default shader now interprets negative color modulation as a flag that indicates that the light map should be ignored.
-  * This can be used to avoid having to change the light map texture, thus reducing draw batches.
-  * Sprite layers that are set to use the "unshaded" shader prototype now use this.
-  * Any fragment shaders that previously the `VtxModulate` colour modulation variable should instead use the new `MODULATE` variable, as the former may now contain negative values.
-
-### New features
-
-* Add OtherBody API to contacts.
-* Make FormattedMessages Equatable.
-* AnimationCompletionEvent now has the AnimationPlayerComponent.
-* Add entity description as a tooltip on the entity spawn panel.
-
-### Bugfixes
-
-* Fix serialization source generator breaking if a class has two partial locations.
-* Fix map saving throwing a `DirectoryNotFoundException` when given a path with a non-existent directory. Now it once again creates any missing directories.
-* Fix map loading taking a significant time due to MappingDataNode.Equals calls being slow.
-
-### Other
-
-* Add Pure to some Angle methods.
-
-### Internal
-
-* Cleanup some warnings in classes.
-
-
-## 249.0.0
-
-### Breaking changes
-
-* Layer is now read-only on VisibilityComponent and isn't serialized.
-
-### New features
-
-* Added a debug overlay for the linear and angular velocity of all entities on the screen. Use the `showvel` and `showangvel` commands to toggle it.
-* Add a GetWorldManifold overload that doesn't require a span of points.
-* Added a GetVisMaskEvent. Calling `RefreshVisibilityMask` will raise it and subscribers can update the vismask via the event rather than subscribers having to each manually try and handle the vismask directly.
-
-### Bugfixes
-
-* `BoxContainer` no longer causes stretching children to go below their minimum size.
-* Fix lights on other grids getting clipped due to ignoring the light range cvar.
-* Fix the `showvelocities` command.
-* Fix the DirtyFields overload not being sandbox safe for content.
-
-### Internal
-
-* Polygon vertices are now inlined with FixedArray8 and a separate SlimPolygon using FixedArray4 for hot paths rather than using pooled arrays.
+## 248.0.2-source-gen-debug
 
 
 ## 248.0.2

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/color-naming.ftl

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

@@ -1,7 +1,5 @@
 ### Localization for engine console commands
 
-cmd-hint-float = [float]
-
 ## generic command errors
 
 cmd-invalid-arg-number-error = Invalid number of arguments.
@@ -13,7 +11,6 @@ cmd-parse-failure-uid = {$arg} is not a valid entity UID.
 cmd-parse-failure-mapid = {$arg} is not a valid MapId.
 cmd-parse-failure-enum = {$arg} is not a {$enum} Enum.
 cmd-parse-failure-grid = {$arg} is not a valid grid.
-cmd-parse-failure-cultureinfo = "{$arg}" is not valid CultureInfo.
 cmd-parse-failure-entity-exist = UID {$arg} does not correspond to an existing entity.
 cmd-parse-failure-session = There is no session with username: {$username}
 
@@ -431,20 +428,11 @@ cmd-entfo-help = Usage: entfo <entityuid>
     The entity UID can be prefixed with 'c' to convert it to a client entity UID.
 
 cmd-fuck-desc = Throws an exception
-cmd-fuck-help = Usage: fuck
+cmd-fuck-help = Throws an exception
 
-cmd-showpos-desc = Show the position of all entities on the screen.
+cmd-showpos-desc = Enables debug drawing over all entity positions in the game.
 cmd-showpos-help = Usage: showpos
 
-cmd-showrot-desc = Show the rotation of all entities on the screen.
-cmd-showrot-help = Usage: showrot
-
-cmd-showvel-desc = Show the local velocity of all entites on the screen.
-cmd-showvel-help = Usage: showvel
-
-cmd-showangvel-desc = Show the angular velocity of all entities on the screen.
-cmd-showangvel-help = Usage: showangvel
-
 cmd-sggcell-desc = Lists entities on a snap grid cell.
 cmd-sggcell-help = Usage: sggcell <gridID> <vector2i>\nThat vector2i param is in the form x<int>,y<int>.
 
@@ -575,8 +563,3 @@ cmd-pvs-override-info-desc = Prints information about any PVS overrides associat
 cmd-pvs-override-info-empty = Entity {$nuid} has no PVS overrides.
 cmd-pvs-override-info-global = Entity {$nuid} has a global override.
 cmd-pvs-override-info-clients = Entity {$nuid} has a session override for {$clients}.
-
-cmd-localization_set_culture-desc = Set DefaultCulture for the client LocalizationManager
-cmd-localization_set_culture-help = Usage: localization_set_culture <cultureName>
-cmd-localization_set_culture-culture-name = <cultureName>
-cmd-localization_set_culture-changed = Localization changed to { $code } ({ $nativeName } / { $englishName })

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

@@ -9,16 +9,11 @@ entity-spawn-window-override-menu-tooltip = Override placement
 ## TileSpawnWindow
 
 tile-spawn-window-title = Place Tiles
-tile-spawn-window-mirror-button-text = Mirror Tiles
 
 ## Console
 
 console-line-edit-placeholder = Command Here
 
-## OutputPanel
-
-output-panel-scroll-down-button-text = Scroll Down
-
 ## Common Used
 
 window-erase-button-text = Erase Mode

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

@@ -1,10 +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 }

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 =

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,141 +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")
-        );
-    }
-
-    [Test]
-    public async Task ReadOnlyFieldTest()
-    {
-        const string code = """
-            using Robust.Shared.Serialization.Manager.Attributes;
-
-            [DataDefinition]
-            public sealed partial class Foo
-            {
-                [DataField]
-                public readonly int Bad;
-
-                [DataField]
-                public int Good;
-            }
-            """;
-
-        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")
-        );
-    }
-
-    [Test]
-    public async Task ReadOnlyPropertyTest()
-    {
-        const string code = """
-            using Robust.Shared.Serialization.Manager.Attributes;
-
-            [DataDefinition]
-            public sealed partial class Foo
-            {
-                [DataField]
-                public int Bad { get; }
-
-                [DataField]
-                public int Good { get; private set; }
-            }
-            """;
-
-        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 { }
-
-            [DataDefinition]
-            public sealed partial class Foo
-            {
-                [DataField]
-                public NotSerializableClass BadField;
-
-                [DataField]
-                public NotSerializableClass BadProperty { get; set; }
-
-                public NotSerializableClass GoodField; // Not a DataField, not a problem
-
-                public NotSerializableClass GoodProperty { get; set; } // Not a DataField, not a problem
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(10,12): error RA0033: Data field BadField in data definition Foo is type NotSerializableClass, which is not YAML serializable
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(10, 12, 10, 32).WithArguments("BadField", "Foo", "NotSerializableClass"),
-            // /0/Test0.cs(13,12): error RA0033: Data field BadProperty in data definition Foo is type NotSerializableClass, which is not YAML serializable
-            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldYamlSerializableRule).WithSpan(13, 12, 13, 32).WithArguments("BadProperty", "Foo", "NotSerializableClass")
+            // /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")
         );
     }
 }

Robust.Analyzers.Tests/ForbidLiteralAnalyzerTest.cs

@@ -1,189 +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.ForbidLiteralAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
-
-
-namespace Robust.Analyzers.Tests;
-
-[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
-[TestFixture]
-public sealed class ForbidLiteralAnalyzerTest
-{
-    private static Task Verifier(string code, params DiagnosticResult[] expected)
-    {
-        var test = new CSharpAnalyzerTest<ForbidLiteralAnalyzer, DefaultVerifier>()
-        {
-            TestState =
-            {
-                Sources = { code },
-            },
-        };
-
-        TestHelper.AddEmbeddedSources(
-            test.TestState,
-            "Robust.Shared.Analyzers.ForbidLiteralAttribute.cs"
-        );
-
-        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.Collections.Generic;
-        using Robust.Shared.Analyzers;
-
-        public sealed class TestClass
-        {
-            public static void OneParameterForbidden([ForbidLiteral] string value) { }
-            public static void TwoParametersFirstForbidden([ForbidLiteral] string first, string second) { }
-            public static void TwoParametersBothForbidden([ForbidLiteral] string first, [ForbidLiteral] string second) { }
-            public static void ListParameterForbidden([ForbidLiteral] List<string> values) { }
-            public static void ParamsListParameterForbidden([ForbidLiteral] params List<string> values) { }
-        }
-
-        public record struct StringWrapper(string value)
-        {
-            private readonly string _value = value;
-
-            public static implicit operator string(StringWrapper wrapper)
-            {
-                return wrapper._value;
-            }
-        }
-    """;
-
-    [Test]
-    public async Task TestOneParameter()
-    {
-        const string code = """
-            public sealed class Tester
-            {
-                private const string _constValue = "foo";
-                private static readonly string StaticValue = "bar";
-                private static readonly StringWrapper WrappedValue = new("biz");
-
-                public void Test()
-                {
-                    TestClass.OneParameterForbidden(_constValue);
-                    TestClass.OneParameterForbidden(StaticValue);
-                    TestClass.OneParameterForbidden(WrappedValue);
-                    TestClass.OneParameterForbidden("baz");
-                }
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(12,41): error RA0033: The "value" parameter of OneParameterForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(12, 41, 12, 46).WithArguments("value", "OneParameterForbidden")
-        );
-    }
-
-    [Test]
-    public async Task TestTwoParametersFirstForbidden()
-    {
-        const string code = """
-            public sealed class Tester
-            {
-                private const string _constValue = "foo";
-
-                public void Test()
-                {
-                    TestClass.TwoParametersFirstForbidden(_constValue, "whatever");
-                    TestClass.TwoParametersFirstForbidden(_constValue, _constValue);
-                    TestClass.TwoParametersFirstForbidden("foo", "whatever");
-                }
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(9,47): error RA0033: The "first" parameter of TwoParametersFirstForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(9, 47, 9, 52).WithArguments("first", "TwoParametersFirstForbidden")
-        );
-    }
-
-    [Test]
-    public async Task TestTwoParametersBothForbidden()
-    {
-        const string code = """
-            public sealed class Tester
-            {
-                private const string _constValue = "foo";
-                private static readonly string StaticValue = "bar";
-
-                public void Test()
-                {
-                    TestClass.TwoParametersBothForbidden(_constValue, _constValue);
-                    TestClass.TwoParametersBothForbidden(_constValue, StaticValue);
-                    TestClass.TwoParametersBothForbidden(_constValue, "whatever");
-                    TestClass.TwoParametersBothForbidden("whatever", _constValue);
-                }
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(10,59): error RA0033: The "second" parameter of TwoParametersBothForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(10, 59, 10, 69).WithArguments("second", "TwoParametersBothForbidden"),
-            // /0/Test0.cs(11,46): error RA0033: The "first" parameter of TwoParametersBothForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(11, 46, 11, 56).WithArguments("first", "TwoParametersBothForbidden")
-        );
-    }
-
-    [Test]
-    public async Task TestListParameter()
-    {
-        const string code = """
-            public sealed class Tester
-            {
-                private const string _constValue = "foo";
-                private static readonly string StaticValue = "bar";
-                private static readonly StringWrapper WrappedValue = new("biz");
-
-                public void Test()
-                {
-                    TestClass.ListParameterForbidden([_constValue, StaticValue, WrappedValue]);
-                    TestClass.ListParameterForbidden(["foo", _constValue, "bar"]);
-                }
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(10,43): warning RA0033: The "values" parameter of ListParameterForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(10, 43, 10, 48).WithArguments("values", "ListParameterForbidden"),
-            // /0/Test0.cs(10,63): warning RA0033: The "values" parameter of ListParameterForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(10, 63, 10, 68).WithArguments("values", "ListParameterForbidden")
-        );
-    }
-
-    [Test]
-    public async Task TestParamsListParameter()
-    {
-        const string code = """
-            public sealed class Tester
-            {
-                private const string _constValue = "foo";
-                private static readonly string StaticValue = "bar";
-                private static readonly StringWrapper WrappedValue = new("biz");
-
-                public void Test()
-                {
-                    TestClass.ParamsListParameterForbidden(_constValue, StaticValue, WrappedValue);
-                    TestClass.ParamsListParameterForbidden("foo", _constValue, "bar");
-                }
-            }
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(10,48): warning RA0033: The "values" parameter of ParamsListParameterForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(10, 48, 10, 53).WithArguments("values", "ParamsListParameterForbidden"),
-            // /0/Test0.cs(10,68): warning RA0033: The "values" parameter of ParamsListParameterForbidden forbids literal values
-            VerifyCS.Diagnostic().WithSpan(10, 68, 10, 73).WithArguments("values", "ParamsListParameterForbidden")
-        );
-    }
-}

Robust.Analyzers.Tests/ObsoleteInheritanceAnalyzerTest.cs

@@ -1,86 +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.ObsoleteInheritanceAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
-
-namespace Robust.Analyzers.Tests;
-
-/// <summary>
-/// Analyzer that implements <c>[ObsoleteInheritance]</c> checking, to give obsoletion warnings for inheriting types
-/// that should never have been virtual.
-/// </summary>
-[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
-[TestFixture]
-public sealed class ObsoleteInheritanceAnalyzerTest
-{
-    private static Task Verifier(string code, params DiagnosticResult[] expected)
-    {
-        var test = new CSharpAnalyzerTest<ObsoleteInheritanceAnalyzer, DefaultVerifier>()
-        {
-            TestState =
-            {
-                Sources = { code },
-            },
-        };
-
-        TestHelper.AddEmbeddedSources(
-            test.TestState,
-            "Robust.Shared.Analyzers.ObsoleteInheritanceAttribute.cs"
-        );
-
-        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
-        test.TestState.ExpectedDiagnostics.AddRange(expected);
-
-        return test.RunAsync();
-    }
-
-    [Test]
-    public async Task TestBasic()
-    {
-        const string code = """
-            using Robust.Shared.Analyzers;
-
-            [ObsoleteInheritance]
-            public class Base;
-
-            public class NotAllowed : Base;
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(6,14): warning RA0034: Type 'NotAllowed' inherits from 'Base', which has obsoleted inheriting from itself
-            VerifyCS.Diagnostic(ObsoleteInheritanceAnalyzer.Rule).WithSpan(6, 14, 6, 24).WithArguments("NotAllowed", "Base")
-            );
-    }
-
-    [Test]
-    public async Task TestMessage()
-    {
-        const string code = """
-            using Robust.Shared.Analyzers;
-
-            [ObsoleteInheritance("Sus")]
-            public class Base;
-
-            public class NotAllowed : Base;
-            """;
-
-        await Verifier(code,
-            // /0/Test0.cs(6,14): warning RA0034: Type 'NotAllowed' inherits from 'Base', which has obsoleted inheriting from itself: "Sus"
-            VerifyCS.Diagnostic(ObsoleteInheritanceAnalyzer.RuleWithMessage).WithSpan(6, 14, 6, 24).WithArguments("NotAllowed", "Base", "Sus")
-        );
-    }
-
-    [Test]
-    public async Task TestNormal()
-    {
-        const string code = """
-            public class Base;
-
-            public class AllowedAllowed : Base;
-            """;
-
-        await Verifier(code);
-    }
-}

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

@@ -13,14 +13,8 @@
     <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" />
-    <EmbeddedResource Include="..\Robust.Shared\Analyzers\ForbidLiteralAttribute.cs" LogicalName="Robust.Shared.Analyzers.ForbidLiteralAttribute.cs" LinkBase="Implementations" />
-    <EmbeddedResource Include="..\Robust.Shared\Analyzers\ObsoleteInheritanceAttribute.cs" LogicalName="Robust.Shared.Analyzers.ObsoleteInheritanceAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\GameObjects\EventBusAttributes.cs" LogicalName="Robust.Shared.GameObjects.EventBusAttributes.cs" LinkBase="Implementations" />
-    <EmbeddedResource Include="..\Robust.Shared\Serialization\NetSerializableAttribute.cs" LogicalName="Robust.Shared.Serialization.NetSerializableAttribute.cs" LinkBase="Implementations" />
-    <EmbeddedResource Include="..\Robust.Shared\Prototypes\Attributes.cs" LogicalName="Robust.Shared.Prototypes.Attributes.cs" LinkBase="Implementations" />
-    <EmbeddedResource Include="..\Robust.Shared\Prototypes\IPrototype.cs" LogicalName="Robust.Shared.Prototypes.IPrototype.cs" LinkBase="Implementations" />
-    <EmbeddedResource Include="..\Robust.Shared\Serialization\Manager\Attributes\DataFieldAttribute.cs" LogicalName="Robust.Shared.Serialization.Manager.Attributes.DataFieldAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <PropertyGroup>

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -18,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",
@@ -42,7 +41,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to mark any type containing a nested data definition as partial."
     );
 
-    public static readonly DiagnosticDescriptor DataFieldWritableRule = new(
+    private static readonly DiagnosticDescriptor DataFieldWritableRule = new(
         Diagnostics.IdDataFieldWritable,
         "Data field must not be readonly",
         "Data field {0} in data definition {1} is readonly",
@@ -52,7 +51,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to remove the readonly modifier."
     );
 
-    public static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
+    private static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
         Diagnostics.IdDataFieldPropertyWritable,
         "Data field property must have a setter",
         "Data field property {0} in data definition {1} does not have a setter",
@@ -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,31 @@ 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));
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), 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,49 +163,32 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
                 TryGetAttributeLocation(field, ViewVariablesAttributeName, out var location);
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, fieldSymbol.Name, type.Name));
             }
-
-            if (context.SemanticModel.GetSymbolInfo(field.Declaration.Type).Symbol is not ITypeSymbol fieldTypeSymbol)
-                continue;
-
-            if (IsNotYamlSerializable(fieldSymbol, fieldTypeSymbol))
-            {
-                context.ReportDiagnostic(Diagnostic.Create(DataFieldYamlSerializableRule,
-                    (context.Node as FieldDeclarationSyntax)?.Declaration.Type.GetLocation(),
-                    fieldSymbol.Name,
-                    type.Name,
-                    fieldTypeSymbol.MetadataName
-                ));
-            }
         }
     }
 
-    private 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));
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), 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));
@@ -235,23 +199,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;
-
-        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);
     }
 
@@ -331,20 +285,6 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
-    private static bool TryGetModifierLocation(MemberDeclarationSyntax syntax, SyntaxKind modifierKind, out Location location)
-    {
-        foreach (var modifier in syntax.Modifiers)
-        {
-            if (modifier.IsKind(modifierKind))
-            {
-                location = modifier.GetLocation();
-                return true;
-            }
-        }
-        location = syntax.GetLocation();
-        return false;
-    }
-
     private static bool IsReadOnlyMember(ITypeSymbol type, ISymbol member)
     {
         if (member is IFieldSymbol field)
@@ -376,14 +316,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)
@@ -398,6 +341,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())
@@ -421,11 +367,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/ForbidLiteralAnalyzer.cs

@@ -1,101 +0,0 @@
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Operations;
-using Robust.Roslyn.Shared;
-
-namespace Robust.Analyzers;
-
-[DiagnosticAnalyzer(LanguageNames.CSharp)]
-public sealed class ForbidLiteralAnalyzer : DiagnosticAnalyzer
-{
-    private const string ForbidLiteralType = "Robust.Shared.Analyzers.ForbidLiteralAttribute";
-
-    public static DiagnosticDescriptor ForbidLiteralRule = new(
-        Diagnostics.IdForbidLiteral,
-        "Parameter forbids literal values",
-        "The {0} parameter of {1} forbids literal values",
-        "Usage",
-        DiagnosticSeverity.Warning,
-        true,
-        "Pass in a validated wrapper type like ProtoId, or a const or static value."
-    );
-
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [ForbidLiteralRule];
-
-    public override void Initialize(AnalysisContext context)
-    {
-        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
-        context.EnableConcurrentExecution();
-        context.RegisterOperationAction(AnalyzeOperation, OperationKind.Invocation);
-    }
-
-    private void AnalyzeOperation(OperationAnalysisContext context)
-    {
-        if (context.Operation is not IInvocationOperation invocationOperation)
-            return;
-
-        // Check each parameter of the method invocation
-        foreach (var argumentOperation in invocationOperation.Arguments)
-        {
-            // Check for our attribute on the parameter
-            if (!AttributeHelper.HasAttribute(argumentOperation.Parameter, ForbidLiteralType, out _))
-                continue;
-
-            // Handle parameters using the params keyword
-            if (argumentOperation.Syntax is InvocationExpressionSyntax subExpressionSyntax)
-            {
-                // Check each param value
-                foreach (var subArgument in subExpressionSyntax.ArgumentList.Arguments)
-                {
-                    CheckArgumentSyntax(context, argumentOperation, subArgument);
-                }
-                continue;
-            }
-
-            // Not params, so just check the single parameter
-            if (argumentOperation.Syntax is not ArgumentSyntax argumentSyntax)
-                continue;
-
-            CheckArgumentSyntax(context, argumentOperation, argumentSyntax);
-        }
-    }
-
-    private void CheckArgumentSyntax(OperationAnalysisContext context, IArgumentOperation operation, ArgumentSyntax argumentSyntax)
-    {
-        // Handle collection types
-        if (argumentSyntax.Expression is CollectionExpressionSyntax collectionExpressionSyntax)
-        {
-            // Check each value of the collection
-            foreach (var elementSyntax in collectionExpressionSyntax.Elements)
-            {
-                if (elementSyntax is not ExpressionElementSyntax expressionSyntax)
-                    continue;
-
-                // Check if a literal was passed in
-                if (expressionSyntax.Expression is not LiteralExpressionSyntax)
-                    continue;
-
-                context.ReportDiagnostic(Diagnostic.Create(ForbidLiteralRule,
-                    expressionSyntax.GetLocation(),
-                    operation.Parameter.Name,
-                    (context.Operation as IInvocationOperation).TargetMethod.Name
-                ));
-            }
-            return;
-        }
-
-        // Not a collection, just a single value to check
-        // Check if it's a literal
-        if (argumentSyntax.Expression is not LiteralExpressionSyntax)
-            return;
-
-        context.ReportDiagnostic(Diagnostic.Create(ForbidLiteralRule,
-            argumentSyntax.GetLocation(),
-            operation.Parameter.Name,
-            (context.Operation as IInvocationOperation).TargetMethod.Name
-        ));
-    }
-}

Robust.Analyzers/ObsoleteInheritanceAnalyzer.cs

@@ -1,75 +0,0 @@
-#nullable enable
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Robust.Roslyn.Shared;
-
-namespace Robust.Analyzers;
-
-[DiagnosticAnalyzer(LanguageNames.CSharp)]
-public sealed class ObsoleteInheritanceAnalyzer : DiagnosticAnalyzer
-{
-    private const string Attribute = "Robust.Shared.Analyzers.ObsoleteInheritanceAttribute";
-
-    public static readonly DiagnosticDescriptor Rule = new(
-        Diagnostics.IdObsoleteInheritance,
-        "Parent type has obsoleted inheritance",
-        "Type '{0}' inherits from '{1}', which has obsoleted inheriting from itself",
-        "Usage",
-        DiagnosticSeverity.Warning,
-        true);
-
-    public static readonly DiagnosticDescriptor RuleWithMessage = new(
-        Diagnostics.IdObsoleteInheritanceWithMessage,
-        "Parent type has obsoleted inheritance",
-        "Type '{0}' inherits from '{1}', which has obsoleted inheriting from itself: \"{2}\"",
-        "Usage",
-        DiagnosticSeverity.Warning,
-        true);
-
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule, RuleWithMessage];
-
-    public override void Initialize(AnalysisContext context)
-    {
-        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-        context.EnableConcurrentExecution();
-        context.RegisterSymbolAction(CheckClass, SymbolKind.NamedType);
-    }
-
-    private static void CheckClass(SymbolAnalysisContext context)
-    {
-        if (context.Symbol is not INamedTypeSymbol typeSymbol)
-            return;
-
-        if (typeSymbol.IsValueType || typeSymbol.BaseType is not { } baseType)
-            return;
-
-        if (!AttributeHelper.HasAttribute(baseType, Attribute, out var data))
-            return;
-
-        var location = context.Symbol.Locations[0];
-
-        if (GetMessageFromAttributeData(data) is { } message)
-        {
-            context.ReportDiagnostic(Diagnostic.Create(
-                RuleWithMessage,
-                location,
-                [typeSymbol.Name, baseType.Name, message]));
-        }
-        else
-        {
-            context.ReportDiagnostic(Diagnostic.Create(
-                Rule,
-                location,
-                [typeSymbol.Name, baseType.Name]));
-        }
-    }
-
-    private static string? GetMessageFromAttributeData(AttributeData data)
-    {
-        if (data.ConstructorArguments is not [var message, ..])
-            return null;
-
-        return message.Value as string;
-    }
-}

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.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -42,8 +42,8 @@ public class RecursiveMoveBenchmark : RobustIntegrationTest
     public void GlobalSetup()
     {
         ProgramShared.PathOffset = "../../../../";
-        var server = StartServer(new() {Pool = false});
-        var client = StartClient(new() {Pool = false});
+        var server = StartServer();
+        var client = StartClient();
 
         Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()).Wait();
 

Robust.Client.WebView/Cef/Program.cs

@@ -6,7 +6,7 @@ using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
 {
-    internal static class Program
+    public static class Program
     {
         // This was supposed to be the main entry for the subprocess program... It doesn't work.
         public static int Main(string[] args)

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

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

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/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.
@@ -120,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:

Robust.Client/Audio/AudioManager.cs

@@ -57,8 +57,8 @@ internal sealed partial class AudioManager : IAudioInternal
         _checkAlError();
 
         // Load up AL context extensions.
-        var s = ALC.GetString(_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);
         }

Robust.Client/Audio/AudioSystem.cs

@@ -582,7 +582,7 @@ 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;
         }
 
@@ -626,7 +626,7 @@ 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;
         }
 
@@ -753,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,5 +1,4 @@
 using System;
-using System.Numerics;
 using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
 using Robust.Shared.Audio;
 using Robust.Shared.Audio.Effects;

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -6,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>

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

@@ -119,7 +119,7 @@ internal sealed partial class MidiManager : IMidiManager
     private const string OsxSoundfont =
         "/System/Library/Components/CoreAudio.component/Contents/Resources/gs_instruments.dls";
 
-    private static readonly ResPath FallbackSoundfont = new ResPath("/Midi/fallback.sf2");
+    private const string FallbackSoundfont = "/Midi/fallback.sf2";
 
     private const string ContentCustomSoundfontDirectory = "/Audio/MidiCustom/";
 
@@ -265,7 +265,81 @@ internal sealed partial class MidiManager : IMidiManager
 
             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;
 
@@ -498,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;
@@ -226,9 +226,6 @@ internal sealed partial class MidiRenderer : IMidiRenderer
             if (value == _master)
                 return;
 
-            if (CheckMasterCycle(value))
-                throw new InvalidOperationException("Tried to set master to a child of this renderer!");
-
             if (_master is { Disposed: false })
             {
                 try
@@ -435,6 +432,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();
@@ -575,28 +581,18 @@ internal sealed partial class MidiRenderer : IMidiRenderer
                     case RobustMidiCommand.NoteOff:
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = 0;
                         _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.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
-
-                            break;
-                        }
-
                         if (FilteredChannels[midiEvent.Channel])
                             break;
 
-                        velocity = VelocityOverride ?? midiEvent.Velocity;
+                        var velocity = VelocityOverride ?? midiEvent.Velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[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);
@@ -733,22 +729,4 @@ internal sealed partial class MidiRenderer : IMidiRenderer
         _synth?.Dispose();
         _player?.Dispose();
     }
-
-    /// <summary>
-    /// Check that a given renderer is not already a child of this renderer, i.e. it would introduce a cycle if set as master of this renderer.
-    /// </summary>
-    private bool CheckMasterCycle(IMidiRenderer? otherRenderer)
-    {
-        // Doesn't inside drift, cringe.
-
-        while (otherRenderer != null)
-        {
-            if (otherRenderer == this)
-                return true;
-
-            otherRenderer = otherRenderer.Master;
-        }
-
-        return false;
-    }
 }

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

@@ -173,51 +173,29 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal sealed class ShowPositionsCommand : LocalizedEntityCommands
+    internal sealed class ShowPositionsCommand : LocalizedCommands
     {
-        [Dependency] private readonly DebugDrawingSystem _debugDrawing = default!;
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
 
         public override string Command => "showpos";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _debugDrawing.DebugPositions = !_debugDrawing.DebugPositions;
+            var mgr = _entitySystems.GetEntitySystem<DebugDrawingSystem>();
+            mgr.DebugPositions = !mgr.DebugPositions;
         }
     }
 
-    internal sealed class ShowRotationsCommand : LocalizedEntityCommands
+    internal sealed class ShowRotationsCommand : LocalizedCommands
     {
-        [Dependency] private readonly DebugDrawingSystem _debugDrawing = default!;
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
 
         public override string Command => "showrot";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _debugDrawing.DebugRotations = !_debugDrawing.DebugRotations;
-        }
-    }
-
-    internal sealed class ShowVelocitiesCommand : LocalizedEntityCommands
-    {
-        [Dependency] private readonly DebugDrawingSystem _debugDrawing = default!;
-
-        public override string Command => "showvel";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            _debugDrawing.DebugVelocities = !_debugDrawing.DebugVelocities;
-        }
-    }
-
-    internal sealed class ShowAngularVelocitiesCommand : LocalizedEntityCommands
-    {
-        [Dependency] private readonly DebugDrawingSystem _debugDrawing = default!;
-
-        public override string Command => "showangvel";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            _debugDrawing.DebugAngularVelocities = !_debugDrawing.DebugAngularVelocities;
+            var mgr = _entitySystems.GetEntitySystem<DebugDrawingSystem>();
+            mgr.DebugRotations = !mgr.DebugRotations;
         }
     }
 

Robust.Client/Console/Commands/DebugAnchoredCommand.cs

@@ -1,19 +1,17 @@
 #if DEBUG
 using Robust.Client.Debugging;
 using Robust.Shared.Console;
-using Robust.Shared.IoC;
+using Robust.Shared.GameObjects;
 
 namespace Robust.Client.Console.Commands
 {
-    public sealed class DebugAnchoredCommand : LocalizedEntityCommands
+    public sealed class DebugAnchoredCommand : LocalizedCommands
     {
-        [Dependency] private readonly DebugAnchoringSystem _system = default!;
-
         public override string Command => "showanchored";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _system.Enabled ^= true;
+            EntitySystem.Get<DebugAnchoringSystem>().Enabled ^= true;
         }
     }
 }

Robust.Client/Console/Commands/LightBBCommand.cs

@@ -1,19 +1,17 @@
 #if DEBUG
 using Robust.Client.GameObjects;
 using Robust.Shared.Console;
-using Robust.Shared.IoC;
+using Robust.Shared.GameObjects;
 
 namespace Robust.Client.Console.Commands
 {
-    internal sealed class LightDebugCommand : LocalizedEntityCommands
+    internal sealed class LightDebugCommand : LocalizedCommands
     {
-        [Dependency] private readonly DebugLightTreeSystem _system = default!;
-
         public override string Command => "lightbb";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _system.Enabled ^= true;
+            EntitySystem.Get<DebugLightTreeSystem>().Enabled ^= true;
         }
     }
 }

Robust.Client/Console/Commands/LocalizationCommands.cs

@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using JetBrains.Annotations;
-using Robust.Shared.Console;
-using Robust.Shared.Localization;
-
-namespace Robust.Client.Console.Commands;
-
-[UsedImplicitly]
-internal sealed class LocalizationSetCulture : LocalizedCommands
-{
-    private const string Name = "localization_set_culture";
-    private const int ArgumentCount = 1;
-
-    public override string Command => Name;
-
-    public override void Execute(IConsoleShell shell, string argStr, string[] args)
-    {
-        if (args.Length != ArgumentCount)
-        {
-            shell.WriteError(Loc.GetString("cmd-invalid-arg-number-error"));
-            return;
-        }
-
-        CultureInfo culture;
-        try
-        {
-            culture = CultureInfo.GetCultureInfo(args[0], predefinedOnly: false);
-        }
-        catch (CultureNotFoundException)
-        {
-            shell.WriteError(Loc.GetString("cmd-parse-failure-cultureinfo", ("arg", args[0])));
-            return;
-        }
-
-        LocalizationManager.SetCulture(culture);
-        shell.WriteLine(LocalizationManager.GetString("cmd-localization_set_culture-changed",
-            ("code", culture.Name),
-            ("nativeName", culture.NativeName),
-            ("englishName", culture.EnglishName)));
-    }
-
-    public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
-    {
-        return args.Length switch
-        {
-            1 => CompletionResult.FromHintOptions(GetCultureNames(),
-                LocalizationManager.GetString("cmd-localization_set_culture-culture-name")),
-            _ => CompletionResult.Empty
-        };
-    }
-
-    private static HashSet<string> GetCultureNames()
-    {
-        var cultureInfos = CultureInfo.GetCultures(CultureTypes.AllCultures)
-            .Where(x => !string.IsNullOrEmpty(x.Name))
-            .ToArray();
-
-        var allNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-        allNames.UnionWith(cultureInfos.Select(x => x.TwoLetterISOLanguageName));
-        allNames.UnionWith(cultureInfos.Select(x => x.Name));
-
-        return allNames;
-    }
-}

Robust.Client/Console/Commands/ShowPlayerVelocityCommand.cs

@@ -1,18 +0,0 @@
-using Robust.Client.GameObjects;
-using Robust.Shared.Console;
-using Robust.Shared.IoC;
-
-namespace Robust.Client.Console.Commands
-{
-    public sealed class ShowPlayerVelocityCommand : LocalizedEntityCommands
-    {
-        [Dependency] private readonly ShowPlayerVelocityDebugSystem _system = default!;
-
-        public override string Command => "showplayervelocity";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            _system.Enabled ^= true;
-        }
-    }
-}

Robust.Client/Console/Commands/VelocitiesCommand.cs

@@ -0,0 +1,19 @@
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Console.Commands
+{
+    public sealed class VelocitiesCommand : LocalizedCommands
+    {
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+
+        public override string Command => "showvelocities";
+
+        public override void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            _entitySystems.GetEntitySystem<VelocityDebugSystem>().Enabled ^= true;
+        }
+    }
+}

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

@@ -1,221 +1,140 @@
+using System.Numerics;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
-using Robust.Shared.Physics.Components;
-using System.Numerics;
 
-namespace Robust.Client.Debugging;
-
-/// <summary>
-/// A collection of visual debug overlays for the client game.
-/// </summary>
-public sealed class DebugDrawingSystem : EntitySystem
+namespace Robust.Client.Debugging
 {
-    [Dependency] private readonly IOverlayManager _overlayManager = default!;
-    [Dependency] private readonly EntityLookupSystem _lookup = default!;
-    [Dependency] private readonly SharedTransformSystem _transform = default!;
-
-    private bool _debugPositions;
-    private bool _debugRotations;
-    private bool _debugVelocities;
-    private bool _debugAngularVelocities;
-
     /// <summary>
-    /// Toggles the visual overlay of the local origin for each entity on screen.
+    /// A collection of visual debug overlays for the client game.
     /// </summary>
-    public bool DebugPositions
+    public sealed class DebugDrawingSystem : EntitySystem
     {
-        get => _debugPositions;
-        set
+        [Dependency] private readonly IOverlayManager _overlayManager = default!;
+        [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
+
+
+        private bool _debugPositions;
+        private bool _debugRotations;
+
+        /// <summary>
+        /// Toggles the visual overlay of the local origin for each entity on screen.
+        /// </summary>
+        public bool DebugPositions
         {
-            if (value == DebugPositions)
+            get => _debugPositions;
+            set
             {
-                return;
-            }
+                if (value == DebugPositions)
+                {
+                    return;
+                }
 
-            _debugPositions = value;
+                _debugPositions = value;
 
-            if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
-            {
-                _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, _transform));
-            }
-            else
-            {
-                _overlayManager.RemoveOverlay<EntityPositionOverlay>();
+                if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
+                {
+                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, EntityManager, _transform));
+                }
+                else
+                {
+                    _overlayManager.RemoveOverlay<EntityPositionOverlay>();
+                }
             }
         }
-    }
 
-    /// <summary>
-    /// Toggles the visual overlay of the rotation for each entity on screen.
-    /// </summary>
-    public bool DebugRotations
-    {
-        get => _debugRotations;
-        set
+        /// <summary>
+        /// Toggles the visual overlay of the local rotation.
+        /// </summary>
+        public bool DebugRotations
         {
-            if (value == DebugRotations)
+            get => _debugRotations;
+            set
             {
-                return;
-            }
+                if (value == DebugRotations)
+                {
+                    return;
+                }
 
-            _debugRotations = value;
+                _debugRotations = value;
 
-            if (value && !_overlayManager.HasOverlay<EntityRotationOverlay>())
-            {
-                _overlayManager.AddOverlay(new EntityRotationOverlay(_lookup, _transform));
-            }
-            else
-            {
-                _overlayManager.RemoveOverlay<EntityRotationOverlay>();
+                if (value && !_overlayManager.HasOverlay<EntityRotationOverlay>())
+                {
+                    _overlayManager.AddOverlay(new EntityRotationOverlay(_lookup, EntityManager));
+                }
+                else
+                {
+                    _overlayManager.RemoveOverlay<EntityRotationOverlay>();
+                }
             }
         }
-    }
 
-    /// <summary>
-    /// Toggles the visual overlay of the local velocity for each entity on screen.
-    /// </summary>
-    public bool DebugVelocities
-    {
-        get => _debugVelocities;
-        set
+        private sealed class EntityPositionOverlay : Overlay
         {
-            if (value == DebugVelocities)
+            private readonly EntityLookupSystem _lookup;
+            private readonly IEntityManager _entityManager;
+            private readonly SharedTransformSystem _transform;
+
+            public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+            public EntityPositionOverlay(EntityLookupSystem lookup, IEntityManager entityManager, SharedTransformSystem transform)
             {
-                return;
+                _lookup = lookup;
+                _entityManager = entityManager;
+                _transform = transform;
             }
 
-            _debugVelocities = value;
+            protected internal override void Draw(in OverlayDrawArgs args)
+            {
+                const float stubLength = 0.25f;
 
-            if (value && !_overlayManager.HasOverlay<EntityVelocityOverlay>())
-            {
-                _overlayManager.AddOverlay(new EntityVelocityOverlay(EntityManager, _lookup, _transform));
-            }
-            else
-            {
-                _overlayManager.RemoveOverlay<EntityVelocityOverlay>();
+                var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
+
+                foreach (var entity in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
+                {
+                    var (center, worldRotation) = _transform.GetWorldPositionRotation(entity);
+
+                    var xLine = worldRotation.RotateVec(Vector2.UnitX);
+                    var yLine = worldRotation.RotateVec(Vector2.UnitY);
+
+                    worldHandle.DrawLine(center, center + xLine * stubLength, Color.Red);
+                    worldHandle.DrawLine(center, center + yLine * stubLength, Color.Green);
+                }
             }
         }
-    }
 
-    /// <summary>
-    /// Toggles the visual overlay of the angular velocity for each entity on screen.
-    /// </summary>
-    public bool DebugAngularVelocities
-    {
-        get => _debugAngularVelocities;
-        set
+        private sealed class EntityRotationOverlay : Overlay
         {
-            if (value == DebugAngularVelocities)
+            private readonly EntityLookupSystem _lookup;
+            private readonly IEntityManager _entityManager;
+
+            public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+            public EntityRotationOverlay(EntityLookupSystem lookup, IEntityManager entityManager)
             {
-                return;
+                _lookup = lookup;
+                _entityManager = entityManager;
             }
 
-            _debugAngularVelocities = value;
-
-            if (value && !_overlayManager.HasOverlay<EntityAngularVelocityOverlay>())
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
-                _overlayManager.AddOverlay(new EntityAngularVelocityOverlay(EntityManager, _lookup, _transform));
-            }
-            else
-            {
-                _overlayManager.RemoveOverlay<EntityAngularVelocityOverlay>();
-            }
-        }
-    }
-    private sealed class EntityPositionOverlay(EntityLookupSystem _lookup, SharedTransformSystem _transform) : Overlay
-    {
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+                const float stubLength = 0.25f;
+                var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
+                var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
 
-        protected internal override void Draw(in OverlayDrawArgs args)
-        {
-            const float stubLength = 0.25f;
+                foreach (var entity in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
+                {
+                    var (center, worldRotation) = xformQuery.GetComponent(entity).GetWorldPositionRotation();
 
-            var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
+                    var drawLine = worldRotation.RotateVec(-Vector2.UnitY);
 
-            foreach (var uid in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
-            {
-                var (center, worldRotation) = _transform.GetWorldPositionRotation(uid);
-
-                var xLine = worldRotation.RotateVec(Vector2.UnitX);
-                var yLine = worldRotation.RotateVec(Vector2.UnitY);
-
-                worldHandle.DrawLine(center, center + xLine * stubLength, Color.Red);
-                worldHandle.DrawLine(center, center + yLine * stubLength, Color.Green);
-            }
-        }
-    }
-
-    private sealed class EntityRotationOverlay(EntityLookupSystem _lookup, SharedTransformSystem _transform) : Overlay
-    {
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
-
-        protected internal override void Draw(in OverlayDrawArgs args)
-        {
-            const float stubLength = 0.25f;
-            var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
-
-            foreach (var uid in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
-            {
-                var (center, worldRotation) = _transform.GetWorldPositionRotation(uid);
-
-                var drawLine = worldRotation.RotateVec(-Vector2.UnitY);
-
-                worldHandle.DrawLine(center, center + drawLine * stubLength, Color.Red);
-            }
-        }
-    }
-
-    private sealed class EntityVelocityOverlay(IEntityManager _entityManager, EntityLookupSystem _lookup, SharedTransformSystem _transform) : Overlay
-    {
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
-
-        protected internal override void Draw(in OverlayDrawArgs args)
-        {
-            const float multiplier = 0.2f;
-
-            var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
-
-            var physicsQuery = _entityManager.GetEntityQuery<PhysicsComponent>();
-            foreach (var uid in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
-            {
-                if(!physicsQuery.TryGetComponent(uid, out var physicsComp))
-                    continue;
-
-                var center = _transform.GetWorldPosition(uid);
-                var localVelocity = physicsComp.LinearVelocity;
-
-                if (localVelocity != Vector2.Zero)
-                    worldHandle.DrawLine(center, center + localVelocity * multiplier, Color.Yellow);
-            }
-        }
-    }
-
-    private sealed class EntityAngularVelocityOverlay(IEntityManager _entityManager, EntityLookupSystem _lookup, SharedTransformSystem _transform) : Overlay
-    {
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
-
-        protected internal override void Draw(in OverlayDrawArgs args)
-        {
-            const float multiplier = (float)(0.2 / (2 * System.Math.PI));
-
-            var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
-
-            var physicsQuery = _entityManager.GetEntityQuery<PhysicsComponent>();
-            foreach (var uid in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
-            {
-                if(!physicsQuery.TryGetComponent(uid, out var physicsComp))
-                    continue;
-
-                var center = _transform.GetWorldPosition(uid);
-                var angularVelocity = physicsComp.AngularVelocity;
-
-                if (angularVelocity != 0.0f)
-                    worldHandle.DrawCircle(center, angularVelocity * multiplier, angularVelocity > 0 ? Color.Magenta : Color.Blue, false);
+                    worldHandle.DrawLine(center, center + drawLine * stubLength, Color.Red);
+                }
             }
         }
     }
 }
-

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -413,9 +413,8 @@ namespace Robust.Client.Debugging
                     }
 
                     var body = bodyEnt.Comp;
-                    var meta = _entityManager.GetComponent<MetaDataComponent>(bodyEnt);
 
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {bodyEnt.Owner} ({meta.EntityName})");
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {bodyEnt.Owner}");
                     row++;
                     screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
                     row++;

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;
 
@@ -160,7 +158,6 @@ namespace Robust.Client
             }
 
             _serializationManager.Initialize();
-            _loc.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
@@ -387,7 +384,7 @@ namespace Robust.Client
 
             _prof.Initialize();
 
-            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null, hideUserDataDir: true);
+            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)

Robust.Client/GameObjects/ClientEntityManager.Spawn.cs

@@ -1,123 +0,0 @@
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
-using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects;
-
-public sealed partial class ClientEntityManager
-{
-    public override EntityUid PredictedSpawnAttachedTo(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default)
-    {
-        var ent = SpawnAttachedTo(protoName, coordinates, overrides, rotation);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public override EntityUid PredictedSpawn(string? protoName = null, ComponentRegistry? overrides = null, bool doMapInit = true)
-    {
-        var ent = Spawn(protoName, overrides, doMapInit);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override EntityUid PredictedSpawn(string? protoName, MapCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default!)
-    {
-        var ent = Spawn(protoName, coordinates, overrides, rotation);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override EntityUid PredictedSpawnAtPosition(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
-    {
-        var ent = SpawnAtPosition(protoName, coordinates, overrides);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override bool PredictedTrySpawnNextTo(
-        string? protoName,
-        EntityUid target,
-        [NotNullWhen(true)] out EntityUid? uid,
-        TransformComponent? xform = null,
-        ComponentRegistry? overrides = null)
-    {
-        if (!TrySpawnNextTo(protoName, target, out uid, xform, overrides))
-            return false;
-
-        FlagPredicted(uid.Value);
-        return true;
-    }
-
-    public override bool PredictedTrySpawnInContainer(
-        string? protoName,
-        EntityUid containerUid,
-        string containerId,
-        [NotNullWhen(true)] out EntityUid? uid,
-        ContainerManagerComponent? containerComp = null,
-        ComponentRegistry? overrides = null)
-    {
-        if (!TrySpawnInContainer(protoName, containerUid, containerId, out uid, containerComp, overrides))
-            return false;
-
-        FlagPredicted(uid.Value);
-        return true;
-    }
-
-    public override EntityUid PredictedSpawnNextToOrDrop(string? protoName, EntityUid target, TransformComponent? xform = null, ComponentRegistry? overrides = null)
-    {
-        var ent = SpawnNextToOrDrop(protoName, target, xform, overrides);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override EntityUid PredictedSpawnInContainerOrDrop(
-        string? protoName,
-        EntityUid containerUid,
-        string containerId,
-        TransformComponent? xform = null,
-        ContainerManagerComponent? containerComp = null,
-        ComponentRegistry? overrides = null)
-    {
-        var ent = SpawnInContainerOrDrop(protoName, containerUid, containerId, xform, containerComp, overrides);
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override EntityUid PredictedSpawnInContainerOrDrop(
-        string? protoName,
-        EntityUid containerUid,
-        string containerId,
-        out bool inserted,
-        TransformComponent? xform = null,
-        ContainerManagerComponent? containerComp = null,
-        ComponentRegistry? overrides = null)
-    {
-        var ent = SpawnInContainerOrDrop(protoName,
-            containerUid,
-            containerId,
-            out inserted,
-            xform,
-            containerComp,
-            overrides);
-
-        FlagPredicted(ent);
-        return ent;
-    }
-
-    public override void FlagPredicted(Entity<MetaDataComponent?> ent)
-    {
-        if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp))
-            return;
-
-        DebugTools.Assert(IsClientSide(ent.Owner, ent.Comp));
-        EnsureComponent<PredictedSpawnComponent>(ent.Owner);
-
-        // TODO: Need to map call site or something, needs to be consistent between client and server.
-    }
-}

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -117,7 +117,7 @@ namespace Robust.Client.GameObjects
                 base.DirtyField(uid, comp, fieldName, metadata);
         }
 
-        public override void DirtyFields<T>(EntityUid uid, T comp, MetaDataComponent? meta, params string[] fields)
+        public override void DirtyFields<T>(EntityUid uid, T comp, MetaDataComponent? meta, params ReadOnlySpan<string> fields)
         {
             // TODO Prediction
             // does the client actually need to dirty the field?
@@ -291,54 +291,5 @@ namespace Robust.Client.GameObjects
             }
         }
         #endregion
-
-        /// <inheritdoc />
-        public override void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
-        {
-            if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityLifeStage >= EntityLifeStage.Terminating
-                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
-            {
-                return;
-            }
-
-            // So there's 3 scenarios:
-            // 1. Networked entity we just move to nullspace and rely on state handling.
-            // 2. Clientside predicted entity we delete and rely on state handling.
-            // 3. Clientside only entity that actually needs deleting here.
-
-            if (ent.Comp1.NetEntity.IsClientSide())
-            {
-                DeleteEntity(ent, ent.Comp1, ent.Comp2);
-            }
-            else
-            {
-                _xforms.DetachEntity(ent, ent.Comp2);
-            }
-        }
-
-        /// <inheritdoc />
-        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
-        {
-            if (IsQueuedForDeletion(ent.Owner)
-                || !MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
-                || ent.Comp1.EntityLifeStage >= EntityLifeStage.Terminating
-                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
-            {
-                return;
-            }
-
-            if (ent.Comp1.NetEntity.IsClientSide())
-            {
-                // client-side QueueDeleteEntity re-fetches MetadataComp and checks IsClientSide().
-                // base call to skip that.
-                // TODO create override that takes in metadata comp
-                base.QueueDeleteEntity(ent);
-            }
-            else
-            {
-                _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

@@ -10,21 +10,21 @@ using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
-    public sealed class ShowSpriteBBCommand : LocalizedEntityCommands
+    public sealed class ShowSpriteBBCommand : LocalizedCommands
     {
-        [Dependency] private readonly SpriteBoundsSystem _system = default!;
-
         public override string Command => "showspritebb";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _system.Enabled ^= true;
+            EntitySystem.Get<SpriteBoundsSystem>().Enabled ^= true;
         }
     }
 
     public sealed class SpriteBoundsSystem : EntitySystem
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
+        [Dependency] private readonly SpriteTreeSystem _spriteTree = default!;
 
         private SpriteBoundsOverlay? _overlay;
 
@@ -40,7 +40,7 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     DebugTools.AssertNull(_overlay);
-                    _overlay = new SpriteBoundsOverlay(EntityManager);
+                    _overlay = new SpriteBoundsOverlay(_spriteTree, _entityManager);
                     _overlayManager.AddOverlay(_overlay);
                 }
                 else
@@ -55,13 +55,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 IEntityManager _entityManager;
+        private SpriteTreeSystem _renderTree;
+
+        public SpriteBoundsOverlay(SpriteTreeSystem renderTree, IEntityManager entityManager)
+        {
+            _renderTree = renderTree;
+            _entityManager = entityManager;
+        }
 
         protected internal override void Draw(in OverlayDrawArgs args)
         {
@@ -69,11 +74,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 (worldPos, worldRot) = xform.GetWorldPositionRotation();
+                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()
         {
@@ -78,7 +76,7 @@ namespace Robust.Client.GameObjects
             foreach (var key in remie)
             {
                 component.PlayingAnimations.Remove(key);
-                var completedEvent = new AnimationCompletedEvent(uid, component, key, true);
+                var completedEvent = new AnimationCompletedEvent {Uid = uid, Key = key, Finished = true};
                 EntityManager.EventBus.RaiseLocalEvent(uid, completedEvent, true);
             }
 
@@ -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);
         }
 
@@ -189,7 +187,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            var completedEvent = new AnimationCompletedEvent(entity.Owner, entity.Comp, key, false);
+            var completedEvent = new AnimationCompletedEvent {Uid = entity.Owner, Key = key, Finished = false};
             EntityManager.EventBus.RaiseLocalEvent(entity.Owner, completedEvent, true);
         }
 
@@ -204,33 +202,13 @@ namespace Robust.Client.GameObjects
     /// </summary>
     public sealed class AnimationCompletedEvent : EntityEventArgs
     {
-        /// <summary>
-        /// The entity associated with the event.
-        /// </summary>
         public EntityUid Uid { get; init; }
-
-        /// <summary>
-        /// The animation player component associated with the entity this event was raised on.
-        /// </summary>
-        public AnimationPlayerComponent AnimationPlayer { get; init; }
-
-        /// <summary>
-        /// The key associated with the animation that was completed.
-        /// </summary>
         public string Key { get; init; } = string.Empty;
 
         /// <summary>
         /// If true, the animation finished by getting to its natural end.
-        /// If false, it was removed prematurely via <see cref="AnimationPlayerSystem.Stop(EntityUid,AnimationPlayerComponent,string)"/> or similar overloads.
+        /// If false, it was removed prematurely via <see cref="AnimationPlayerSystem.Stop(Robust.Client.GameObjects.AnimationPlayerComponent,string)"/> or similar overloads.
         /// </summary>
         public bool Finished { get; init; }
-
-        public AnimationCompletedEvent(EntityUid uid, AnimationPlayerComponent animationPlayer, string key, bool finished = true)
-        {
-            Uid = uid;
-            AnimationPlayer = animationPlayer;
-            Key = key;
-            Finished = finished;
-        }
     }
 }

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)
@@ -302,7 +303,7 @@ namespace Robust.Client.GameObjects
             while (parent.IsValid() && (!spriteOccluded || !lightOccluded))
             {
                 var parentXform = TransformQuery.GetComponent(parent);
-                if (TryComp<ContainerManagerComponent>(parent, out var manager) && TryGetContainingContainer(parent, child, out var container, manager))
+                if (TryComp<ContainerManagerComponent>(parent, out var manager) && manager.TryGetContainer(child, out var container))
                 {
                     spriteOccluded = spriteOccluded || !container.ShowContents;
                     lightOccluded = lightOccluded || container.OccludesLight;
@@ -343,7 +344,7 @@ namespace Robust.Client.GameObjects
                     var childLightOccluded = lightOccluded;
 
                     // We already know either sprite or light is not occluding so need to check container.
-                    if (TryGetContainingContainer(entity, child, out var container, manager))
+                    if (manager.TryGetContainer(child, out var container))
                     {
                         childSpriteOccluded = childSpriteOccluded || !container.ShowContents;
                         childLightOccluded = childLightOccluded || container.OccludesLight;

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

@@ -2,24 +2,24 @@ using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Console;
+using Robust.Shared.Containers;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Utility;
 using Color = Robust.Shared.Maths.Color;
 
 namespace Robust.Client.GameObjects;
 
-public sealed class DebugEntityLookupCommand : LocalizedEntityCommands
+public sealed class DebugEntityLookupCommand : LocalizedCommands
 {
-    [Dependency] private readonly DebugEntityLookupSystem _system = default!;
-
     public override string Command => "togglelookup";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        _system.Enabled ^= true;
+        EntitySystem.Get<DebugEntityLookupSystem>().Enabled ^= true;
     }
 }
 

Robust.Client/GameObjects/EntitySystems/DebugLightTreeSystem.cs

@@ -26,10 +26,10 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     _lightOverlay = new DebugLightOverlay(
-                        EntityManager.System<EntityLookupSystem>(),
+                        EntitySystem.Get<EntityLookupSystem>(),
                         IoCManager.Resolve<IEyeManager>(),
                         IoCManager.Resolve<IMapManager>(),
-                        EntityManager.System<LightTreeSystem>());
+                        Get<LightTreeSystem>());
 
                     overlayManager.AddOverlay(_lightOverlay);
                 }

Robust.Client/GameObjects/EntitySystems/EyeSystem.cs

@@ -62,7 +62,7 @@ public sealed class EyeSystem : SharedEyeSystem
                 eyeComponent.Target = null;
             }
 
-            eyeComponent.Eye.Position = TransformSystem.GetMapCoordinates(xform);
+            eyeComponent.Eye.Position = xform.MapPosition;
         }
     }
 }

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

@@ -9,6 +9,10 @@ namespace Robust.Client.GameObjects;
 
 public sealed class MapSystem : SharedMapSystem
 {
+    [Dependency] private readonly IOverlayManager _overlayManager = default!;
+    [Dependency] private readonly IResourceCache _resource = default!;
+    [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+
     protected override MapId GetNextMapId()
     {
         // Client-side map entities use negative map Ids to avoid conflict with server-side maps.
@@ -19,4 +23,16 @@ public sealed class MapSystem : SharedMapSystem
         }
         return id;
     }
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        _overlayManager.AddOverlay(new TileEdgeOverlay(EntityManager, _resource, _tileDefinitionManager));
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        _overlayManager.RemoveOverlay<TileEdgeOverlay>();
+    }
 }

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

Robust.Client/GameObjects/EntitySystems/ShowPlayerVelocityDebugSystem.cs

@@ -1,66 +0,0 @@
-using System.Numerics;
-using Robust.Client.Graphics;
-using Robust.Client.Player;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Physics.Components;
-
-namespace Robust.Client.GameObjects;
-
-public sealed class ShowPlayerVelocityDebugSystem : EntitySystem
-{
-    [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IPlayerManager _playerManager = default!;
-    [Dependency] private readonly TransformSystem _transform = default!;
-    [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
-
-    internal bool Enabled
-    {
-        get => _label.Parent != null;
-        set
-        {
-            if (value)
-            {
-                _uiManager.WindowRoot.AddChild(_label);
-            }
-            else
-            {
-                _label.Orphan();
-            }
-        }
-    }
-
-    private Label _label = default!;
-
-    public override void Initialize()
-    {
-        base.Initialize();
-        _label = new Label();
-    }
-
-    public override void FrameUpdate(float frameTime)
-    {
-        base.FrameUpdate(frameTime);
-        if (!Enabled)
-        {
-            _label.Visible = false;
-            return;
-        }
-
-        var player = _playerManager.LocalEntity;
-
-        if (player == null || !TryComp(player.Value, out PhysicsComponent? body))
-        {
-            _label.Visible = false;
-            return;
-        }
-
-        var screenPos = _eyeManager.WorldToScreen(_transform.GetWorldPosition(Transform(player.Value)));
-        LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
-        _label.Visible = true;
-
-        _label.Text = $"Speed: {body.LinearVelocity.Length():0.00}\nLinear: {body.LinearVelocity.X:0.00}, {body.LinearVelocity.Y:0.00}\nAngular: {body.AngularVelocity}";
-    }
-}

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,66 +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;
-
-        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,24 @@ 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 +61,11 @@ namespace Robust.Client.GameObjects
             UpdatesAfter.Add(typeof(SpriteTreeSystem));
 
             SubscribeLocalEvent<PrototypesReloadedEventArgs>(OnPrototypesReloaded);
+            SubscribeLocalEvent<SpriteComponent, SpriteUpdateInertEvent>(QueueUpdateInert);
             SubscribeLocalEvent<SpriteComponent, ComponentInit>(OnInit);
 
             Subs.CVar(_cfg, CVars.RenderSpriteDirectionBias, OnBiasChanged, true);
             _sawmill = _logManager.GetSawmill("sprite");
-            _query = GetEntityQuery<SpriteComponent>();
         }
 
         public bool IsVisible(Layer layer)
@@ -84,6 +84,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/VelocityDebugSystem.cs

@@ -0,0 +1,54 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics.Components;
+
+namespace Robust.Client.GameObjects
+{
+    public sealed class VelocityDebugSystem : EntitySystem
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
+
+        internal bool Enabled { get; set; }
+
+        private Label _label = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _label = new Label();
+            IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+        }
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+            if (!Enabled)
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var player = _playerManager.LocalEntity;
+
+            if (player == null || !EntityManager.TryGetComponent(player.Value, out PhysicsComponent? body))
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var screenPos = _eyeManager.WorldToScreen(_transform.GetWorldPosition(Transform(player.Value)));
+            LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
+            _label.Visible = true;
+
+            _label.Text = $"Speed: {body.LinearVelocity.Length():0.00}\nLinear: {body.LinearVelocity.X:0.00}, {body.LinearVelocity.Y:0.00}\nAngular: {body.AngularVelocity}";
+        }
+    }
+}

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

@@ -13,7 +13,6 @@ using Robust.Client.Physics;
 using Robust.Client.Player;
 using Robust.Client.Timing;
 using Robust.Shared;
-using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
 using Robust.Shared.Console;
 using Robust.Shared.Containers;
@@ -385,6 +384,7 @@ namespace Robust.Client.GameStates
                     _processor.UpdateFullRep(curState);
                 }
 
+                IEnumerable<NetEntity> createdEntities;
                 using (_prof.Group("ApplyGameState"))
                 {
                     if (_timing.LastProcessedTick < targetProcessedTick && nextState != null)
@@ -564,21 +564,6 @@ namespace Robust.Client.GameStates
             var metaQuery = _entities.GetEntityQuery<MetaDataComponent>();
             RemQueue<IComponent> toRemove = new();
 
-            // Handle predicted entity spawns.
-            var predicted = new ValueList<EntityUid>();
-            var predictedQuery = _entities.AllEntityQueryEnumerator<PredictedSpawnComponent>();
-
-            while (predictedQuery.MoveNext(out var uid, out var _))
-            {
-                predicted.Add(uid);
-            }
-
-            // Entity will get re-created as part of the tick.
-            foreach (var ent in predicted)
-            {
-                _entities.DeleteEntity(ent);
-            }
-
             foreach (var entity in system.DirtyEntities)
             {
                 DebugTools.Assert(toRemove.Count == 0);
@@ -631,7 +616,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);
@@ -714,9 +699,8 @@ namespace Robust.Client.GameStates
 
 #if !EXCEPTION_TOLERANCE
                     throw new KeyNotFoundException();
-#else
-                    continue;
 #endif
+                    continue;
                 }
 
                 var compData = _compDataPool.Get();
@@ -977,9 +961,8 @@ namespace Robust.Client.GameStates
                 RequestFullState();
 #if !EXCEPTION_TOLERANCE
                 throw;
-#else
-                return;
 #endif
+                return;
             }
 
             if (data.Created)
@@ -997,9 +980,8 @@ namespace Robust.Client.GameStates
                     RequestFullState();
 #if !EXCEPTION_TOLERANCE
                     throw;
-#else
-                    return;
 #endif
+                    return;
                 }
             }
 
@@ -1306,11 +1288,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 +1308,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/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/ClientEye/EyeManager.cs

@@ -123,8 +123,7 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public ScreenCoordinates CoordinatesToScreen(EntityCoordinates point)
         {
-            var transformSystem = _entityManager.System<SharedTransformSystem>();
-            return MapToScreen(transformSystem.ToMapCoordinates(point));
+            return MapToScreen(point.ToMap(_entityManager, _entityManager.System<SharedTransformSystem>()));
         }
 
         public ScreenCoordinates MapToScreen(MapCoordinates point)

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

@@ -21,7 +21,7 @@ namespace Robust.Client.Graphics.Clyde
         private const string UniModelMatrix = "modelMatrix";
         private const string UniTexturePixelSize = "TEXTURE_PIXEL_SIZE";
         private const string UniMainTexture = "TEXTURE";
-        private const string UniLightTexture = "lightMap"; // TODO CLYDE consistent shader variable naming
+        private const string UniLightTexture = "lightMap";
         private const string UniProjViewMatrices = "projectionViewMatrices";
         private const string UniUniformConstants = "uniformConstants";
 

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

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Numerics;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
@@ -24,30 +22,10 @@ namespace Robust.Client.Graphics.Clyde
         /// </summary>
         private HashSet<Type> _erroredGridOverlays = new();
 
-        private Vertex2D[]? _chunkMeshBuilderVertexBuffer;
-        private ushort[]? _chunkMeshBuilderIndexBuffer;
-
         private int _verticesPerChunk(MapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * 4;
         private int _indicesPerChunk(MapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * GetQuadBatchIndexCount();
 
         private List<Entity<MapGridComponent>> _grids = new();
-        private bool _drawTileEdges;
-
-        private void RenderTileEdgesChanges(bool value)
-        {
-            _drawTileEdges = value;
-            if (!value)
-                return;
-
-            // Dirty all Edges
-            foreach (var gridData in _mapChunkData.Values)
-            {
-                foreach (var chunk in gridData.Values)
-                {
-                    chunk.EdgeDirty = true;
-                }
-            }
-        }
 
         private void _drawGrids(Viewport viewport, Box2 worldAABB, Box2Rotated worldBounds, IEye eye)
         {
@@ -85,79 +63,29 @@ namespace Robust.Client.Graphics.Clyde
                     gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
                 }
 
-                gridProgram.SetUniform(UniIModelMatrix, _transformSystem.GetWorldMatrix(mapGrid));
+                var transform = _entityManager.GetComponent<TransformComponent>(mapGrid);
+                gridProgram.SetUniform(UniIModelMatrix, _transformSystem.GetWorldMatrix(transform));
                 var enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
 
-                // Handle base texture updates.
                 while (enumerator.MoveNext(out var chunk))
                 {
                     DebugTools.Assert(chunk.FilledTiles > 0);
-                    var datum = EnsureChunkInitialized(data, chunk, mapGrid);
+                    if (!data.TryGetValue(chunk.Indices, out MapChunkData? datum))
+                        data[chunk.Indices] = datum = _initChunkBuffers(mapGrid, chunk);
 
-                    if (!datum.Dirty)
-                        continue;
+                    if (datum.Dirty)
+                        _updateChunkMesh(mapGrid, chunk, datum);
 
-                    _updateChunkMesh(mapGrid, chunk, datum);
-
-                    if (!_drawTileEdges)
-                        continue;
-
-                    // Dirty edge tiles for next step.
-                    datum.EdgeDirty = true;
-
-                    for (var x = -1; x <= 1; x++)
-                    {
-                        for (var y = -1; y <= 1; y++)
-                        {
-                            var neighbor = chunk.Indices + new Vector2i(x, y);
-
-                            if (!mapGrid.Comp.Chunks.TryGetValue(neighbor, out var neighborChunk))
-                                continue;
-
-                            var neighborDatum = EnsureChunkInitialized(data, neighborChunk, mapGrid);
-                            neighborDatum.EdgeDirty = true;
-                        }
-                    }
-                }
-
-                // Handle edge sprites.
-                if (_drawTileEdges)
-                {
-                    enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
-                    while (enumerator.MoveNext(out var chunk))
-                    {
-                        var datum = data[chunk.Indices];
-                        if (datum.EdgeDirty)
-                            _updateChunkEdges(mapGrid, chunk, datum);
-                    }
-                }
-
-                enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
-
-                // Draw chunks
-                while (enumerator.MoveNext(out var chunk))
-                {
-                    var datum = data[chunk.Indices];
                     DebugTools.Assert(datum.TileCount > 0);
-                    if (datum.TileCount > 0)
-                    {
-                        BindVertexArray(datum.VAO);
-                        CheckGlError();
+                    if (datum.TileCount == 0)
+                        continue;
 
-                        _debugStats.LastGLDrawCalls += 1;
-                        GL.DrawElements(GetQuadGLPrimitiveType(), datum.TileCount * GetQuadBatchIndexCount(), DrawElementsType.UnsignedShort, 0);
-                        CheckGlError();
-                    }
+                    BindVertexArray(datum.VAO);
+                    CheckGlError();
 
-                    if (_drawTileEdges && datum.EdgeCount > 0)
-                    {
-                        BindVertexArray(datum.EdgeVAO);
-                        CheckGlError();
-
-                        _debugStats.LastGLDrawCalls += 1;
-                        GL.DrawElements(GetQuadGLPrimitiveType(), datum.EdgeCount * GetQuadBatchIndexCount(), DrawElementsType.UnsignedShort, 0);
-                        CheckGlError();
-                    }
+                    _debugStats.LastGLDrawCalls += 1;
+                    GL.DrawElements(GetQuadGLPrimitiveType(), datum.TileCount * GetQuadBatchIndexCount(), DrawElementsType.UnsignedShort, 0);
+                    CheckGlError();
                 }
 
                 requiresFlush = false;
@@ -189,17 +117,6 @@ namespace Robust.Client.Graphics.Clyde
             CullEmptyChunks();
         }
 
-        private MapChunkData EnsureChunkInitialized(Dictionary<Vector2i, MapChunkData> data, MapChunk chunk, Entity<MapGridComponent> mapGrid)
-        {
-            if (!data.TryGetValue(chunk.Indices, out var datum))
-            {
-                data[chunk.Indices] = datum = new MapChunkData();
-                _initChunkBuffers(mapGrid, chunk, datum);
-            }
-
-            return datum;
-        }
-
         private void CullEmptyChunks()
         {
             foreach (var (grid, chunks) in _mapChunkData)
@@ -221,147 +138,66 @@ namespace Robust.Client.Graphics.Clyde
 
         private void _updateChunkMesh(Entity<MapGridComponent> grid, MapChunk chunk, MapChunkData datum)
         {
-            Span<ushort> indexBuffer = EnsureSize(ref _chunkMeshBuilderIndexBuffer, _indicesPerChunk(chunk));
-            Span<Vertex2D> vertexBuffer = EnsureSize(ref _chunkMeshBuilderVertexBuffer, _verticesPerChunk(chunk));
+            Span<ushort> indexBuffer = stackalloc ushort[_indicesPerChunk(chunk)];
+            Span<Vertex2D> vertexBuffer = stackalloc Vertex2D[_verticesPerChunk(chunk)];
 
             var i = 0;
-            var chunkSize = grid.Comp.ChunkSize;
-            var chunkOriginScaled = chunk.Indices * chunkSize;
-
-            for (ushort x = 0; x < chunkSize; x++)
+            var cSz = grid.Comp.ChunkSize;
+            var cScaled = chunk.Indices * cSz;
+            for (ushort x = 0; x < cSz; x++)
             {
-                for (ushort y = 0; y < chunkSize; y++)
+                for (ushort y = 0; y < cSz; y++)
                 {
-                    var gridX = x + chunkOriginScaled.X;
-                    var gridY = y + chunkOriginScaled.Y;
                     var tile = chunk.GetTile(x, y);
+                    if (tile.IsEmpty)
+                        continue;
 
-                    // Tile render
-                    if (x != chunkSize && y != chunkSize)
+                    var regionMaybe = _tileDefinitionManager.TileAtlasRegion(tile);
+
+                    Box2 region;
+                    if (regionMaybe == null || regionMaybe.Length <= tile.Variant)
                     {
-                        // ReSharper disable once IntVariableOverflowInUncheckedContext
-                        if (tile.IsEmpty)
-                            continue;
-
-                        var regionMaybe = _tileDefinitionManager.TileAtlasRegion(tile);
-
-                        Box2 region;
-                        if (regionMaybe == null || regionMaybe.Length <= tile.Variant)
-                        {
-                            region = _tileDefinitionManager.ErrorTileRegion;
-                        }
-                        else
-                        {
-                            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);
-                        i += 1;
+                        region = _tileDefinitionManager.ErrorTileRegion;
                     }
+                    else
+                    {
+                        region = regionMaybe[tile.Variant];
+                    }
+
+                    var gx = x + cScaled.X;
+                    var gy = y + cScaled.Y;
+
+                    var vIdx = i * 4;
+                    vertexBuffer[vIdx + 0] = new Vertex2D(gx, gy, region.Left, region.Bottom, Color.White);
+                    vertexBuffer[vIdx + 1] = new Vertex2D(gx + 1, gy, region.Right, region.Bottom, Color.White);
+                    vertexBuffer[vIdx + 2] = new Vertex2D(gx + 1, gy + 1, region.Right, region.Top, Color.White);
+                    vertexBuffer[vIdx + 3] = new Vertex2D(gx, gy + 1, region.Left, region.Top, Color.White);
+                    var nIdx = i * GetQuadBatchIndexCount();
+                    var tIdx = (ushort)(i * 4);
+                    QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);
+                    i += 1;
                 }
             }
 
-            var indexSlice = indexBuffer[..(i * GetQuadBatchIndexCount())];
-            var vertSlice = vertexBuffer[..(i * 4)];
-
             GL.BindVertexArray(datum.VAO);
             CheckGlError();
             datum.EBO.Use();
             datum.VBO.Use();
-            datum.EBO.Reallocate(indexSlice);
-            datum.VBO.Reallocate(vertSlice);
-
-            datum.TileCount = i;
+            datum.EBO.Reallocate(indexBuffer[..(i * GetQuadBatchIndexCount())]);
+            datum.VBO.Reallocate(vertexBuffer[..(i * 4)]);
             datum.Dirty = false;
+            datum.TileCount = i;
         }
 
-        private void _updateChunkEdges(Entity<MapGridComponent> grid, MapChunk chunk, MapChunkData datum)
+        private unsafe MapChunkData _initChunkBuffers(Entity<MapGridComponent> grid, MapChunk chunk)
         {
-            // Need a buffer that can potentially store all neighbor tiles
-            Span<ushort> indexBuffer = EnsureSize(ref _chunkMeshBuilderIndexBuffer, _indicesPerChunk(chunk) * 8);
-            Span<Vertex2D> vertexBuffer = EnsureSize(ref _chunkMeshBuilderVertexBuffer, _verticesPerChunk(chunk) * 8);
-
-            var i = 0;
-            var chunkSize = grid.Comp.ChunkSize;
-            var chunkOriginScaled = chunk.Indices * chunkSize;
-            var maps = _entityManager.System<SharedMapSystem>();
-
-            for (ushort x = 0; x < chunkSize; x++)
-            {
-                for (ushort y = 0; y < chunkSize; y++)
-                {
-                    var gridX = x + chunkOriginScaled.X;
-                    var gridY = y + chunkOriginScaled.Y;
-                    var tile = chunk.GetTile(x, y);
-                    if (!_tileDefinitionManager.TryGetDefinition(tile.TypeId, out var tileDef))
-                        continue;
-
-                    // Edge render
-                    for (var nx = -1; nx <= 1; nx++)
-                    {
-                        for (var ny = -1; ny <= 1; ny++)
-                        {
-                            if (nx == 0 && ny == 0)
-                                continue;
-
-                            var neighborIndices = new Vector2i(gridX + nx, gridY + ny);
-                            if (!maps.TryGetTile(grid.Comp, neighborIndices, out var neighborTile))
-                                continue;
-
-                            if (!_tileDefinitionManager.TryGetDefinition(neighborTile.TypeId, out var neighborDef))
-                                continue;
-
-                            // If it's the same tile then no edge to be drawn.
-                            if (tile.TypeId == neighborTile.TypeId || neighborDef.EdgeSprites.Count == 0)
-                                continue;
-
-                            // If neighbor is a lower or same priority then us then don't draw on our tile.
-                            if (neighborDef.EdgeSpritePriority <= tileDef.EdgeSpritePriority)
-                                continue;
-
-                            var direction = new Vector2i(nx, ny).AsDirection().GetOpposite();
-                            var regionMaybe = _tileDefinitionManager.TileAtlasRegion(neighborTile.TypeId, direction);
-
-                            if (regionMaybe == null)
-                                continue;
-
-                            var region = regionMaybe[0];
-                            WriteTileToBuffers(i, gridX, gridY, vertexBuffer, indexBuffer, region, 0);
-                            i += 1;
-                        }
-                    }
-                }
-            }
-
-            // We don't save the edge buffers back because we might need to re-use it if a neighbor chunk updates.
-            var indexSlice = indexBuffer[..(i * GetQuadBatchIndexCount())];
-            var vertSlice = vertexBuffer[..(i * 4)];
-
-            GL.BindVertexArray(datum.EdgeVAO);
-            CheckGlError();
-            datum.EdgeEBO.Use();
-            datum.EdgeVBO.Use();
-            datum.EdgeEBO.Reallocate(indexSlice);
-            datum.EdgeVBO.Reallocate(vertSlice);
-
-            datum.EdgeCount = i;
-            datum.EdgeDirty = false;
-        }
-
-        private unsafe void _initChunkBuffers(Entity<MapGridComponent> grid, MapChunk chunk, MapChunkData datum)
-        {
-            var vboSize = _verticesPerChunk(chunk) * sizeof(Vertex2D);
-            var eboSize = _indicesPerChunk(chunk) * sizeof(ushort);
-
-            // Base VAO
             var vao = GenVertexArray();
             BindVertexArray(vao);
             CheckGlError();
 
+            var vboSize = _verticesPerChunk(chunk) * sizeof(Vertex2D);
+            var eboSize = _indicesPerChunk(chunk) * sizeof(ushort);
+
             var vbo = new GLBuffer(this, BufferTarget.ArrayBuffer, BufferUsageHint.DynamicDraw,
                 vboSize, $"Grid {grid.Owner} chunk {chunk.Indices} VBO");
             var ebo = new GLBuffer(this, BufferTarget.ElementArrayBuffer, BufferUsageHint.DynamicDraw,
@@ -376,30 +212,12 @@ namespace Robust.Client.Graphics.Clyde
             vbo.Use();
             ebo.Use();
 
-            datum.EBO = ebo;
-            datum.VBO = vbo;
-            datum.VAO = vao;
+            var datum = new MapChunkData(vao, vbo, ebo)
+            {
+                Dirty = true
+            };
 
-            // EdgeVAO
-            var edgeVao = GenVertexArray();
-            BindVertexArray(edgeVao);
-            CheckGlError();
-
-            var edgeVbo = new GLBuffer(this, BufferTarget.ArrayBuffer, BufferUsageHint.DynamicDraw,
-                vboSize * 8, $"Grid {grid.Owner} chunk {chunk.Indices} EdgeVBO");
-            var edgeEbo = new GLBuffer(this, BufferTarget.ElementArrayBuffer, BufferUsageHint.DynamicDraw,
-                eboSize * 8, $"Grid {grid.Owner} chunk {chunk.Indices} EdgeEBO");
-
-            ObjectLabelMaybe(ObjectLabelIdentifier.VertexArray, vao, $"Grid {grid.Owner} chunk {chunk.Indices} EdgeVAO");
-            SetupVAOLayout();
-            CheckGlError();
-
-            edgeVbo.Use();
-            edgeEbo.Use();
-
-            datum.EdgeEBO = edgeEbo;
-            datum.EdgeVBO = edgeVbo;
-            datum.EdgeVAO = edgeVao;
+            return datum;
         }
 
         private void DeleteChunk(MapChunkData data)
@@ -413,11 +231,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)
@@ -439,93 +254,19 @@ namespace Robust.Client.Graphics.Clyde
             _mapChunkData.Remove(gridId);
         }
 
-        private static T[] EnsureSize<T>(ref T[]? field, int size)
-        {
-            if (field == null || field.Length < size)
-                field = new T[size];
-
-            return field;
-        }
-
-        private void WriteTileToBuffers(
-            int i,
-            int gridX,
-            int gridY,
-            Span<Vertex2D> vertexBuffer,
-            Span<ushort> indexBuffer,
-            Box2 region,
-            int rotationMirroring)
-        {
-            var rLeftBottom = (region.Left, region.Bottom);
-            var rRightBottom = (region.Right, region.Bottom);
-            var rRightTop = (region.Right, region.Top);
-            var rLeftTop = (region.Left, region.Top);
-
-            // The vertices must be changed if there's any rotation or mirroring to the tile
-            if (rotationMirroring != 0)
-            {
-                // Rotate the tile
-                for (int r = 0; r < rotationMirroring % 4; r++)
-                {
-                    (rLeftBottom, rRightBottom, rRightTop, rLeftTop) =
-                        (rLeftTop, rLeftBottom, rRightBottom, rRightTop);
-                }
-
-                // Mirror on the x-axis
-                if (rotationMirroring >= 4)
-                {
-                    if (rotationMirroring % 2 == 0)
-                    {
-                        rLeftBottom = (rLeftBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
-                            rLeftBottom.Item2);
-                        rRightBottom = (rRightBottom.Item1.Equals(region.Left) ? region.Right : region.Left,
-                            rRightBottom.Item2);
-                        rRightTop = (rRightTop.Item1.Equals(region.Left) ? region.Right : region.Left,
-                            rRightTop.Item2);
-                        rLeftTop = (rLeftTop.Item1.Equals(region.Left) ? region.Right : region.Left,
-                            rLeftTop.Item2);
-                    }
-                    else
-                    {
-                        rLeftBottom = (rLeftBottom.Item1,
-                            rLeftBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
-                        rRightBottom = (rRightBottom.Item1,
-                            rRightBottom.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
-                        rRightTop = (rRightTop.Item1,
-                            rRightTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
-                        rLeftTop = (rLeftTop.Item1,
-                            rLeftTop.Item2.Equals(region.Bottom) ? region.Top : region.Bottom);
-                    }
-                }
-            }
-
-            var vIdx = i * 4;
-            vertexBuffer[vIdx + 0] = new Vertex2D(gridX, gridY, rLeftBottom.Left, rLeftBottom.Bottom, Color.White);
-            vertexBuffer[vIdx + 1] = new Vertex2D(gridX + 1, gridY, rRightBottom.Right, rRightBottom.Bottom, Color.White);
-            vertexBuffer[vIdx + 2] = new Vertex2D(gridX + 1, gridY + 1, rRightTop.Right, rRightTop.Top, Color.White);
-            vertexBuffer[vIdx + 3] = new Vertex2D(gridX, gridY + 1, rLeftTop.Left, rLeftTop.Top, Color.White);
-            var nIdx = i * GetQuadBatchIndexCount();
-            var tIdx = (ushort)(i * 4);
-            QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);
-        }
-
         private sealed class MapChunkData
         {
-            public bool EdgeDirty = true;
-            public bool Dirty = true;
-
-            public uint VAO;
-            public GLBuffer VBO = default!;
-            public GLBuffer EBO = default!;
+            public bool Dirty;
+            public readonly uint VAO;
+            public readonly GLBuffer VBO;
+            public readonly GLBuffer EBO;
             public int TileCount;
 
-            public uint EdgeVAO;
-            public GLBuffer EdgeVBO = default!;
-            public GLBuffer EdgeEBO = default!;
-            public int EdgeCount;
-
-            public MapChunkData()
+            public MapChunkData(uint vao, GLBuffer vbo, GLBuffer ebo)
             {
+                VAO = vao;
+                VBO = vbo;
+                EBO = ebo;
             }
         }
     }

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

@@ -123,13 +123,9 @@ namespace Robust.Client.Graphics.Clyde
 
         private void RenderSingleWorldOverlay(Overlay overlay, Viewport vp, OverlaySpace space, in Box2 worldBox, in Box2Rotated worldBounds)
         {
-            // Check that entity manager has started.
-            // This is required for us to be able to use MapSystem.
-            DebugTools.Assert(_entityManager.Started, "Entity manager should be started/initialized before rendering world-space overlays");
-
             DebugTools.Assert(space != OverlaySpace.ScreenSpaceBelowWorld && space != OverlaySpace.ScreenSpace);
 
-            var mapId = vp.Eye?.Position.MapId ?? MapId.Nullspace;
+            var mapId = vp.Eye!.Position.MapId;
             var args = new OverlayDrawArgs(space, null, vp, _renderHandle, new UIBox2i((0, 0), vp.Size), _mapSystem.GetMapOrInvalid(mapId), mapId, worldBox, worldBounds);
 
             if (!overlay.BeforeDraw(args))
@@ -156,7 +152,6 @@ namespace Robust.Client.Graphics.Clyde
 
         private void RenderOverlays(Viewport vp, OverlaySpace space, in Box2 worldBox, in Box2Rotated worldBounds)
         {
-            DebugTools.Assert(space != OverlaySpace.ScreenSpaceBelowWorld && space != OverlaySpace.ScreenSpace);
             using (DebugGroup($"Overlays: {space}"))
             {
                 foreach (var overlay in GetOverlaysForSpace(space))
@@ -181,18 +176,9 @@ namespace Robust.Client.Graphics.Clyde
 
             var worldBounds = CalcWorldBounds(vp);
             var worldAABB = worldBounds.CalcBoundingBox();
-            var mapId = vp.Eye?.Position.MapId ?? MapId.Nullspace;
-            var mapUid = EntityUid.Invalid;
+            var mapId = vp.Eye!.Position.MapId;
 
-            // Screen space overlays may be getting used before entity manager & entity systems have been initialized.
-            // This might mean that _mapSystem is currently null.
-            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
-            if (_entityManager.Started && _mapSystem != null)
-                mapUid = _mapSystem.GetMapOrInvalid(mapId);
-
-            DebugTools.Assert(_mapSystem != null || !_entityManager.Started);
-
-            var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, mapUid, mapId, worldAABB, worldBounds);
+            var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, _mapSystem.GetMapOrInvalid(mapId), mapId, worldAABB, worldBounds);
 
             foreach (var overlay in list)
             {
@@ -318,7 +304,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);
@@ -369,7 +355,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
 {
@@ -97,11 +98,9 @@ namespace Robust.Client.Graphics.Clyde
         private LightCapacityComparer _lightCap = new();
         private ShadowCapacityComparer _shadowCap = new ShadowCapacityComparer();
 
-        private float _maxLightRadius;
-
         private unsafe void InitLighting()
         {
-            _cfg.OnValueChanged(CVars.MaxLightRadius, val => { _maxLightRadius = val;}, true);
+
 
             // Other...
             LoadLightingShaders();
@@ -618,9 +617,8 @@ namespace Robust.Client.Graphics.Clyde
             // Use worldbounds for this one as we only care if the light intersects our actual bounds
             var xforms = _entityManager.GetEntityQuery<TransformComponent>();
             var state = (this, count: 0, shadowCastingCount: 0, xforms, worldAABB);
-            var lightAabb = worldAABB.Enlarged(_maxLightRadius);
 
-            foreach (var (uid, comp) in _lightTreeSystem.GetIntersectingTrees(map, lightAabb))
+            foreach (var (uid, comp) in _lightTreeSystem.GetIntersectingTrees(map, worldAABB))
             {
                 var bounds = _transformSystem.GetInvWorldMatrix(uid, xforms).TransformBox(worldBounds);
                 comp.Tree.QueryAabb(ref state, LightQuery, bounds);

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

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

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

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -121,7 +121,6 @@ namespace Robust.Client.Graphics.Clyde
             _cfg.OnValueChanged(CVars.LightSoftShadows, SoftShadowsChanged, true);
             _cfg.OnValueChanged(CVars.MaxLightCount, MaxLightsChanged, true);
             _cfg.OnValueChanged(CVars.MaxOccluderCount, MaxOccludersChanged, true);
-            _cfg.OnValueChanged(CVars.RenderTileEdges, RenderTileEdgesChanges, true);
             // I can't be bothered to tear down and set these threads up in a cvar change handler.
 
             // Windows and Linux can be trusted to not explode with threaded windowing,

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

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

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

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

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

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