Lights, colored items (only used for wires atm)

Subsurface/Map/Lights/Light.cs

@@ -0,0 +1,61 @@
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Subsurface.Lights
+{
+    class LightSource
+    {
+
+        private static Texture2D lightTexture;
+
+        private Color color;
+
+        private float range;
+
+        private Texture2D texture;
+
+        public Vector2 Position;
+
+        public Color Color
+        {
+            get { return color; }
+            set { color = value; }
+        }
+
+        public float Range
+        {
+            get { return range; }
+            set
+            {
+                range = MathHelper.Clamp(value, 0.0f, 2048.0f);
+            }
+        }
+
+        public LightSource(Vector2 position, float range, Color color)
+        {
+            Position = position;
+            this.range = range;
+            this.color = color;
+
+            if (lightTexture == null)
+            {
+                lightTexture = Game1.TextureLoader.FromFile("Content/Lights/light.png");
+            }
+
+            texture = lightTexture;
+
+            Game1.LightManager.AddLight(this);
+        }
+
+        public void Draw(SpriteBatch spriteBatch)
+        {
+            Vector2 center = new Vector2(lightTexture.Width / 2, lightTexture.Height / 2);
+            float scale = range / ((float)lightTexture.Width / 2.0f);
+            spriteBatch.Draw(lightTexture, new Vector2(Position.X, -Position.Y), null, color, 0, center, scale, SpriteEffects.None, 1);
+        }
+    }
+}

Subsurface/Map/Lights/LightManager.cs

@@ -1,5 +1,6 @@
 using Microsoft.Xna.Framework;
 using Microsoft.Xna.Framework.Graphics;
+using System.Collections.Generic;
 
 namespace Subsurface.Lights
 {
@@ -7,16 +8,126 @@ namespace Subsurface.Lights
     {
         public static Vector2 ViewPos;
 
-        public static bool FowEnabled = true;
+        public Color AmbientLight;
 
-        public static void DrawFow(GraphicsDevice graphics, Camera cam)
+        RenderTarget2D lightMap;
+
+        private static Texture2D alphaClearTexture;
+
+        private List<LightSource> lights;
+
+        public bool FowEnabled = true;
+
+        public bool LightingEnabled = true;
+
+        public RenderTarget2D LightMap
+        {
+            get { return lightMap; }
+        }
+
+        public LightManager(GraphicsDevice graphics)
+        {
+            lights = new List<LightSource>();
+
+            AmbientLight = new Color(80, 80, 80, 255);
+
+            var pp = graphics.PresentationParameters;
+
+            lightMap = new RenderTarget2D(graphics, Game1.GraphicsWidth, Game1.GraphicsHeight, false,
+                       pp.BackBufferFormat, pp.DepthStencilFormat, pp.MultiSampleCount,
+                       RenderTargetUsage.DiscardContents);
+
+
+            if (alphaClearTexture==null)
+            {
+                alphaClearTexture = Game1.TextureLoader.FromFile("Content/Lights/alphaOne.png");
+            }
+        }
+
+        public void AddLight(LightSource light)
+        {
+            lights.Add(light);
+        }
+
+        public void RemoveLight(LightSource light)
+        {
+            lights.Remove(light);
+        }
+
+        public void DrawFow(GraphicsDevice graphics, Camera cam, Vector2 pos)
         {
             if (!FowEnabled) return;
             foreach (ConvexHull convexHull in ConvexHull.list)
             {
-                convexHull.DrawShadows(graphics, cam, ViewPos);
+                convexHull.DrawShadows(graphics, cam, pos);
             }
         }
+
+        public void DrawLightmap(GraphicsDevice graphics, SpriteBatch spriteBatch, Camera cam)
+        {
+            graphics.SetRenderTarget(lightMap);
+
+            //clear to some small ambient light
+            graphics.Clear(AmbientLight);
+            
+            foreach (LightSource light in lights)
+            {
+                //clear alpha to 1
+                ClearAlphaToOne(graphics, spriteBatch);
+
+                //draw all shadows
+                //write only to the alpha channel, which sets alpha to 0
+                //graphics.RasterizerState = RasterizerState.CullNone;
+                //graphics.BlendState = CustomBlendStates.WriteToAlpha;
+
+                //foreach (ConvexHull ch in ConvexHull.list)
+                //{
+                //    //draw shadow
+                //    ch.DrawShadows(graphics, cam,  light.Position);
+                //}
+
+                //draw the light shape
+                //where Alpha is 0, nothing will be written
+                spriteBatch.Begin(SpriteSortMode.Immediate, CustomBlendStates.MultiplyWithAlpha, null, null, null, null, cam.Transform);
+                light.Draw(spriteBatch);
+                spriteBatch.End();
+            }
+            //clear alpha, to avoid messing stuff up later
+            ClearAlphaToOne(graphics, spriteBatch);
+            graphics.SetRenderTarget(null);
+        }
+
+        private void ClearAlphaToOne(GraphicsDevice graphics, SpriteBatch spriteBatch)
+        {
+            spriteBatch.Begin(SpriteSortMode.Immediate, CustomBlendStates.WriteToAlpha);
+            spriteBatch.Draw(alphaClearTexture, new Rectangle(0, 0,graphics.Viewport.Width, graphics.Viewport.Height), Color.White);
+            spriteBatch.End();
+        }
+    }
+
+
+    class CustomBlendStates
+    {
+        static CustomBlendStates()
+        {
+            Multiplicative = new BlendState();
+            Multiplicative.ColorSourceBlend = Multiplicative.AlphaSourceBlend = Blend.Zero;
+            Multiplicative.ColorDestinationBlend = Multiplicative.AlphaDestinationBlend = Blend.SourceColor;
+            Multiplicative.ColorBlendFunction = Multiplicative.AlphaBlendFunction = BlendFunction.Add;
+
+            WriteToAlpha = new BlendState();
+            WriteToAlpha.ColorWriteChannels = ColorWriteChannels.Alpha;
+
+            MultiplyWithAlpha = new BlendState();
+            MultiplyWithAlpha.ColorDestinationBlend = MultiplyWithAlpha.AlphaDestinationBlend = Blend.One;
+            MultiplyWithAlpha.ColorSourceBlend = MultiplyWithAlpha.AlphaSourceBlend = Blend.DestinationAlpha;
+        }
+        public static BlendState Multiplicative { get; private set; }
+        public static BlendState WriteToAlpha { get; private set; }
+        public static BlendState MultiplyWithAlpha { get; private set; }
+
+
+
     }
 
 }