FFV HML Equipment rework. WIP-DO NOT MERGE

Content.Client/Eye/DarkenedVisionSystem.cs

@@ -0,0 +1,59 @@
+using Robust.Client.Graphics;
+using Robust.Shared.Player;
+using Robust.Client.Player;
+using Content.Client.Overlays;
+using Content.Shared.Eye;
+
+namespace Content.Client.Eye;
+
+public sealed class DarkenedVisionSystem : SharedDarkenedVisionSystem
+{
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly IOverlayManager _overlayMan = default!;
+
+
+    private DarkenedVisionOverlay _overlay = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<DarkenedVisionComponent, ComponentStartup>(OnStartup);
+        SubscribeLocalEvent<DarkenedVisionComponent, ComponentShutdown>(OnShutdown);
+
+        SubscribeLocalEvent<DarkenedVisionComponent, LocalPlayerAttachedEvent>(OnAttached);
+        SubscribeLocalEvent<DarkenedVisionComponent, LocalPlayerDetachedEvent>(OnDetached);
+
+        _overlay = new();
+    }
+
+    private void OnAttached(Entity<DarkenedVisionComponent> ent, ref LocalPlayerAttachedEvent args)
+    {
+        _overlayMan.AddOverlay(_overlay);
+        _overlay.DarkenedVision = ent.Comp;
+    }
+
+    private void OnDetached(Entity<DarkenedVisionComponent> ent, ref LocalPlayerDetachedEvent args)
+    {
+        _overlayMan.RemoveOverlay(_overlay);
+        _overlay.DarkenedVision = null;
+    }
+
+    private void OnStartup(Entity<DarkenedVisionComponent> ent, ref ComponentStartup args)
+    {
+        if (_player.LocalEntity == ent.Owner)
+        {
+            _overlayMan.AddOverlay(_overlay);
+            _overlay.DarkenedVision = ent.Comp;
+        }
+    }
+
+    private void OnShutdown(Entity<DarkenedVisionComponent> ent, ref ComponentShutdown args)
+    {
+        if (_player.LocalEntity == ent.Owner)
+        {
+            _overlayMan.RemoveOverlay(_overlay);
+            _overlay.DarkenedVision = null;
+        }
+    }
+}

Content.Client/Movement/Systems/EyeCursorOffsetSystem.cs

@@ -2,6 +2,7 @@
 using Content.Client.Movement.Components;
 using Content.Client.Viewport;
 using Content.Shared.Camera;
+using Content.Shared.Item.ItemToggle.Components;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Shared.Map;
@@ -22,6 +23,7 @@ public override void Initialize()
         base.Initialize();
 
         SubscribeLocalEvent<EyeCursorOffsetComponent, GetEyeOffsetEvent>(OnGetEyeOffsetEvent);
+        // SubscribeLocalEvent<EyeCursorOffsetComponent, ItemToggledEvent>(OnToggled);
     }
 
     private void OnGetEyeOffsetEvent(EntityUid uid, EyeCursorOffsetComponent component, ref GetEyeOffsetEvent args)
@@ -33,6 +35,15 @@ private void OnGetEyeOffsetEvent(EntityUid uid, EyeCursorOffsetComponent compone
         args.Offset += offset.Value;
     }
 
+    // private void OnToggled(EntityUid uid, EyeCursorOffsetComponent component, ref ItemToggledEvent args)
+    // {
+    //     var offset = OffsetAfterMouse(uid, component);
+    //     if (offset == null)
+    //         return;
+
+    //     args.Offset += offset.Value;
+    // }
+
     public Vector2? OffsetAfterMouse(EntityUid uid, EyeCursorOffsetComponent? component)
     {
         // We need the main viewport where the game content is displayed, as certain UI layouts (e.g. Separated HUD) can make it a different size to the game window.

Content.Client/Overlays/DarkenedVisionOverlay.cs

@@ -0,0 +1,72 @@
+using Content.Client.Movement.Systems;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+using Content.Shared.Eye.Blinding;
+using Content.Shared.Eye.Blinding.Components;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Content.Shared.Eye;
+
+namespace Content.Client.Overlays;
+
+public sealed class DarkenedVisionOverlay : Overlay
+{
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+
+    public override bool RequestScreenTexture => true;
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+    private readonly ShaderInstance _circleMaskShader;
+
+    public DarkenedVisionComponent? DarkenedVision;
+
+
+    public DarkenedVisionOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _circleMaskShader = _prototypeManager.Index<ShaderPrototype>("CircleMask").InstanceUnique();
+    }
+    protected override bool BeforeDraw(in OverlayDrawArgs args)
+    {
+        if (!_entityManager.TryGetComponent(_playerManager.LocalSession?.AttachedEntity, out EyeComponent? eyeComp))
+            return false;
+
+        if (args.Viewport.Eye != eyeComp.Eye)
+            return false;
+
+        var playerEntity = _playerManager.LocalSession?.AttachedEntity;
+
+        if (playerEntity == null)
+            return false;
+
+        return DarkenedVision != null && DarkenedVision.Strength < DarkenedVision.BlindTreshold && DarkenedVision.Strength > 0;
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture == null)
+            return;
+
+        var playerEntity = _playerManager.LocalSession?.AttachedEntity;
+
+        if (playerEntity == null)
+            return;
+
+        if (_entityManager.TryGetComponent<EyeComponent>(playerEntity, out var content))
+        {
+            _circleMaskShader?.SetParameter("Zoom", content.Zoom.X);
+        }
+
+        _circleMaskShader?.SetParameter("CirclePow", 1f);
+        _circleMaskShader?.SetParameter("CircleRadius", (10 - DarkenedVision!.Strength) * 32f);
+
+        var worldHandle = args.WorldHandle;
+        var viewport = args.WorldBounds;
+        worldHandle.UseShader(_circleMaskShader);
+        worldHandle.DrawRect(viewport, Color.White);
+        worldHandle.UseShader(null);
+    }
+}

Content.Client/Overlays/EquipmentHudSystem.cs

@@ -33,8 +33,8 @@ public override void Initialize()
 
         SubscribeLocalEvent<T, RefreshEquipmentHudEvent<T>>(OnRefreshComponentHud);
         SubscribeLocalEvent<T, InventoryRelayedEvent<RefreshEquipmentHudEvent<T>>>(OnRefreshEquipmentHud);
-/*
-        SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRoundRestart); */
+
+        SubscribeLocalEvent<RoundRestartCleanupEvent>(OnRoundRestart);
     }
 
     private void Update(RefreshEquipmentHudEvent<T> ev)
@@ -87,14 +87,17 @@ private void OnCompUnequip(Entity<T> ent, ref GotUnequippedEvent args)
         RefreshOverlay();
     }
 
-/*     private void OnRoundRestart(RoundRestartCleanupEvent args)
+    private void OnRoundRestart(RoundRestartCleanupEvent args)
     {
         Deactivate();
-    } */
+    }
 
     protected virtual void OnRefreshEquipmentHud(Entity<T> ent, ref InventoryRelayedEvent<RefreshEquipmentHudEvent<T>> args)
     {
-        OnRefreshComponentHud(ent, ref args.Args);
+        // Goob edit start
+        args.Args.Active = true;
+        args.Args.Components.Add(ent);
+        // Goob edit end
     }
 
     protected virtual void OnRefreshComponentHud(Entity<T> ent, ref RefreshEquipmentHudEvent<T> args)

Content.Client/_White/Overlays/BaseSwitchableOverlay.cs

@@ -0,0 +1,48 @@
+using System.Numerics;
+using Content.Shared._White.Overlays;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+
+namespace Content.Client._White.Overlays;
+
+public sealed class BaseSwitchableOverlay<TComp> : Overlay where TComp : SwitchableVisionOverlayComponent
+{
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
+
+    public override bool RequestScreenTexture => true;
+    public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+    private readonly ShaderInstance _shader;
+
+    public TComp? Comp = null;
+
+    public bool IsActive = true;
+
+    public BaseSwitchableOverlay()
+    {
+        IoCManager.InjectDependencies(this);
+        _shader = _prototype.Index<ShaderPrototype>("NVHud").InstanceUnique();
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (ScreenTexture is null || Comp is null || !IsActive)
+            return;
+
+        _shader.SetParameter("SCREEN_TEXTURE", ScreenTexture);
+        _shader.SetParameter("tint", Comp.Tint);
+        _shader.SetParameter("luminance_threshold", Comp.Strength);
+        _shader.SetParameter("noise_amount", Comp.Noise);
+
+        var worldHandle = args.WorldHandle;
+
+        var accumulator = Math.Clamp(Comp.PulseAccumulator, 0f, Comp.PulseTime);
+        var alpha = Comp.PulseTime <= 0f ? 1f : float.Lerp(1f, 0f, accumulator / Comp.PulseTime);
+
+        worldHandle.SetTransform(Matrix3x2.Identity);
+        worldHandle.UseShader(_shader);
+        worldHandle.DrawRect(args.WorldBounds, Comp.Color.WithAlpha(alpha));
+        worldHandle.UseShader(null);
+    }
+}