Move do_afters to an overlay (#10463)

Content.Client/DoAfter/DoAfterOverlay.cs

@@ -0,0 +1,141 @@
+using Content.Client.Resources;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared;
+using Robust.Shared.Configuration;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Client.DoAfter;
+
+public sealed class DoAfterOverlay : Overlay
+{
+    [Dependency] private readonly IConfigurationManager _configManager = default!;
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    private readonly SharedTransformSystem _transform;
+
+    private Texture _barTexture;
+    private ShaderInstance _shader;
+
+    public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowFOV;
+
+    public DoAfterOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _transform = _entManager.EntitySysManager.GetEntitySystem<SharedTransformSystem>();
+        _barTexture = IoCManager.Resolve<IResourceCache>()
+            .GetTexture("/Textures/Interface/Misc/progress_bar.rsi/icon.png");
+
+        _shader = IoCManager.Resolve<IPrototypeManager>().Index<ShaderPrototype>("unshaded").Instance();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        var handle = args.WorldHandle;
+        var rotation = args.Viewport.Eye?.Rotation ?? Angle.Zero;
+        var spriteQuery = _entManager.GetEntityQuery<SpriteComponent>();
+        var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+
+        var scale = _configManager.GetCVar(CVars.DisplayUIScale);
+        var scaleMatrix = Matrix3.CreateScale(new Vector2(scale, scale));
+        var rotationMatrix = Matrix3.CreateRotation(-rotation);
+        handle.UseShader(_shader);
+
+        // TODO: Need active DoAfter component (or alternatively just make DoAfter itself active)
+        foreach (var comp in _entManager.EntityQuery<DoAfterComponent>(true))
+        {
+            if (comp.DoAfters.Count == 0 ||
+                !xformQuery.TryGetComponent(comp.Owner, out var xform) ||
+                xform.MapID != args.MapId)
+            {
+                continue;
+            }
+
+            var worldPosition = _transform.GetWorldPosition(xform);
+
+            if (!args.WorldAABB.Contains(worldPosition))
+                continue;
+
+            var index = 0;
+            var worldMatrix = Matrix3.CreateTranslation(worldPosition);
+
+            foreach (var (_, doAfter) in comp.DoAfters)
+            {
+                var elapsed = doAfter.Accumulator;
+                var displayRatio = MathF.Min(1.0f,
+                    elapsed / doAfter.Delay);
+
+                Matrix3.Multiply(scaleMatrix, worldMatrix, out var scaledWorld);
+                Matrix3.Multiply(rotationMatrix, scaledWorld, out var matty);
+
+                handle.SetTransform(matty);
+                var offset = _barTexture.Height / scale * index;
+
+                // Use the sprite itself if we know its bounds. This means short or tall sprites don't get overlapped
+                // by the bar.
+                float yOffset;
+                if (spriteQuery.TryGetComponent(comp.Owner, out var sprite))
+                {
+                    yOffset = sprite.Bounds.Height / 2f + 0.05f;
+                }
+                else
+                {
+                    yOffset = 0.5f;
+                }
+
+                // Position above the entity (we've already applied the matrix transform to the entity itself)
+                // Offset by the texture size for every do_after we have.
+                var position = new Vector2(-_barTexture.Width / 2f / EyeManager.PixelsPerMeter,
+                    yOffset / scale + offset / EyeManager.PixelsPerMeter * scale);
+
+                // Draw the underlying bar texture
+                handle.DrawTexture(_barTexture, position);
+
+                // Draw the bar itself
+                var cancelled = doAfter.Cancelled;
+                Color color;
+                const float flashTime = 0.125f;
+
+                // if we're cancelled then flick red / off.
+                if (cancelled)
+                {
+                    var flash = Math.Floor(doAfter.CancelledAccumulator / flashTime) % 2 == 0;
+                    color = new Color(1f, 0f, 0f, flash ? 1f : 0f);
+                }
+                else
+                {
+                    color = GetProgressColor(displayRatio);
+                }
+
+                // Hardcoded width of the progress bar because it doesn't match the texture.
+                const float startX = 2f;
+                const float endX = 22f;
+
+                var xProgress = (endX - startX) * displayRatio + startX;
+
+                var box = new Box2(new Vector2(startX, 3f) / EyeManager.PixelsPerMeter, new Vector2(xProgress, 4f) / EyeManager.PixelsPerMeter);
+                box = box.Translated(position);
+                handle.DrawRect(box, color);
+
+                index++;
+            }
+        }
+
+        handle.UseShader(null);
+        handle.SetTransform(Matrix3.Identity);
+    }
+
+    public static Color GetProgressColor(float progress)
+    {
+        if (progress >= 1.0f)
+        {
+            return new Color(0f, 1f, 0f);
+        }
+        // lerp
+        var hue = (5f / 18f) * progress;
+        return Color.FromHsv((hue, 1f, 0.75f, 1f));
+    }
+}