LightManager.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using System.Collections.Generic;
using System.Linq;
using System;
using Barotrauma.Items.Components;
using Barotrauma.Extensions;
using System.Threading;
 
namespace Barotrauma.Lights
{
    class LightManager
    {
        const int MaxLightVolumeRecalculationsPerFrame = 5;
 
        const float ObstructLightsBehindCharactersZoomThreshold = 0.5f;
 
        private Thread rayCastThread;
        private Queue<RayCastTask> pendingRayCasts = new Queue<RayCastTask>();
 
        public static Entity ViewTarget { get; set; }
 
        private float currLightMapScale;
 
        public Color AmbientLight;
 
        public RenderTarget2D LightMap
        {
            get;
            private set;
        }
        public RenderTarget2D LimbLightMap
        {
            get;
            private set;
        }
        public RenderTarget2D LosTexture
        {
            get;
            private set;
        }
        public RenderTarget2D HighlightMap
        {
            get;
            private set;
        }
 
        private readonly Texture2D highlightRaster;
 
        private BasicEffect lightEffect;
 
        public Effect LosEffect { get; private set; }
        public Effect SolidColorEffect { get; private set; }
 
        private readonly List<LightSource> lights;
 
        public bool DebugLos;
 
        public bool LosEnabled = true;
        public float LosAlpha = 1f;
        public LosMode LosMode = LosMode.Transparent;
 
        public bool LightingEnabled = true;
 
        public float ObstructVisionAmount;
 
        private readonly Texture2D visionCircle;
 
        private readonly Texture2D gapGlowTexture;
 
        private Vector2 losOffset;
 
        private int recalculationCount;
 
        private float time;
 
        public IEnumerable<LightSource> Lights
        {
            get { return lights; }
        }
 
        public LightManager(GraphicsDevice graphics)
        {
            lights = new List<LightSource>(100);
 
            AmbientLight = new Color(20, 20, 20, 255);
 
            rayCastThread = new Thread(UpdateRayCasts)
            {
                Name = "LightManager Raycast thread",
                IsBackground = true //this should kill the thread if the game crashes
            };
            rayCastThread.Start();
 
            visionCircle = Sprite.LoadTexture("Content/Lights/visioncircle.png");
            highlightRaster = Sprite.LoadTexture("Content/UI/HighlightRaster.png");
            gapGlowTexture = Sprite.LoadTexture("Content/Lights/pointlight_rays.png");
 
            GameMain.Instance.ResolutionChanged += () =>
            {
                CreateRenderTargets(graphics);
            };
 
            CrossThread.RequestExecutionOnMainThread(() =>
            {
                CreateRenderTargets(graphics);
 
                LosEffect = EffectLoader.Load("Effects/losshader");
                SolidColorEffect = EffectLoader.Load("Effects/solidcolor");
 
                lightEffect ??= new BasicEffect(GameMain.Instance.GraphicsDevice)
                    {
                        VertexColorEnabled = true,
                        TextureEnabled = true,
                        Texture = LightSource.LightTexture
                    };
            });
        }
 
        private void CreateRenderTargets(GraphicsDevice graphics)
        {
            var pp = graphics.PresentationParameters;
 
            currLightMapScale = GameSettings.CurrentConfig.Graphics.LightMapScale;
 
            LightMap?.Dispose();
            LightMap = CreateRenderTarget();
 
            LimbLightMap?.Dispose();
            LimbLightMap = CreateRenderTarget();
 
            HighlightMap?.Dispose();
            HighlightMap = CreateRenderTarget();
 
            RenderTarget2D CreateRenderTarget()
            {
               return new RenderTarget2D(graphics,
                       (int)(GameMain.GraphicsWidth * GameSettings.CurrentConfig.Graphics.LightMapScale), (int)(GameMain.GraphicsHeight * GameSettings.CurrentConfig.Graphics.LightMapScale), false,
                       pp.BackBufferFormat, pp.DepthStencilFormat, pp.MultiSampleCount,
                       RenderTargetUsage.DiscardContents);
            }
 
            LosTexture?.Dispose();
            LosTexture = new RenderTarget2D(graphics,
                (int)(GameMain.GraphicsWidth * GameSettings.CurrentConfig.Graphics.LightMapScale),
                (int)(GameMain.GraphicsHeight * GameSettings.CurrentConfig.Graphics.LightMapScale), false, SurfaceFormat.Color, DepthFormat.None);
        }
 
        public void AddLight(LightSource light)
        {
            if (!lights.Contains(light)) { lights.Add(light); }
        }
 
        public void RemoveLight(LightSource light)
        {
            lights.Remove(light);
        }
 
        public void OnMapLoaded()
        {
            foreach (LightSource light in lights)
            {
                light.HullsUpToDate.Clear();
                light.NeedsRecalculation = true;
            }
        }
 
        private readonly List<LightSource> activeLights = new List<LightSource>(capacity: 100);
        private readonly List<LightSource> activeLightsWithLightVolume = new List<LightSource>(capacity: 100);
 
        public static int ActiveLightCount { get; private set; }
 
        public void Update(float deltaTime)
        {
            //wrap around if the timer gets very large, otherwise we'd start running into floating point accuracy issues
            time = (time + deltaTime) % 100000.0f;
            foreach (LightSource light in activeLights)
            {
                if (!light.Enabled) { continue; }
                light.Update(time);
            }
        }
 
        private sealed class RayCastTask
        {
            public LightSource LightSource;
            public Vector2 DrawPos;
            public float Rotation;
 
            public RayCastTask(LightSource lightSource, Vector2 drawPos, float rotation)
            {
                LightSource = lightSource;
                DrawPos = drawPos;
                Rotation = rotation;
            }
 
            public void Calculate()
            {
                LightSource.RayCastTask(DrawPos, Rotation);
            }
        }
 
        private static readonly object mutex = new object();
 
        public void AddRayCastTask(LightSource lightSource, Vector2 drawPos, float rotation)
        {
            lock (mutex)
            {
                if (pendingRayCasts.Any(p => p.LightSource == lightSource)) { return; }
                pendingRayCasts.Enqueue(new RayCastTask(lightSource, drawPos, rotation));
            }
        }
 
        private void UpdateRayCasts()
        {
            while (true)
            {
                lock (mutex)
                {
                    while (pendingRayCasts.Count > 0)
                    {
                        pendingRayCasts.Dequeue().Calculate();
                    }
                }
                Thread.Sleep(10);
            }
        }
 
        public void DebugDrawVertices(SpriteBatch spriteBatch)
        {
            foreach (LightSource light in lights)
            {
                if (!light.Enabled) { continue; }
                light.DebugDrawVertices(spriteBatch);
            }
        }
 
        public void RenderLightMap(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, RenderTarget2D backgroundObstructor = null)
        {
            if (!LightingEnabled) { return; }
 
            if (Math.Abs(currLightMapScale - GameSettings.CurrentConfig.Graphics.LightMapScale) > 0.01f)
            {
                //lightmap scale has changed -> recreate render targets
                CreateRenderTargets(graphics);
            }
 
            Matrix spriteBatchTransform = cam.Transform * Matrix.CreateScale(new Vector3(GameSettings.CurrentConfig.Graphics.LightMapScale, GameSettings.CurrentConfig.Graphics.LightMapScale, 1.0f));
            Matrix transform = cam.ShaderTransform
                * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
 
            bool highlightsVisible = UpdateHighlights(graphics, spriteBatch, spriteBatchTransform, cam);
 
            Rectangle viewRect = cam.WorldView;
            viewRect.Y -= cam.WorldView.Height;
            //check which lights need to be drawn
            recalculationCount = 0;
            activeLights.Clear();
            foreach (LightSource light in lights)
            {
                if (!light.Enabled) { continue; }
                if ((light.Color.A < 1 || light.Range < 1.0f) && !light.LightSourceParams.OverrideLightSpriteAlpha.HasValue) { continue; }
 
                if (light.ParentBody != null)
                {
                    light.ParentBody.UpdateDrawPosition();
 
                    Vector2 pos =  light.ParentBody.DrawPosition;
                    if (light.ParentSub != null) { pos -= light.ParentSub.DrawPosition; }
                    light.Position = pos;
                }
 
                //above the top boundary of the level (in an inactive respawn shuttle?)
                if (Level.Loaded != null && light.WorldPosition.Y > Level.Loaded.Size.Y) { continue; }
 
                float range = light.LightSourceParams.TextureRange;
                if (light.LightSprite != null)
                {
                    float spriteRange = Math.Max(
                        light.LightSprite.size.X * light.SpriteScale.X * (0.5f + Math.Abs(light.LightSprite.RelativeOrigin.X - 0.5f)),
                        light.LightSprite.size.Y * light.SpriteScale.Y * (0.5f + Math.Abs(light.LightSprite.RelativeOrigin.Y - 0.5f)));
 
                    float targetSize = Math.Max(light.LightTextureTargetSize.X, light.LightTextureTargetSize.Y);
                    range = Math.Max(Math.Max(spriteRange, targetSize), range);
                }
                if (!MathUtils.CircleIntersectsRectangle(light.WorldPosition, range, viewRect)) { continue; }
 
                light.Priority = lightPriority(range, light);
 
                int i = 0;
                while (i < activeLights.Count && light.Priority < activeLights[i].Priority)
                {
                    i++;
                }
                activeLights.Insert(i, light);
            }
            ActiveLightCount = activeLights.Count;
 
            float lightPriority(float range, LightSource light)
            {
                return
                    range *
                    ((Character.Controlled?.Submarine != null && light.ParentSub == Character.Controlled?.Submarine) ? 2.0f : 1.0f) *
                    (light.CastShadows ? 10.0f : 1.0f) *
                    (light.LightSourceParams.OverrideLightSpriteAlpha ?? (light.Color.A / 255.0f)) *
                    light.PriorityMultiplier;
            }
 
            //find the lights with an active light volume
            activeLightsWithLightVolume.Clear();
            foreach (var activeLight in activeLights)
            {
                if (activeLight.Range < 1.0f || activeLight.Color.A < 1 || activeLight.CurrentBrightness <= 0.0f) { continue; }
                activeLightsWithLightVolume.Add(activeLight);
            }
 
            //remove some lights with a light volume if there's too many of them
            if (activeLightsWithLightVolume.Count > GameSettings.CurrentConfig.Graphics.VisibleLightLimit && Screen.Selected is { IsEditor: false })
            {
                for (int i = GameSettings.CurrentConfig.Graphics.VisibleLightLimit; i < activeLightsWithLightVolume.Count; i++)
                {
                    activeLights.Remove(activeLightsWithLightVolume[i]);
                }
            }
            activeLights.Sort((l1, l2) => l1.LastRecalculationTime.CompareTo(l2.LastRecalculationTime));
 
            //draw light sprites attached to characters
            //render into a separate rendertarget using alpha blending (instead of on top of everything else with alpha blending)
            //to prevent the lights from showing through other characters or other light sprites attached to the same character
            //---------------------------------------------------------------------------------------------------
            graphics.SetRenderTarget(LimbLightMap);
            graphics.Clear(Color.Black);
            graphics.BlendState = BlendState.NonPremultiplied;
            spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.NonPremultiplied, transformMatrix: spriteBatchTransform);
            foreach (LightSource light in activeLights)
            {
                if (light.IsBackground || light.CurrentBrightness <= 0.0f) { continue; }
                //draw limb lights at this point, because they were skipped over previously to prevent them from being obstructed
                if (light.ParentBody?.UserData is Limb limb && !limb.Hide) { light.DrawSprite(spriteBatch, cam); }
            }
            spriteBatch.End();
 
            //draw background lights
            //---------------------------------------------------------------------------------------------------
            graphics.SetRenderTarget(LightMap);
            graphics.Clear(AmbientLight);
            graphics.BlendState = BlendState.Additive;
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, transformMatrix: spriteBatchTransform);
            Level.Loaded?.BackgroundCreatureManager?.DrawLights(spriteBatch, cam);
            foreach (LightSource light in activeLights)
            {
                if (!light.IsBackground || light.CurrentBrightness <= 0.0f) { continue; }
                light.DrawLightVolume(spriteBatch, lightEffect, transform, recalculationCount < MaxLightVolumeRecalculationsPerFrame, ref recalculationCount);
                light.DrawSprite(spriteBatch, cam);
            }
            GameMain.ParticleManager.Draw(spriteBatch, true, null, Particles.ParticleBlendState.Additive);
            spriteBatch.End();
 
            //draw a black rectangle on hulls to hide background lights behind subs
            //---------------------------------------------------------------------------------------------------
 
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Opaque, transformMatrix: spriteBatchTransform);
            Dictionary<Hull, Rectangle> visibleHulls = GetVisibleHulls(cam);
            foreach (KeyValuePair<Hull, Rectangle> hull in visibleHulls)
            {
                GUI.DrawRectangle(spriteBatch,
                    new Vector2(hull.Value.X, -hull.Value.Y),
                    new Vector2(hull.Value.Width, hull.Value.Height),
                    hull.Key.AmbientLight == Color.TransparentBlack ? Color.Black : hull.Key.AmbientLight.Multiply(hull.Key.AmbientLight.A / 255.0f), true);
            }
            spriteBatch.End();
 
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, transformMatrix: spriteBatchTransform);
            Vector3 glowColorHSV = ToolBox.RGBToHSV(AmbientLight);
            glowColorHSV.Z = Math.Max(glowColorHSV.Z, 0.4f);
            Color glowColor = ToolBoxCore.HSVToRGB(glowColorHSV.X, glowColorHSV.Y, glowColorHSV.Z);
            Vector2 glowSpriteSize = new Vector2(gapGlowTexture.Width, gapGlowTexture.Height);
            foreach (var gap in Gap.GapList)
            {
                if (gap.IsRoomToRoom || gap.Open <= 0.0f || gap.ConnectedWall == null) { continue; }
 
                float a = MathHelper.Lerp(0.5f, 1.0f,
                    PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.05f, gap.GlowEffectT));
 
                float scale = MathHelper.Lerp(0.5f, 2.0f,
                    PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.01f, gap.GlowEffectT));
 
                float rot = PerlinNoise.GetPerlin((float)Timing.TotalTime * 0.001f, gap.GlowEffectT) * MathHelper.TwoPi;
 
                Vector2 spriteScale = new Vector2(gap.Rect.Width, gap.Rect.Height) / glowSpriteSize;
                Vector2 drawPos = new Vector2(gap.DrawPosition.X, -gap.DrawPosition.Y);
 
                spriteBatch.Draw(gapGlowTexture,
                    drawPos,
                    null,
                    glowColor * a,
                    rot,
                    glowSpriteSize / 2,
                    scale: Math.Max(spriteScale.X, spriteScale.Y) * scale,
                    SpriteEffects.None,
                    layerDepth: 0);
            }
            spriteBatch.End();
 
            GameMain.GameScreen.DamageEffect.CurrentTechnique = GameMain.GameScreen.DamageEffect.Techniques["StencilShaderSolidColor"];
            GameMain.GameScreen.DamageEffect.Parameters["solidColor"].SetValue(Color.Black.ToVector4());
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, SamplerState.LinearWrap, transformMatrix: spriteBatchTransform, effect: GameMain.GameScreen.DamageEffect);
            Submarine.DrawDamageable(spriteBatch, GameMain.GameScreen.DamageEffect);
            spriteBatch.End();
 
            graphics.BlendState = BlendState.Additive;
 
            //draw the focused item and character to highlight them,
            //and light sprites (done before drawing the actual light volumes so we can make characters obstruct the highlights and sprites)
            //---------------------------------------------------------------------------------------------------
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, transformMatrix: spriteBatchTransform);
            foreach (LightSource light in activeLights)
            {
                //don't draw limb lights at this point, they need to be drawn after lights have been obstructed by characters
                if (light.IsBackground || light.ParentBody?.UserData is Limb || light.CurrentBrightness <= 0.0f) { continue; }
                light.DrawSprite(spriteBatch, cam);
            }
            spriteBatch.End();
 
            if (highlightsVisible)
            {
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive);
                spriteBatch.Draw(HighlightMap, Vector2.Zero, Color.White);
                spriteBatch.End();
            }
 
            //draw characters to obstruct the highlighted items/characters and light sprites
            //---------------------------------------------------------------------------------------------------
            if (cam.Zoom > ObstructLightsBehindCharactersZoomThreshold)
            {
                SolidColorEffect.CurrentTechnique = SolidColorEffect.Techniques["SolidVertexColor"];
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, effect: SolidColorEffect, transformMatrix: spriteBatchTransform);
                DrawCharacters(spriteBatch, cam, drawDeformSprites: false);
                spriteBatch.End();
 
                DeformableSprite.Effect.CurrentTechnique = DeformableSprite.Effect.Techniques["DeformShaderSolidVertexColor"];
                DeformableSprite.Effect.CurrentTechnique.Passes[0].Apply();
                spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, transformMatrix: spriteBatchTransform);
                DrawCharacters(spriteBatch, cam, drawDeformSprites: true);
                spriteBatch.End();
            }
 
            static void DrawCharacters(SpriteBatch spriteBatch, Camera cam, bool drawDeformSprites)
            {
                foreach (Character character in Character.CharacterList)
                {
                    if (character.CurrentHull == null || !character.Enabled || !character.IsVisible || character.InvisibleTimer > 0.0f) { continue; }
                    if (Character.Controlled?.FocusedCharacter == character) { continue; }
                    Color lightColor = character.CurrentHull.AmbientLight == Color.TransparentBlack ?
                        Color.Black :
                        character.CurrentHull.AmbientLight.Multiply(character.CurrentHull.AmbientLight.A / 255.0f).Opaque();
                    foreach (Limb limb in character.AnimController.Limbs)
                    {
                        if (drawDeformSprites == (limb.DeformSprite == null)) { continue; }
                        limb.Draw(spriteBatch, cam, lightColor);
                    }
                    foreach (var heldItem in character.HeldItems)
                    {
                        heldItem.Draw(spriteBatch, editing: false, overrideColor: Color.Black);
                    }
                }
            }
 
            DeformableSprite.Effect.CurrentTechnique = DeformableSprite.Effect.Techniques["DeformShader"];
            graphics.BlendState = BlendState.Additive;
 
            //draw the actual light volumes, additive particles, hull ambient lights and the halo around the player
            //---------------------------------------------------------------------------------------------------
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, transformMatrix: spriteBatchTransform);
 
            spriteBatch.Draw(LimbLightMap, new Rectangle(cam.WorldView.X, -cam.WorldView.Y, cam.WorldView.Width, cam.WorldView.Height), Color.White);
 
            foreach (ElectricalDischarger discharger in ElectricalDischarger.List)
            {
                discharger.DrawElectricity(spriteBatch);
            }
 
            foreach (LightSource light in activeLights)
            {
                if (light.IsBackground || light.CurrentBrightness <= 0.0f) { continue; }
                light.DrawLightVolume(spriteBatch, lightEffect, transform, recalculationCount < MaxLightVolumeRecalculationsPerFrame, ref recalculationCount);
            }
 
            if (ConnectionPanel.ShouldDebugDrawWiring)
            {
                foreach (MapEntity e in (Submarine.VisibleEntities ?? MapEntity.MapEntityList))
                {
                    if (e is Item item && !item.IsHidden && item.GetComponent<Wire>() is Wire wire)
                    {
                        wire.DebugDraw(spriteBatch, alpha: 0.4f);
                    }
                }
            }
 
            lightEffect.World = transform;
 
            GameMain.ParticleManager.Draw(spriteBatch, false, null, Particles.ParticleBlendState.Additive);
 
            if (Character.Controlled != null)
            {
                DrawHalo(Character.Controlled);
            }
            else
            {
                foreach (Character character in Character.CharacterList)
                {
                    if (character.Submarine == null || character.IsDead || !character.IsHuman) { continue; }
                    DrawHalo(character);
                }
            }
 
            void DrawHalo(Character character)
            {
                if (character == null || character.Removed) { return; }
                Vector2 haloDrawPos = character.DrawPosition;
                haloDrawPos.Y = -haloDrawPos.Y;
 
                //ambient light decreases the brightness of the halo (no need for a bright halo if the ambient light is bright enough)
                float ambientBrightness = (AmbientLight.R + AmbientLight.B + AmbientLight.G) / 255.0f / 3.0f;
                Color haloColor = Color.White.Multiply(0.3f - ambientBrightness);
                if (haloColor.A > 0)
                {
                    float scale = 512.0f / LightSource.LightTexture.Width;
                    spriteBatch.Draw(
                        LightSource.LightTexture, haloDrawPos, null, haloColor, 0.0f,
                        new Vector2(LightSource.LightTexture.Width, LightSource.LightTexture.Height) / 2, scale, SpriteEffects.None, 0.0f);
                }
            }
 
            spriteBatch.End();
 
            //draw the actual light volumes, additive particles, hull ambient lights and the halo around the player
            //---------------------------------------------------------------------------------------------------
 
            graphics.SetRenderTarget(null);
            graphics.BlendState = BlendState.NonPremultiplied;
        }
 
        private readonly List<Entity> highlightedEntities = new List<Entity>();
 
        private bool UpdateHighlights(GraphicsDevice graphics, SpriteBatch spriteBatch, Matrix spriteBatchTransform, Camera cam)
        {
            if (GUI.DisableItemHighlights) { return false; }
 
            highlightedEntities.Clear();
            if (Character.Controlled != null && (!Character.Controlled.IsKeyDown(InputType.Aim) || Character.Controlled.HeldItems.Any(it => it.GetComponent<Sprayer>() == null)))
            {
                if (Character.Controlled.FocusedItem != null)
                {
                    highlightedEntities.Add(Character.Controlled.FocusedItem);
                }
                if (Character.Controlled.FocusedCharacter != null)
                {
                    highlightedEntities.Add(Character.Controlled.FocusedCharacter);
                }
                foreach (MapEntity me in MapEntity.HighlightedEntities)
                {
                    if (me is Item item && item != Character.Controlled.FocusedItem)
                    {
                        highlightedEntities.Add(item);
                    }
                }
            }
            if (highlightedEntities.Count == 0) { return false; }
 
            //draw characters in light blue first
            graphics.SetRenderTarget(HighlightMap);
            SolidColorEffect.CurrentTechnique = SolidColorEffect.Techniques["SolidColor"];
            SolidColorEffect.Parameters["color"].SetValue(Color.LightBlue.ToVector4());
            SolidColorEffect.CurrentTechnique.Passes[0].Apply();
            DeformableSprite.Effect.CurrentTechnique = DeformableSprite.Effect.Techniques["DeformShaderSolidColor"];
            DeformableSprite.Effect.Parameters["solidColor"].SetValue(Color.LightBlue.ToVector4());
            DeformableSprite.Effect.CurrentTechnique.Passes[0].Apply();
            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.Additive, samplerState: SamplerState.LinearWrap, effect: SolidColorEffect, transformMatrix: spriteBatchTransform);
            foreach (Entity highlighted in highlightedEntities)
            {
                if (highlighted is Item item)
                {
                    if (item.IconStyle != null && (item != Character.Controlled.FocusedItem || Character.Controlled.FocusedItem == null))
                    {
                        //wait until next pass
                    }
                    else
                    {
                        item.Draw(spriteBatch, false, true);
                    }
                }
                else if (highlighted is Character character)
                {
                    character.Draw(spriteBatch, cam);
                }
            }
            spriteBatch.End();
 
            //draw items with iconstyles in the style's color
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.Additive, samplerState: SamplerState.LinearWrap, effect: SolidColorEffect, transformMatrix: spriteBatchTransform);
            foreach (Entity highlighted in highlightedEntities)
            {
                if (highlighted is Item item)
                {
                    if (item.IconStyle != null && (item != Character.Controlled.FocusedItem || Character.Controlled.FocusedItem == null))
                    {
                        SolidColorEffect.Parameters["color"].SetValue(item.IconStyle.Color.ToVector4());
                        SolidColorEffect.CurrentTechnique.Passes[0].Apply();
                        item.Draw(spriteBatch, false, true);
                    }
                }
            }
            spriteBatch.End();
 
            //draw characters in black with a bit of blur, leaving the white edges visible
            float phase = (float)(Math.Sin(Timing.TotalTime * 3.0f) + 1.0f) / 2.0f; //phase oscillates between 0 and 1
            Vector4 overlayColor = Color.Black.ToVector4() * MathHelper.Lerp(0.5f, 0.9f, phase);
            SolidColorEffect.Parameters["color"].SetValue(overlayColor);
            SolidColorEffect.CurrentTechnique = SolidColorEffect.Techniques["SolidColorBlur"];
            SolidColorEffect.CurrentTechnique.Passes[0].Apply();
            DeformableSprite.Effect.Parameters["solidColor"].SetValue(overlayColor);
            DeformableSprite.Effect.CurrentTechnique.Passes[0].Apply();
            spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, samplerState: SamplerState.LinearWrap, effect: SolidColorEffect, transformMatrix: spriteBatchTransform);
            foreach (Entity highlighted in highlightedEntities)
            {
                if (highlighted is Item item)
                {
                    SolidColorEffect.Parameters["blurDistance"].SetValue(0.02f);
                    item.Draw(spriteBatch, false, true);
                }
                else if (highlighted is Character character)
                {
                    SolidColorEffect.Parameters["blurDistance"].SetValue(0.05f);
                    character.Draw(spriteBatch, cam);
                }
            }
            spriteBatch.End();
 
            //raster pattern on top of everything
            spriteBatch.Begin(blendState: BlendState.NonPremultiplied, samplerState: SamplerState.LinearWrap);
            spriteBatch.Draw(highlightRaster,
                new Rectangle(0, 0, HighlightMap.Width, HighlightMap.Height),
                new Rectangle(0, 0, (int)(HighlightMap.Width / currLightMapScale * 0.5f), (int)(HighlightMap.Height / currLightMapScale * 0.5f)),
                Color.White * 0.5f);
            spriteBatch.End();
 
            DeformableSprite.Effect.CurrentTechnique = DeformableSprite.Effect.Techniques["DeformShader"];
 
            return true;
        }
 
        private readonly Dictionary<Hull, Rectangle> visibleHulls = new Dictionary<Hull, Rectangle>();
        private Dictionary<Hull, Rectangle> GetVisibleHulls(Camera cam)
        {
            visibleHulls.Clear();
            foreach (Hull hull in Hull.HullList)
            {
                if (hull.IsHidden) { continue; }
                var drawRect =
                    hull.Submarine == null ?
                    hull.Rect :
                    new Rectangle((int)(hull.Submarine.DrawPosition.X + hull.Rect.X), (int)(hull.Submarine.DrawPosition.Y + hull.Rect.Y), hull.Rect.Width, hull.Rect.Height);
 
                if (drawRect.Right < cam.WorldView.X || drawRect.X > cam.WorldView.Right ||
                    drawRect.Y - drawRect.Height > cam.WorldView.Y || drawRect.Y < cam.WorldView.Y - cam.WorldView.Height)
                {
                    continue;
                }
                visibleHulls.Add(hull, drawRect);
            }
            return visibleHulls;
        }
 
        public void UpdateObstructVision(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam, Vector2 lookAtPosition)
        {
            if ((!LosEnabled || LosMode == LosMode.None) && ObstructVisionAmount <= 0.0f) { return; }
            if (ViewTarget == null) return;
 
            graphics.SetRenderTarget(LosTexture);
 
            if (ObstructVisionAmount > 0.0f)
            {
                graphics.Clear(Color.Black);
                Vector2 diff = lookAtPosition - ViewTarget.WorldPosition;
                diff.Y = -diff.Y;
                if (diff.LengthSquared() > 20.0f * 20.0f) { losOffset = diff; }
                float rotation = MathUtils.VectorToAngle(losOffset);
 
                //the visible area stretches to the maximum when the cursor is this far from the character
                const float MaxOffset = 256.0f;
                //the magic numbers here are just based on experimentation
                float MinHorizontalScale = MathHelper.Lerp(3.5f, 1.5f, ObstructVisionAmount);
                float MaxHorizontalScale = MinHorizontalScale * 1.25f;
                float VerticalScale = MathHelper.Lerp(4.0f, 1.25f, ObstructVisionAmount);
 
                //Starting point and scale-based modifier that moves the point of origin closer to the edge of the texture if the player moves their mouse further away, or vice versa.
                float relativeOriginStartPosition = 0.1f; //Increasing this value moves the origin further behind the character
                float originStartPosition = visionCircle.Width * relativeOriginStartPosition * MinHorizontalScale;
                float relativeOriginLookAtPosModifier = -0.055f; //Increase this value increases how much the vision changes by moving the mouse
                float originLookAtPosModifier = visionCircle.Width * relativeOriginLookAtPosModifier;
 
                Vector2 scale = new Vector2(
                    MathHelper.Clamp(losOffset.Length() / MaxOffset, MinHorizontalScale, MaxHorizontalScale), VerticalScale);
 
                spriteBatch.Begin(SpriteSortMode.Deferred, transformMatrix: cam.Transform * Matrix.CreateScale(new Vector3(GameSettings.CurrentConfig.Graphics.LightMapScale, GameSettings.CurrentConfig.Graphics.LightMapScale, 1.0f)));
                spriteBatch.Draw(visionCircle, new Vector2(ViewTarget.WorldPosition.X, -ViewTarget.WorldPosition.Y), null, Color.White, rotation,
                    new Vector2(originStartPosition + (scale.X * originLookAtPosModifier), visionCircle.Height / 2), scale, SpriteEffects.None, 0.0f);
                spriteBatch.End();
            }
            else
            {
                graphics.Clear(Color.White);
            }
 
 
            //--------------------------------------
 
            if (LosEnabled && LosMode != LosMode.None && ViewTarget != null)
            {
                Vector2 pos = ViewTarget.DrawPosition;
                bool centeredOnHead = false;
                if (ViewTarget is Character character &&
                    character.AnimController?.GetLimb(LimbType.Head) is Limb head &&
                    !head.IsSevered && !head.Removed)
                {
                    pos = head.body.DrawPosition;
                    centeredOnHead = true;
                }
 
                Rectangle camView = new Rectangle(cam.WorldView.X, cam.WorldView.Y - cam.WorldView.Height, cam.WorldView.Width, cam.WorldView.Height);
                Matrix shadowTransform = cam.ShaderTransform
                    * Matrix.CreateOrthographic(GameMain.GraphicsWidth, GameMain.GraphicsHeight, -1, 1) * 0.5f;
 
                var convexHulls = ConvexHull.GetHullsInRange(ViewTarget.Position, cam.WorldView.Width * 0.75f, ViewTarget.Submarine);
 
                //make sure the head isn't peeking through any LOS segments, and if it is,
                //center the LOS on the character's collider instead
                if (centeredOnHead)
                {
                    foreach (var ch in convexHulls)
                    {
                        if (!ch.Enabled) { continue; }
                        Vector2 currentViewPos = pos;
                        Vector2 defaultViewPos = ViewTarget.DrawPosition;
                        if (ch.ParentEntity?.Submarine != null)
                        {
                            defaultViewPos -= ch.ParentEntity.Submarine.DrawPosition;
                            currentViewPos -= ch.ParentEntity.Submarine.DrawPosition;
                        }
                        //check if a line from the character's collider to the head intersects with the los segment (= head poking through it)
                        if (ch.LosIntersects(defaultViewPos, currentViewPos))
                        {
                            pos = ViewTarget.DrawPosition;
                        }
                    }
                }
 
                if (convexHulls != null)
                {
                    List<VertexPositionColor> shadowVerts = new List<VertexPositionColor>();
                    List<VertexPositionTexture> penumbraVerts = new List<VertexPositionTexture>();
                    foreach (ConvexHull convexHull in convexHulls)
                    {
                        if (!convexHull.Enabled || !convexHull.Intersects(camView)) { continue; }
 
                        Vector2 relativeViewPos = pos;
                        if (convexHull.ParentEntity?.Submarine != null) 
                        { 
                            relativeViewPos -= convexHull.ParentEntity.Submarine.DrawPosition;
                        }
 
                        convexHull.CalculateLosVertices(relativeViewPos);
 
                        for (int i = 0; i < convexHull.ShadowVertexCount; i++)
                        {
                            shadowVerts.Add(convexHull.ShadowVertices[i]);
                        }
 
                        for (int i = 0; i < convexHull.PenumbraVertexCount; i++)
                        {
                            penumbraVerts.Add(convexHull.PenumbraVertices[i]);
                        }
                    }
 
                    if (shadowVerts.Count > 0)
                    {
                        ConvexHull.shadowEffect.World = shadowTransform;
                        ConvexHull.shadowEffect.CurrentTechnique.Passes[0].Apply();
                        graphics.DrawUserPrimitives(PrimitiveType.TriangleList, shadowVerts.ToArray(), 0, shadowVerts.Count / 3, VertexPositionColor.VertexDeclaration);
 
                        if (penumbraVerts.Count > 0)
                        {
                            ConvexHull.penumbraEffect.World = shadowTransform;
                            ConvexHull.penumbraEffect.CurrentTechnique.Passes[0].Apply();
                            graphics.DrawUserPrimitives(PrimitiveType.TriangleList, penumbraVerts.ToArray(), 0, penumbraVerts.Count / 3, VertexPositionTexture.VertexDeclaration);
                        }
                    }
                }
            }
            graphics.SetRenderTarget(null);
        }
 
        public void DebugDrawLos(SpriteBatch spriteBatch, Camera cam)
        {
            Vector2 pos = ViewTarget?.Position ?? cam.Position;
            spriteBatch.Begin(SpriteSortMode.Deferred, transformMatrix: cam.Transform);
            var convexHulls = ConvexHull.GetHullsInRange(pos, cam.WorldView.Width * 0.75f, ViewTarget?.Submarine);
            Rectangle camView = new Rectangle(cam.WorldView.X, cam.WorldView.Y - cam.WorldView.Height, cam.WorldView.Width, cam.WorldView.Height);
            foreach (ConvexHull convexHull in convexHulls)
            {
                if (!convexHull.Enabled || !convexHull.Intersects(camView)) { continue; }
                if (convexHull.ParentEntity is Structure { CastShadow: false }) { continue; }
                convexHull.DebugDraw(spriteBatch);
            }
            spriteBatch.End();
        }
 
        public void ClearLights()
        {
            activeLights.Clear();
            activeLightsWithLightVolume.Clear();
            lights.Clear();
        }
    }
 
 
    class CustomBlendStates
    {
        static CustomBlendStates()
        {
            Multiplicative = new BlendState
            {
                ColorSourceBlend = Blend.DestinationColor,
                ColorDestinationBlend = Blend.SourceColor,
                ColorBlendFunction = BlendFunction.Add
            };
        }
        public static BlendState Multiplicative { get; private set; }
    }
 
}