mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-23 12:22:35 +00:00
319 lines
12 KiB
C#
Executable file
319 lines
12 KiB
C#
Executable file
|
|
#region ================== Copyright (c) 2007 Pascal vd Heiden
|
|
|
|
/*
|
|
* Copyright (c) 2007 Pascal vd Heiden, www.codeimp.com
|
|
* This program is released under GNU General Public License
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#endregion
|
|
|
|
#region ================== Namespaces
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using CodeImp.DoomBuilder.Map;
|
|
using CodeImp.DoomBuilder.Geometry;
|
|
using System.Drawing;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.VisualModes
|
|
{
|
|
public sealed class VisualBlockMap
|
|
{
|
|
// This returns all blocks along the given line
|
|
public List<VisualBlockEntry> GetLineBlocks(Vector2D v1, Vector2D v2)
|
|
{
|
|
int x0 = (int)Math.Floor(Math.Min(v1.x, v2.x));
|
|
int y0 = (int)Math.Floor(Math.Min(v1.y, v2.y));
|
|
int x1 = (int)Math.Floor(Math.Max(v1.x, v2.x)) + 1;
|
|
int y1 = (int)Math.Floor(Math.Max(v1.y, v2.y)) + 1;
|
|
|
|
var result = new List<VisualBlockEntry>();
|
|
root.GetBlocks(new Rectangle(x0, y0, x1 - x0, y1 - y0), ref result);
|
|
return result;
|
|
}
|
|
|
|
public List<VisualBlockEntry> GetBlocks(RectangleF box)
|
|
{
|
|
var result = new List<VisualBlockEntry>();
|
|
root.GetBlocks(ToRectangle(box), ref result);
|
|
return result;
|
|
}
|
|
|
|
public List<VisualBlockEntry> GetBlocks(Vector2D pos)
|
|
{
|
|
var result = new List<VisualBlockEntry>();
|
|
root.GetBlocks(new Point((int)Math.Floor(pos.x), (int)Math.Floor(pos.y)), ref result);
|
|
return result;
|
|
}
|
|
|
|
// This returns a range of blocks in a frustum
|
|
public List<VisualBlockEntry> GetFrustumRange(ProjectedFrustum2D frustum2D)
|
|
{
|
|
var frustum = new Frustum();
|
|
frustum.planes = new Plane[4]
|
|
{
|
|
new Plane(frustum2D.Lines[0]),
|
|
new Plane(frustum2D.Lines[1]),
|
|
new Plane(frustum2D.Lines[2]),
|
|
new Plane(frustum2D.Lines[3])
|
|
};
|
|
|
|
var result = new List<VisualBlockEntry>();
|
|
root.GetBlocks(frustum, ref result);
|
|
return result;
|
|
}
|
|
|
|
public Sector GetSectorAt(Vector2D pos)
|
|
{
|
|
foreach (VisualBlockEntry e in GetBlocks(pos))
|
|
{
|
|
foreach (Sector s in e.Sectors)
|
|
{
|
|
if (s.Intersect(pos))
|
|
{
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
root = new Node(new Rectangle(General.Map.Config.LeftBoundary, General.Map.Config.BottomBoundary, General.Map.Config.RightBoundary - General.Map.Config.LeftBoundary, General.Map.Config.TopBoundary - General.Map.Config.BottomBoundary));
|
|
}
|
|
|
|
public void AddSectorsSet(ICollection<Sector> sectors)
|
|
{
|
|
foreach (Sector s in sectors) AddSector(s);
|
|
}
|
|
|
|
public void AddLinedefsSet(ICollection<Linedef> lines)
|
|
{
|
|
foreach (Linedef line in lines) AddLinedef(line);
|
|
}
|
|
|
|
public void AddThingsSet(ICollection<Thing> things)
|
|
{
|
|
foreach (Thing t in things) AddThing(t);
|
|
}
|
|
|
|
public void AddSector(Sector sector)
|
|
{
|
|
root.GetEntry(ToRectangle(sector.BBox)).Sectors.Add(sector);
|
|
}
|
|
|
|
public void AddLinedef(Linedef line)
|
|
{
|
|
int x0 = (int)Math.Floor(Math.Min(line.Start.Position.x, line.End.Position.x));
|
|
int y0 = (int)Math.Floor(Math.Min(line.Start.Position.y, line.End.Position.y));
|
|
int x1 = (int)Math.Floor(Math.Max(line.Start.Position.x, line.End.Position.x)) + 1;
|
|
int y1 = (int)Math.Floor(Math.Max(line.Start.Position.y, line.End.Position.y)) + 1;
|
|
root.GetEntry(new Rectangle(x0, y0, x1 - x0, y1 - y0)).Lines.Add(line);
|
|
}
|
|
|
|
public void AddThing(Thing thing)
|
|
{
|
|
int x0 = (int)Math.Floor(thing.Position.x - thing.Size);
|
|
int x1 = (int)Math.Floor(thing.Position.x + thing.Size) + 1;
|
|
int y0 = (int)Math.Floor(thing.Position.y - thing.Size);
|
|
int y1 = (int)Math.Floor(thing.Position.y + thing.Size) + 1;
|
|
root.GetEntry(new Rectangle(x0, y0, x1 - x0, y1 - y0)).Things.Add(thing);
|
|
}
|
|
|
|
internal void Dispose()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
static Rectangle ToRectangle(RectangleF bbox)
|
|
{
|
|
int x0 = (int)Math.Floor(bbox.Left);
|
|
int y0 = (int)Math.Floor(bbox.Top);
|
|
int x1 = (int)Math.Floor(bbox.Right) + 1;
|
|
int y1 = (int)Math.Floor(bbox.Bottom) + 1;
|
|
return new Rectangle(x0, y0, x1 - x0, y1 - y0);
|
|
}
|
|
|
|
const int MaxLevels = 8;
|
|
|
|
Node root = new Node(new Rectangle(General.Map.Config.LeftBoundary, General.Map.Config.BottomBoundary, General.Map.Config.RightBoundary - General.Map.Config.LeftBoundary, General.Map.Config.TopBoundary - General.Map.Config.BottomBoundary));
|
|
|
|
struct Plane
|
|
{
|
|
public Plane(Line2D line)
|
|
{
|
|
Vector2D dir = line.v2 - line.v1;
|
|
A = -dir.y;
|
|
B = dir.x;
|
|
D = -(line.v1.x * A + line.v1.y * B);
|
|
}
|
|
|
|
public double A, B, D;
|
|
}
|
|
|
|
class Frustum
|
|
{
|
|
public Plane[] planes;
|
|
}
|
|
|
|
class Node
|
|
{
|
|
enum Visibility { Inside, Intersecting, Outside };
|
|
|
|
public Node(Rectangle bbox)
|
|
{
|
|
this.bbox = bbox;
|
|
extents = new Vector2D(bbox.Width * 0.5f, bbox.Height * 0.5f);
|
|
center = new Vector2D(bbox.X + extents.x, bbox.Y + extents.y);
|
|
}
|
|
|
|
public void GetBlocks(Frustum frustum, ref List<VisualBlockEntry> list)
|
|
{
|
|
Visibility vis = TestVisibility(frustum);
|
|
if (vis == Visibility.Inside)
|
|
{
|
|
GetAllBlocks(ref list);
|
|
}
|
|
else if (vis == Visibility.Intersecting)
|
|
{
|
|
if (visualBlock != null)
|
|
list.Add(visualBlock);
|
|
|
|
if (topLeft != null)
|
|
{
|
|
topLeft.GetBlocks(frustum, ref list);
|
|
topRight.GetBlocks(frustum, ref list);
|
|
bottomLeft.GetBlocks(frustum, ref list);
|
|
bottomRight.GetBlocks(frustum, ref list);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GetAllBlocks(ref List<VisualBlockEntry> list)
|
|
{
|
|
if (visualBlock != null)
|
|
list.Add(visualBlock);
|
|
|
|
if (topLeft != null)
|
|
{
|
|
topLeft.GetAllBlocks(ref list);
|
|
topRight.GetAllBlocks(ref list);
|
|
bottomLeft.GetAllBlocks(ref list);
|
|
bottomRight.GetAllBlocks(ref list);
|
|
}
|
|
}
|
|
|
|
Visibility TestVisibility(Frustum frustum)
|
|
{
|
|
Visibility result = Visibility.Inside;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
Visibility vis = TestFrustumLineVisibility(frustum.planes[i]);
|
|
if (vis == Visibility.Outside)
|
|
return Visibility.Outside;
|
|
else if (vis == Visibility.Intersecting)
|
|
result = Visibility.Intersecting;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
Visibility TestFrustumLineVisibility(Plane plane)
|
|
{
|
|
double e = extents.x * Math.Abs(plane.A) + extents.y * Math.Abs(plane.B);
|
|
double s = center.x * plane.A + center.y * plane.B + plane.D;
|
|
if (s - e > 0.0)
|
|
return Visibility.Inside;
|
|
else if (s + e < 0)
|
|
return Visibility.Outside;
|
|
else
|
|
return Visibility.Intersecting;
|
|
}
|
|
|
|
public void GetBlocks(Point pos, ref List<VisualBlockEntry> list)
|
|
{
|
|
if (visualBlock != null)
|
|
list.Add(visualBlock);
|
|
|
|
if (topLeft != null)
|
|
{
|
|
if (topLeft.bbox.Contains(pos)) topLeft.GetBlocks(pos, ref list);
|
|
if (topRight.bbox.Contains(pos)) topRight.GetBlocks(pos, ref list);
|
|
if (bottomLeft.bbox.Contains(pos)) bottomLeft.GetBlocks(pos, ref list);
|
|
if (bottomRight.bbox.Contains(pos)) bottomRight.GetBlocks(pos, ref list);
|
|
}
|
|
}
|
|
|
|
public void GetBlocks(Rectangle box, ref List<VisualBlockEntry> list)
|
|
{
|
|
if (visualBlock != null)
|
|
list.Add(visualBlock);
|
|
|
|
if (topLeft != null)
|
|
{
|
|
if (topLeft.bbox.IntersectsWith(box)) topLeft.GetBlocks(box, ref list);
|
|
if (topRight.bbox.IntersectsWith(box)) topRight.GetBlocks(box, ref list);
|
|
if (bottomLeft.bbox.IntersectsWith(box)) bottomLeft.GetBlocks(box, ref list);
|
|
if (bottomRight.bbox.IntersectsWith(box)) bottomRight.GetBlocks(box, ref list);
|
|
}
|
|
}
|
|
|
|
public VisualBlockEntry GetEntry(Rectangle box, int level = 0)
|
|
{
|
|
if (level == MaxLevels)
|
|
{
|
|
if (visualBlock == null)
|
|
visualBlock = new VisualBlockEntry();
|
|
return visualBlock;
|
|
}
|
|
|
|
if (topLeft == null)
|
|
CreateChildren();
|
|
|
|
if (topLeft.bbox.Contains(box)) return topLeft.GetEntry(box, level + 1);
|
|
if (topRight.bbox.Contains(box)) return topRight.GetEntry(box, level + 1);
|
|
if (bottomLeft.bbox.Contains(box)) return bottomLeft.GetEntry(box, level + 1);
|
|
if (bottomRight.bbox.Contains(box)) return bottomRight.GetEntry(box, level + 1);
|
|
|
|
if (visualBlock == null)
|
|
visualBlock = new VisualBlockEntry();
|
|
return visualBlock;
|
|
}
|
|
|
|
void CreateChildren()
|
|
{
|
|
int x0 = bbox.X;
|
|
int x1 = bbox.X + bbox.Width / 2;
|
|
int x2 = bbox.X + bbox.Width;
|
|
int y0 = bbox.Y;
|
|
int y1 = bbox.Y + bbox.Height / 2;
|
|
int y2 = bbox.Y + bbox.Height;
|
|
topLeft = new Node(new Rectangle(x0, y0, x1 - x0, y1 - y0));
|
|
topRight = new Node(new Rectangle(x1, y0, x2 - x1, y1 - y0));
|
|
bottomLeft = new Node(new Rectangle(x0, y1, x1 - x0, y2 - y1));
|
|
bottomRight = new Node(new Rectangle(x1, y1, x2 - x1, y2 - y1));
|
|
}
|
|
|
|
Rectangle bbox;
|
|
Vector2D extents;
|
|
Vector2D center;
|
|
|
|
Node topLeft;
|
|
Node topRight;
|
|
Node bottomLeft;
|
|
Node bottomRight;
|
|
VisualBlockEntry visualBlock;
|
|
}
|
|
}
|
|
}
|