470 lines
17 KiB
C#
470 lines
17 KiB
C#
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Xml.Linq;
|
|
|
|
namespace Barotrauma.Lights
|
|
{
|
|
class LightSource
|
|
{
|
|
private static Texture2D lightTexture;
|
|
|
|
private List<ConvexHullList> hullsInRange;
|
|
|
|
private Color color;
|
|
|
|
private float range;
|
|
|
|
public SpriteEffects SpriteEffect = SpriteEffects.None;
|
|
|
|
private Texture2D texture;
|
|
|
|
public Sprite LightSprite;
|
|
|
|
private Sprite overrideLightTexture;
|
|
|
|
public Submarine ParentSub;
|
|
|
|
public bool CastShadows;
|
|
|
|
//what was the range of the light when HullsInRange were last updated
|
|
private float prevHullUpdateRange;
|
|
|
|
private Vector2 prevHullUpdatePosition;
|
|
|
|
public bool NeedsHullUpdate;
|
|
|
|
private Vector2 position;
|
|
public Vector2 Position
|
|
{
|
|
get { return position; }
|
|
set
|
|
{
|
|
if (position == value) return;
|
|
position = value;
|
|
|
|
if (Vector2.Distance(prevHullUpdatePosition, position) < 5.0f) return;
|
|
|
|
NeedsHullUpdate = true;
|
|
prevHullUpdatePosition = position;
|
|
}
|
|
}
|
|
|
|
public float Rotation
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Vector2 WorldPosition
|
|
{
|
|
get { return (ParentSub == null) ? position : position + ParentSub.Position; }
|
|
}
|
|
|
|
public static Texture2D LightTexture
|
|
{
|
|
get
|
|
{
|
|
if (lightTexture == null)
|
|
{
|
|
lightTexture = TextureLoader.FromFile("Content/Lights/light.png");
|
|
}
|
|
|
|
return lightTexture;
|
|
}
|
|
}
|
|
|
|
public Color Color
|
|
{
|
|
get { return color; }
|
|
set { color = value; }
|
|
}
|
|
|
|
public float Range
|
|
{
|
|
get { return range; }
|
|
set
|
|
{
|
|
|
|
range = MathHelper.Clamp(value, 0.0f, 2048.0f);
|
|
if (Math.Abs(prevHullUpdateRange - range) < 10.0f) return;
|
|
|
|
NeedsHullUpdate = true;
|
|
prevHullUpdateRange = range;
|
|
}
|
|
}
|
|
|
|
public LightSource (XElement element)
|
|
: this(Vector2.Zero, 100.0f, Color.White, null)
|
|
{
|
|
range = ToolBox.GetAttributeFloat(element, "range", 100.0f);
|
|
color = new Color(ToolBox.GetAttributeVector4(element, "color", Vector4.One));
|
|
|
|
CastShadows = ToolBox.GetAttributeBool(element, "castshadows", true);
|
|
|
|
foreach (XElement subElement in element.Elements())
|
|
{
|
|
switch (subElement.Name.ToString().ToLowerInvariant())
|
|
{
|
|
case "sprite":
|
|
LightSprite = new Sprite(subElement);
|
|
break;
|
|
case "lighttexture":
|
|
overrideLightTexture = new Sprite(subElement);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public LightSource(Vector2 position, float range, Color color, Submarine submarine)
|
|
{
|
|
hullsInRange = new List<ConvexHullList>();
|
|
|
|
this.ParentSub = submarine;
|
|
|
|
this.position = position;
|
|
this.range = range;
|
|
this.color = color;
|
|
|
|
CastShadows = true;
|
|
|
|
texture = LightTexture;
|
|
|
|
GameMain.LightManager.AddLight(this);
|
|
}
|
|
|
|
/*public void DrawShadows(GraphicsDevice graphics, Camera cam, Matrix shadowTransform)
|
|
{
|
|
if (!CastShadows) return;
|
|
if (range < 1.0f || color.A < 0.01f) return;
|
|
|
|
foreach (Submarine sub in Submarine.Loaded)
|
|
{
|
|
var hulls = GetHullsInRange(sub);
|
|
|
|
if (hulls == null) continue;
|
|
|
|
foreach ( ConvexHull ch in hulls)
|
|
{
|
|
ch.DrawShadows(graphics, cam, this, shadowTransform, false);
|
|
}
|
|
}
|
|
|
|
var outsideHulls = GetHullsInRange(null);
|
|
|
|
NeedsHullUpdate = false;
|
|
|
|
if (outsideHulls == null) return;
|
|
foreach (ConvexHull ch in outsideHulls)
|
|
{
|
|
ch.DrawShadows(graphics, cam, this, shadowTransform, false);
|
|
}
|
|
}
|
|
|
|
private List<ConvexHull> GetHullsInRange(Submarine sub)
|
|
{
|
|
//find the current list of hulls in range
|
|
var chList = hullsInRange.Find(x => x.Submarine == sub);
|
|
|
|
//not found -> create one
|
|
if (chList == null)
|
|
{
|
|
chList = new ConvexHullList(sub);
|
|
hullsInRange.Add(chList);
|
|
}
|
|
|
|
Vector2 lightPos = position;
|
|
if (ParentSub == null)
|
|
{
|
|
//light and the convexhull are both outside
|
|
if (sub == null)
|
|
{
|
|
if (NeedsHullUpdate)
|
|
{
|
|
var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
|
|
if (fullChList != null)
|
|
chList.List = fullChList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox));
|
|
}
|
|
}
|
|
//light is outside, convexhull inside a sub
|
|
else
|
|
{
|
|
lightPos -= sub.Position;
|
|
|
|
Rectangle subBorders = sub.Borders;
|
|
subBorders.Location += sub.HiddenSubPosition.ToPoint() - new Point(0, sub.Borders.Height);
|
|
|
|
//only draw if the light overlaps with the sub
|
|
if (!MathUtils.CircleIntersectsRectangle(lightPos, range, subBorders)) return null;
|
|
|
|
var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
|
|
chList.List = fullChList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//light is inside, convexhull outside
|
|
if (sub == null) return null;
|
|
|
|
//light and convexhull are both inside the same sub
|
|
if (sub == ParentSub)
|
|
{
|
|
if (NeedsHullUpdate)
|
|
{
|
|
var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
|
|
chList.List = fullChList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox));
|
|
}
|
|
}
|
|
//light and convexhull are inside different subs
|
|
else
|
|
{
|
|
if (sub.DockedTo.Contains(ParentSub) && !NeedsHullUpdate) return chList.List;
|
|
|
|
lightPos -= (sub.Position - ParentSub.Position);
|
|
|
|
Rectangle subBorders = sub.Borders;
|
|
subBorders.Location += sub.HiddenSubPosition.ToPoint() - new Point(0, sub.Borders.Height);
|
|
|
|
//only draw if the light overlaps with the sub
|
|
if (!MathUtils.CircleIntersectsRectangle(lightPos, range, subBorders)) return null;
|
|
|
|
var fullChList = ConvexHull.HullLists.Find(x => x.Submarine == sub);
|
|
chList.List = fullChList.List.FindAll(ch => MathUtils.CircleIntersectsRectangle(lightPos, range, ch.BoundingBox));
|
|
}
|
|
}
|
|
|
|
return chList.List;
|
|
}*/
|
|
|
|
private List<Vector2> FindRaycastHits()
|
|
{
|
|
if (!CastShadows) return null;
|
|
if (range < 1.0f || color.A < 0.01f) return null;
|
|
|
|
Vector2 drawPos = position;
|
|
if (ParentSub != null) drawPos += ParentSub.DrawPosition;
|
|
|
|
var hulls = ConvexHull.GetHullsInRange(position, range, ParentSub);
|
|
|
|
//find convexhull segments that are close enough and facing towards the light source
|
|
List<Segment> visibleSegments = new List<Segment>();
|
|
List<SegmentPoint> points = new List<SegmentPoint>();
|
|
foreach (ConvexHull hull in hulls)
|
|
{
|
|
hull.RefreshWorldPositions();
|
|
|
|
var visibleHullSegments = hull.GetVisibleSegments(drawPos);
|
|
visibleSegments.AddRange(visibleHullSegments);
|
|
|
|
foreach (Segment s in visibleHullSegments)
|
|
{
|
|
points.Add(s.Start);
|
|
points.Add(s.End);
|
|
}
|
|
}
|
|
|
|
//add a square-shaped boundary to make sure we've got something to construct the triangles from
|
|
//even if there aren't enough hull segments around the light source
|
|
|
|
//(might be more effective to calculate if we actually need these extra points)
|
|
var boundaryCorners = new List<SegmentPoint> {
|
|
new SegmentPoint(new Vector2(drawPos.X + range*2, drawPos.Y + range*2)),
|
|
new SegmentPoint(new Vector2(drawPos.X + range*2, drawPos.Y - range*2)),
|
|
new SegmentPoint(new Vector2(drawPos.X - range*2, drawPos.Y - range*2)),
|
|
new SegmentPoint(new Vector2(drawPos.X - range*2, drawPos.Y + range*2))
|
|
};
|
|
|
|
points.AddRange(boundaryCorners);
|
|
|
|
var compareCCW = new CompareSegmentPointCW(drawPos);
|
|
points.Sort(compareCCW);
|
|
|
|
List<Vector2> output = new List<Vector2>();
|
|
|
|
//remove points that are very close to each other
|
|
for (int i = 0; i < points.Count - 1; i++)
|
|
{
|
|
if (Math.Abs(points[i].WorldPos.X - points[i + 1].WorldPos.X) < 3 &&
|
|
Math.Abs(points[i].WorldPos.Y - points[i + 1].WorldPos.Y) < 3)
|
|
{
|
|
points.RemoveAt(i + 1);
|
|
}
|
|
}
|
|
|
|
foreach (SegmentPoint p in points)
|
|
{
|
|
Vector2 dir = Vector2.Normalize(p.WorldPos - drawPos);
|
|
Vector2 dirNormal = new Vector2(-dir.Y, dir.X)*3;
|
|
|
|
//do two slightly offset raycasts to hit the segment itself and whatever's behind it
|
|
Vector2 intersection1 = RayCast(drawPos, drawPos + dir * range * 2 - dirNormal, visibleSegments);
|
|
Vector2 intersection2 = RayCast(drawPos, drawPos + dir * range * 2 + dirNormal, visibleSegments);
|
|
|
|
//hit almost the same position -> only add one vertex to output
|
|
if ((Math.Abs(intersection1.X - intersection2.X) < 5 &&
|
|
Math.Abs(intersection1.Y - intersection2.Y) < 5))
|
|
{
|
|
output.Add(intersection1);
|
|
}
|
|
else
|
|
{
|
|
output.Add(intersection1);
|
|
output.Add(intersection2);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
private Vector2 RayCast(Vector2 rayStart, Vector2 rayEnd, List<Segment> segments)
|
|
{
|
|
float closestDist = 0.0f;
|
|
Vector2? closestIntersection = null;
|
|
|
|
foreach (Segment s in segments)
|
|
{
|
|
Vector2? intersection = MathUtils.GetAxisAlignedLineIntersection(rayStart, rayEnd, s.Start.WorldPos, s.End.WorldPos);
|
|
|
|
if (intersection != null)
|
|
{
|
|
float dist = Vector2.Distance((Vector2)intersection, rayStart);
|
|
if (closestIntersection == null || dist < closestDist)
|
|
{
|
|
closestDist = dist;
|
|
closestIntersection = intersection;
|
|
}
|
|
}
|
|
}
|
|
|
|
return closestIntersection == null ? rayEnd : (Vector2)closestIntersection;
|
|
}
|
|
|
|
private void CalculateVertices(List<Vector2> encounters,
|
|
out VertexPositionTexture[] vertexArray, out short[] indexArray)
|
|
{
|
|
List<VertexPositionTexture> vertices = new List<VertexPositionTexture>();
|
|
|
|
Vector2 drawPos = position;
|
|
if (ParentSub != null) drawPos += ParentSub.DrawPosition;
|
|
|
|
// Add a vertex for the center of the mesh
|
|
vertices.Add(new VertexPositionTexture(new Vector3(drawPos.X, drawPos.Y, 0),
|
|
new Vector2(0.5f, 0.5f)));
|
|
|
|
// Add all the other encounter points as vertices
|
|
// storing their world position as UV coordinates
|
|
foreach (Vector2 vertex in encounters)
|
|
{
|
|
Vector2 diff = vertex - drawPos;
|
|
|
|
vertices.Add(new VertexPositionTexture(new Vector3(vertex.X, vertex.Y, 0),
|
|
new Vector2(0.5f, 0.5f) + diff / range / 2));
|
|
}
|
|
|
|
// Compute the indices to form triangles
|
|
List<short> indices = new List<short>();
|
|
for (int i = 0; i < encounters.Count - 1; i++)
|
|
{
|
|
indices.Add(0);
|
|
indices.Add((short)((i + 2) % vertices.Count));
|
|
indices.Add((short)((i + 1) % vertices.Count));
|
|
}
|
|
|
|
indices.Add(0);
|
|
indices.Add((short)(1));
|
|
indices.Add((short)(vertices.Count - 1));
|
|
|
|
vertexArray = vertices.ToArray<VertexPositionTexture>();
|
|
indexArray = indices.ToArray<short>();
|
|
}
|
|
|
|
public void Draw(SpriteBatch spriteBatch, BasicEffect lightEffect)
|
|
{
|
|
Vector2 drawPos = position;
|
|
if (ParentSub != null) drawPos += ParentSub.DrawPosition;
|
|
|
|
drawPos.Y = -drawPos.Y;
|
|
|
|
if (range > 1.0f && false)
|
|
{
|
|
if (overrideLightTexture == null)
|
|
{
|
|
Vector2 center = new Vector2(LightTexture.Width / 2, LightTexture.Height / 2);
|
|
float scale = range / (lightTexture.Width / 2.0f);
|
|
|
|
spriteBatch.Draw(lightTexture, drawPos, null, color * (color.A / 255.0f), 0, center, scale, SpriteEffects.None, 1);
|
|
}
|
|
else
|
|
{
|
|
overrideLightTexture.Draw(spriteBatch,
|
|
drawPos, color * (color.A / 255.0f),
|
|
overrideLightTexture.Origin, -Rotation,
|
|
new Vector2(overrideLightTexture.size.X / overrideLightTexture.SourceRect.Width, overrideLightTexture.size.Y / overrideLightTexture.SourceRect.Height),
|
|
SpriteEffect);
|
|
}
|
|
}
|
|
|
|
if (LightSprite != null)
|
|
{
|
|
//LightSprite.Draw(spriteBatch, drawPos, Color, LightSprite.Origin, -Rotation, 1, SpriteEffect);
|
|
}
|
|
|
|
var verts = FindRaycastHits();
|
|
|
|
/*for (int i = 0; i < verts.Count; i++)
|
|
{
|
|
Color[] clrs = new Color[] { Color.Green, Color.Cyan, Color.Red, Color.White, Color.Magenta };
|
|
|
|
Color clr = clrs[i % clrs.Length];
|
|
|
|
// GUI.DrawString(spriteBatch, new Vector2(verts[i].X, -verts[i].Y), verts[i].ToString(), clr);
|
|
GUI.DrawString(spriteBatch, new Vector2(verts[i].X, -verts[i].Y), i.ToString(), clr);
|
|
GUI.DrawLine(spriteBatch, drawPos, new Vector2(verts[i].X, -verts[i].Y), clr, 0,3);
|
|
}*/
|
|
|
|
// Generate a triangle list from the encounter points
|
|
VertexPositionTexture[] vertices;
|
|
short[] indices;
|
|
CalculateVertices(verts, out vertices, out indices);
|
|
|
|
if (vertices.Length == 0) return;
|
|
|
|
lightEffect.DiffuseColor = (new Vector3(color.R, color.G, color.B) * (color.A / 255.0f)) / 255.0f;// color.ToVector3();
|
|
lightEffect.CurrentTechnique.Passes[0].Apply();
|
|
|
|
GameMain.CurrGraphicsDevice.DrawUserIndexedPrimitives<VertexPositionTexture>
|
|
(
|
|
PrimitiveType.TriangleList, vertices, 0, vertices.Length, indices, 0, indices.Length / 3
|
|
);
|
|
}
|
|
|
|
public void FlipX()
|
|
{
|
|
SpriteEffect = SpriteEffect == SpriteEffects.None ? SpriteEffects.FlipHorizontally : SpriteEffects.None;
|
|
if (LightSprite != null)
|
|
{
|
|
Vector2 lightOrigin = LightSprite.Origin;
|
|
lightOrigin.X = LightSprite.SourceRect.Width - lightOrigin.X;
|
|
LightSprite.Origin = lightOrigin;
|
|
}
|
|
|
|
if (overrideLightTexture != null)
|
|
{
|
|
Vector2 lightOrigin = overrideLightTexture.Origin;
|
|
lightOrigin.X = overrideLightTexture.SourceRect.Width - lightOrigin.X;
|
|
overrideLightTexture.Origin = lightOrigin;
|
|
}
|
|
}
|
|
|
|
public void Remove()
|
|
{
|
|
if (LightSprite != null) LightSprite.Remove();
|
|
|
|
GameMain.LightManager.RemoveLight(this);
|
|
}
|
|
}
|
|
}
|