mirror of
https://git.do.srb2.org/STJr/UltimateZoneBuilder.git
synced 2024-11-30 15:41:30 +00:00
654 lines
19 KiB
C#
654 lines
19 KiB
C#
|
|
#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;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using CodeImp.DoomBuilder.Geometry;
|
|
using CodeImp.DoomBuilder.Rendering;
|
|
using SlimDX.Direct3D;
|
|
using System.Drawing;
|
|
using CodeImp.DoomBuilder.Map;
|
|
|
|
#endregion
|
|
|
|
namespace CodeImp.DoomBuilder.Geometry
|
|
{
|
|
/// <summary>
|
|
/// Responsible for creating and caching sector polygons.
|
|
/// Performs triangulation of sectors by using ear clipping.
|
|
/// </summary>
|
|
/// See: http://www.geometrictools.com/Documentation/TriangulationByEarClipping.pdf
|
|
public sealed class EarClipTriangulator : Triangulator
|
|
{
|
|
#region ================== Delegates
|
|
|
|
// For debugging purpose only!
|
|
// These are not called in a release build
|
|
public delegate void ShowLine(Vector2D v1, Vector2D v2, PixelColor c);
|
|
public delegate void ShowPolygon(Polygon p, PixelColor c);
|
|
public delegate void ShowPoint(Vector2D v, int c);
|
|
public delegate void ShowEarClip(EarClipVertex[] found, LinkedList<EarClipVertex> remaining);
|
|
|
|
// For debugging purpose only!
|
|
// These are not called in a release build
|
|
public ShowLine OnShowLine;
|
|
public ShowPolygon OnShowPolygon;
|
|
public ShowPoint OnShowPoint;
|
|
public ShowEarClip OnShowEarClip;
|
|
|
|
#endregion
|
|
|
|
#region ================== Constants
|
|
|
|
#endregion
|
|
|
|
#region ================== Variables
|
|
|
|
#endregion
|
|
|
|
#region ================== Properties
|
|
|
|
#endregion
|
|
|
|
#region ================== Constructor / Disposer
|
|
|
|
// Constructor
|
|
public EarClipTriangulator()
|
|
{
|
|
// Initialize
|
|
|
|
// We have no destructor
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
// Diposer
|
|
public override void Dispose()
|
|
{
|
|
// Not already disposed?
|
|
if(!isdisposed)
|
|
{
|
|
// Clean up
|
|
|
|
// Done
|
|
base.Dispose();
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Methods
|
|
|
|
// This triangulates a sector and stores it
|
|
protected override void PerformTriangulation(Sector sector)
|
|
{
|
|
TriangleList triangles = new TriangleList();
|
|
List<Polygon> polys;
|
|
|
|
/*
|
|
* This process is divided into several steps:
|
|
*
|
|
* 1) Tracing the sector lines to find clockwise outer polygons
|
|
* and counter-clockwise inner polygons. These are arranged in a
|
|
* polygon tree for the next step.
|
|
*
|
|
* 2) Cutting the inner polygons to make a flat list of only
|
|
* outer polygons.
|
|
*
|
|
* 3) Ear-clipping the polygons to create triangles.
|
|
*
|
|
*/
|
|
|
|
// TRACING
|
|
polys = DoTrace(sector);
|
|
|
|
// CUTTING
|
|
DoCutting(polys);
|
|
|
|
// EAR-CLIPPING
|
|
foreach(Polygon p in polys) triangles.AddRange(DoEarClip(p));
|
|
|
|
// STORE
|
|
base.StoreTriangles(sector, triangles);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Tracing
|
|
|
|
// This traces sector lines to create a polygon tree
|
|
private List<Polygon> DoTrace(Sector s)
|
|
{
|
|
Dictionary<Sidedef, bool> todosides = new Dictionary<Sidedef, bool>(s.Sidedefs.Count);
|
|
List<Polygon> root = new List<Polygon>();
|
|
TracePath path;
|
|
Polygon newpoly;
|
|
Vertex start;
|
|
|
|
// Fill the dictionary
|
|
// The bool value is used to indicate lines which has been visited in the trace
|
|
foreach(Sidedef sd in s.Sidedefs) todosides.Add(sd, false);
|
|
|
|
// First remove all sides that refer to the same sector on both sides of the line
|
|
RemoveDoubleSidedefReferences(todosides, s.Sidedefs);
|
|
|
|
// Continue until all sidedefs have been processed
|
|
while(todosides.Count > 0)
|
|
{
|
|
// Reset all visited indicators
|
|
foreach(Sidedef sd in s.Sidedefs) if(todosides.ContainsKey(sd)) todosides[sd] = false;
|
|
|
|
// Find the right-most vertex to start a trace with.
|
|
// This guarantees that we start out with an outer polygon and we just
|
|
// have to check if it is inside a previously found polygon.
|
|
start = FindRightMostVertex(todosides);
|
|
|
|
// Trace to find a polygon
|
|
path = DoTracePath(new TracePath(), start, null, s, todosides);
|
|
|
|
// If tracing is not possible (sector not closed?)
|
|
// then leave with what we have up till now
|
|
if(path == null) break;
|
|
|
|
// Remove the sides found in the path
|
|
foreach(Sidedef sd in path) todosides.Remove(sd);
|
|
|
|
// Create the polygon
|
|
newpoly = path.MakePolygon();
|
|
|
|
// Determine where this polygon goes in our tree
|
|
foreach(Polygon p in root)
|
|
{
|
|
// Insert if it belongs as a child
|
|
if(p.InsertChild(newpoly))
|
|
{
|
|
// Done
|
|
newpoly = null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Still not inserted in our tree?
|
|
if(newpoly != null)
|
|
{
|
|
// Then add it at root level as outer polygon
|
|
newpoly.Inner = false;
|
|
root.Add(newpoly);
|
|
}
|
|
}
|
|
|
|
// Return result
|
|
return root;
|
|
}
|
|
|
|
// This recursively traces a path
|
|
// Returns the resulting TracePath when the search is complete
|
|
// or returns null when no path found.
|
|
private TracePath DoTracePath(TracePath history, Vertex fromhere, Vertex findme, Sector sector, Dictionary<Sidedef, bool> sides)
|
|
{
|
|
TracePath nextpath;
|
|
TracePath result;
|
|
Vertex nextvertex;
|
|
List<Sidedef> allsides;
|
|
SidedefAngleSorter sorter;
|
|
|
|
// Found the vertex we are tracing to?
|
|
if(fromhere == findme) return history;
|
|
|
|
// On the first run, findme is null (otherwise the trace would end
|
|
// immeditely when it starts) so set findme here on the first run.
|
|
if(findme == null) findme = fromhere;
|
|
|
|
// Make a list of sides referring to the same sector
|
|
allsides = new List<Sidedef>(fromhere.Linedefs.Count * 2);
|
|
foreach(Linedef l in fromhere.Linedefs)
|
|
{
|
|
// Should we go along the front or back side?
|
|
// This is very important for clockwise polygon orientation!
|
|
if(l.Start == fromhere)
|
|
{
|
|
// Front side of line connected to sector?
|
|
if((l.Front != null) && (l.Front.Sector == sector))
|
|
{
|
|
// Visit here when not visited yet
|
|
if(sides.ContainsKey(l.Front) && !sides[l.Front]) allsides.Add(l.Front);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Back side of line connected to sector?
|
|
if((l.Back != null) && (l.Back.Sector == sector))
|
|
{
|
|
// Visit here when not visited yet
|
|
if(sides.ContainsKey(l.Back) && !sides[l.Back]) allsides.Add(l.Back);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Previous line available?
|
|
if(history.Count > 0)
|
|
{
|
|
// This is done to ensure the tracing works along vertices that are shared by
|
|
// more than 2 lines/sides of the same sector. We must continue tracing along
|
|
// the first next smallest delta angle! This sorts the smallest delta angle to
|
|
// the top of the list.
|
|
sorter = new SidedefAngleSorter(history[history.Count - 1], fromhere);
|
|
allsides.Sort(sorter);
|
|
}
|
|
|
|
// Go for all lines connected to this vertex
|
|
foreach(Sidedef s in allsides)
|
|
{
|
|
// Mark sidedef as visited and move to next vertex
|
|
sides[s] = true;
|
|
nextpath = new TracePath(history, s);
|
|
if(s.Line.Start == fromhere) nextvertex = s.Line.End; else nextvertex = s.Line.Start;
|
|
result = DoTracePath(nextpath, nextvertex, findme, sector, sides);
|
|
if(result != null) return result;
|
|
}
|
|
|
|
// Nothing found
|
|
return null;
|
|
}
|
|
|
|
// This removes all sidedefs which has a sidedefs on the other side
|
|
// of the same line that refers to the same sector. These are removed
|
|
// because they are useless and make the triangulation inefficient.
|
|
private void RemoveDoubleSidedefReferences(Dictionary<Sidedef, bool> todosides, ICollection<Sidedef> sides)
|
|
{
|
|
// Go for all sides
|
|
foreach(Sidedef sd in sides)
|
|
{
|
|
// Double sided?
|
|
if(sd.Other != null)
|
|
{
|
|
// Referring to the same sector on both sides?
|
|
if(sd.Sector == sd.Other.Sector)
|
|
{
|
|
// Remove this one
|
|
todosides.Remove(sd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// This finds the right-most vertex to start tracing with
|
|
private Vertex FindRightMostVertex(Dictionary<Sidedef, bool> sides)
|
|
{
|
|
Vertex found = General.GetByIndex<Sidedef>(sides.Keys, 0).Line.Start;
|
|
|
|
// Go for all sides to find the right-most side
|
|
foreach(KeyValuePair<Sidedef, bool> sd in sides)
|
|
{
|
|
// Check if more to the right than the last found
|
|
if(sd.Key.Line.Start.X > found.X) found = sd.Key.Line.Start;
|
|
if(sd.Key.Line.End.X > found.X) found = sd.Key.Line.End;
|
|
}
|
|
|
|
// Return result
|
|
return found;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Cutting
|
|
|
|
// This cuts into outer polygons to solve inner polygons and make the polygon tree flat
|
|
private void DoCutting(List<Polygon> polys)
|
|
{
|
|
Queue<Polygon> todo = new Queue<Polygon>(polys);
|
|
|
|
// Begin processing outer polygons
|
|
while(todo.Count > 0)
|
|
{
|
|
// Get outer polygon to process
|
|
Polygon p = todo.Dequeue();
|
|
|
|
// Any inner polygons to work with?
|
|
if(p.Children.Count > 0)
|
|
{
|
|
// Go for all the children
|
|
foreach(Polygon c in p.Children)
|
|
{
|
|
// The children of the children are outer polygons again,
|
|
// so move them to the root and add for processing
|
|
polys.AddRange(c.Children);
|
|
foreach(Polygon sc in c.Children) todo.Enqueue(sc);
|
|
|
|
// Remove from inner polygon
|
|
c.Children.Clear();
|
|
}
|
|
|
|
// Now do some cutting on this polygon to merge the inner polygons
|
|
MergeInnerPolys(p);
|
|
}
|
|
}
|
|
}
|
|
|
|
// This takes an outer polygon and a set of inner polygons to start cutting on
|
|
private void MergeInnerPolys(Polygon p)
|
|
{
|
|
LinkedList<Polygon> todo = new LinkedList<Polygon>(p.Children);
|
|
LinkedListNode<EarClipVertex> start;
|
|
LinkedListNode<Polygon> ip;
|
|
LinkedListNode<Polygon> found;
|
|
LinkedListNode<EarClipVertex> foundstart;
|
|
|
|
// Continue until no more inner polygons to process
|
|
while(todo.Count > 0)
|
|
{
|
|
// Find the inner polygon with the highest x vertex
|
|
found = null;
|
|
foundstart = null;
|
|
ip = todo.First;
|
|
while(ip != null)
|
|
{
|
|
start = FindRightMostVertex(ip.Value);
|
|
if((foundstart == null) || (start.Value.Position.x > foundstart.Value.Position.x))
|
|
{
|
|
// Found a better start
|
|
found = ip;
|
|
foundstart = start;
|
|
}
|
|
|
|
// Next!
|
|
ip = ip.Next;
|
|
}
|
|
|
|
// Remove from todo list
|
|
todo.Remove(found);
|
|
|
|
// Get cut start and end
|
|
SplitOuterWithInner(foundstart, p, found.Value);
|
|
}
|
|
|
|
// Remove the children, they should be merged in the polygon by now
|
|
p.Children.Clear();
|
|
}
|
|
|
|
// This finds the right-most vertex in an inner polygon to use for cut startpoint.
|
|
private LinkedListNode<EarClipVertex> FindRightMostVertex(Polygon p)
|
|
{
|
|
LinkedListNode<EarClipVertex> found = p.First;
|
|
LinkedListNode<EarClipVertex> v = found.Next;
|
|
|
|
// Go for all vertices to find the on with the biggest x value
|
|
while(v != null)
|
|
{
|
|
if(v.Value.Position.x > found.Value.Position.x) found = v;
|
|
v = v.Next;
|
|
}
|
|
|
|
// Return result
|
|
return found;
|
|
}
|
|
|
|
// This finds the cut coordinates and splits the other poly with inner vertices
|
|
private void SplitOuterWithInner(LinkedListNode<EarClipVertex> start, Polygon p, Polygon inner)
|
|
{
|
|
Line2D starttoright = new Line2D(start.Value.Position, start.Value.Position + new Vector2D(1000.0f, 0.0f));
|
|
LinkedListNode<EarClipVertex> v1, v2;
|
|
LinkedListNode<EarClipVertex> insertbefore = null;
|
|
float u, ul, foundu = float.MaxValue;
|
|
EarClipVertex split;
|
|
|
|
// Go for all lines in the outer polygon
|
|
v1 = p.Last;
|
|
v2 = p.First;
|
|
while(v2 != null)
|
|
{
|
|
// Check if the line is to the right of start
|
|
if((v1.Value.Position.x > start.Value.Position.x) ||
|
|
(v2.Value.Position.x > start.Value.Position.x))
|
|
{
|
|
// Find intersection
|
|
Line2D pl = new Line2D(v1.Value.Position, v2.Value.Position);
|
|
pl.GetIntersection(starttoright, out u, out ul);
|
|
if(float.IsNaN(u))
|
|
{
|
|
// We have found a line that is perfectly horizontal
|
|
// (parallel to the cut scan line) Check if the line
|
|
// is overlapping the cut scan line.
|
|
if(v1.Value.Position.y == start.Value.Position.y)
|
|
{
|
|
// Calculate distance of each vertex in units
|
|
u = starttoright.GetNearestOnLine(v1.Value.Position);
|
|
ul = starttoright.GetNearestOnLine(v2.Value.Position);
|
|
|
|
// Rule out vertices before the scan line
|
|
if(u < 0) u = float.MaxValue;
|
|
if(ul < 0) ul = float.MaxValue;
|
|
|
|
// Choose closest of both vertices
|
|
if((u < ul) && (u < foundu))
|
|
{
|
|
insertbefore = v2;
|
|
foundu = u;
|
|
}
|
|
else if((u > ul) && (ul < foundu))
|
|
{
|
|
insertbefore = v2;
|
|
foundu = ul;
|
|
}
|
|
}
|
|
}
|
|
// Found a closer match?
|
|
else if((ul >= 0) && (ul <= 1) && (u > 0) && (u < foundu))
|
|
{
|
|
// Found a closer intersection
|
|
insertbefore = v2;
|
|
foundu = u;
|
|
}
|
|
}
|
|
|
|
// Next
|
|
v1 = v2;
|
|
v2 = v2.Next;
|
|
}
|
|
|
|
// Found anything?
|
|
if(insertbefore != null)
|
|
{
|
|
// Find the position where we have to split the outer polygon
|
|
split = new EarClipVertex(starttoright.GetCoordinatesAt(foundu));
|
|
|
|
// Insert manual split vertices
|
|
p.AddBefore(insertbefore, new EarClipVertex(split));
|
|
|
|
// Start inserting from the start (do I make sense this time?)
|
|
v1 = start;
|
|
do
|
|
{
|
|
// Insert inner polygon vertex
|
|
p.AddBefore(insertbefore, new EarClipVertex(v1.Value));
|
|
if(v1.Next != null) v1 = v1.Next; else v1 = v1.List.First;
|
|
}
|
|
while(v1 != start);
|
|
|
|
// Insert manual split vertices
|
|
p.AddBefore(insertbefore, new EarClipVertex(start.Value));
|
|
p.AddBefore(insertbefore, new EarClipVertex(split));
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("Can't find an edge for polygon cutting!");
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region ================== Ear Clipping
|
|
|
|
// This clips a polygon and returns the triangles
|
|
// The polygon may not have any holes or islands
|
|
private TriangleList DoEarClip(Polygon poly)
|
|
{
|
|
LinkedList<EarClipVertex> verts = new LinkedList<EarClipVertex>();
|
|
List<EarClipVertex> convexes = new List<EarClipVertex>(poly.Count);
|
|
LinkedList<EarClipVertex> reflexes = new LinkedList<EarClipVertex>();
|
|
LinkedList<EarClipVertex> eartips = new LinkedList<EarClipVertex>();
|
|
TriangleList result = new TriangleList();
|
|
EarClipVertex v, v1, v2;
|
|
EarClipVertex[] t, t1, t2;
|
|
|
|
// Go for all vertices to fill list
|
|
foreach(EarClipVertex vec in poly)
|
|
vec.SetVertsLink(verts.AddLast(vec));
|
|
|
|
// Optimization: Vertices which have lines with the
|
|
// same angle are useless. Remove them!
|
|
v = verts.First.Value;
|
|
while(v != null)
|
|
{
|
|
// Get the next vertex
|
|
if(v.MainListNode.Next != null) v1 = v.MainListNode.Next.Value; else v1 = null;
|
|
|
|
// Get triangle for v
|
|
t = GetTriangle(v);
|
|
|
|
// Check if both lines have the same angle
|
|
Line2D a = new Line2D(t[0].Position, t[1].Position);
|
|
Line2D b = new Line2D(t[1].Position, t[2].Position);
|
|
if(Math.Abs(Angle2D.Difference(a.GetAngle(), b.GetAngle())) < 0.00001f)
|
|
{
|
|
// Same angles, remove vertex
|
|
v.Remove();
|
|
}
|
|
|
|
// Next!
|
|
v = v1;
|
|
}
|
|
|
|
// Go for all vertices to determine reflex or convex
|
|
foreach(EarClipVertex vv in verts)
|
|
{
|
|
// Add to reflex or convex list
|
|
if(IsReflex(GetTriangle(vv))) vv.AddReflex(reflexes); else convexes.Add(vv);
|
|
}
|
|
|
|
// Go for all convex vertices to see if they are ear tips
|
|
foreach(EarClipVertex cv in convexes)
|
|
{
|
|
// Add when this a valid ear
|
|
t = GetTriangle(cv);
|
|
if(CheckValidEar(t, reflexes)) cv.AddEarTip(eartips);
|
|
}
|
|
|
|
// Process ears until done
|
|
while((eartips.Count > 0) && (verts.Count > 2))
|
|
{
|
|
// Get next ear
|
|
v = eartips.First.Value;
|
|
t = GetTriangle(v);
|
|
|
|
// Add ear as triangle
|
|
result.Add(t);
|
|
|
|
// Remove this ear from all lists
|
|
v.Remove();
|
|
v1 = t[0];
|
|
v2 = t[2];
|
|
|
|
#if DEBUG
|
|
if(OnShowEarClip != null) OnShowEarClip(t, verts);
|
|
#endif
|
|
|
|
// Test first neighbour
|
|
t1 = GetTriangle(v1);
|
|
if(IsReflex(t1))
|
|
{
|
|
// List as reflex if not listed yet
|
|
if(!v1.IsReflex) v1.AddReflex(reflexes);
|
|
v1.RemoveEarTip();
|
|
}
|
|
else
|
|
{
|
|
// Remove from reflexes
|
|
v1.RemoveReflex();
|
|
}
|
|
|
|
// Test second neighbour
|
|
t2 = GetTriangle(v2);
|
|
if(IsReflex(t2))
|
|
{
|
|
// List as reflex if not listed yet
|
|
if(!v2.IsReflex) v2.AddReflex(reflexes);
|
|
v2.RemoveEarTip();
|
|
}
|
|
else
|
|
{
|
|
// Remove from reflexes
|
|
v2.RemoveReflex();
|
|
}
|
|
|
|
// Check if any neightbour have become a valid or invalid ear
|
|
if(!v1.IsReflex && CheckValidEar(t1, reflexes)) v1.AddEarTip(eartips); else v1.RemoveEarTip();
|
|
if(!v2.IsReflex && CheckValidEar(t2, reflexes)) v2.AddEarTip(eartips); else v2.RemoveEarTip();
|
|
}
|
|
|
|
// Return result
|
|
return result;
|
|
}
|
|
|
|
// This checks if a given ear is a valid (no intersections from reflex vertices)
|
|
private bool CheckValidEar(EarClipVertex[] t, LinkedList<EarClipVertex> reflexes)
|
|
{
|
|
// Go for all reflex vertices
|
|
foreach(EarClipVertex rv in reflexes)
|
|
{
|
|
// Return false on intersection
|
|
if(PointInsideTriangle(t, rv.Position) &&
|
|
(rv != t[0]) && (rv != t[1]) && (rv != t[2])) return false;
|
|
}
|
|
|
|
// Valid ear!
|
|
return true;
|
|
}
|
|
|
|
// This returns the 3-vertex array triangle for an ear
|
|
private EarClipVertex[] GetTriangle(EarClipVertex v)
|
|
{
|
|
EarClipVertex[] t = new EarClipVertex[3];
|
|
if(v.MainListNode.Previous == null) t[0] = v.MainListNode.List.Last.Value; else t[0] = v.MainListNode.Previous.Value;
|
|
t[1] = v;
|
|
if(v.MainListNode.Next == null) t[2] = v.MainListNode.List.First.Value; else t[2] = v.MainListNode.Next.Value;
|
|
return t;
|
|
}
|
|
|
|
// This checks if a vertex is reflex (corner > 180 deg) or convex (corner < 180 deg)
|
|
private bool IsReflex(EarClipVertex[] t)
|
|
{
|
|
// Return true when corner is > 180 deg
|
|
//return (Line2D.GetSideOfLine(t[0].Position, t[2].Position, t[1].Position) < 0.00001f);
|
|
return (Line2D.GetSideOfLine(t[0].Position, t[2].Position, t[1].Position) < 0);
|
|
}
|
|
|
|
// This checks if a point is inside a triangle
|
|
// NOTE: vertices in t must be in clockwise order!
|
|
private bool PointInsideTriangle(EarClipVertex[] t, Vector2D p)
|
|
{
|
|
return (Line2D.GetSideOfLine(t[0].Position, t[1].Position, p) < 0.00001f) &&
|
|
(Line2D.GetSideOfLine(t[1].Position, t[2].Position, p) < 0.00001f) &&
|
|
(Line2D.GetSideOfLine(t[2].Position, t[0].Position, p) < 0.00001f);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|