public override Value Evaluate(FSharpList <Value> args)
{
var input = args[0];
var result = FSharpList <Value> .Empty;
if (input.IsList)
{
var ptList = (input as Value.List).Item;
int length = ptList.Length;
var verts = new List <Vertex3>();
for (int i = 0; i < length; i++)
{
var pt = (XYZ)((Value.Container)ptList[i]).Item;
var vert = new Vertex3(pt.X, pt.Y, pt.Z);
verts.Add(vert);
}
// make triangulation
var triResult = DelaunayTriangulation <Vertex3, Tetrahedron> .Create(verts);
_tessellationLines.Clear();
// make edges
foreach (var cell in triResult.Cells)
{
foreach (var face in cell.MakeFaces())
{
var start1 = cell.Vertices[face[0]].ToXYZ();
var end1 = cell.Vertices[face[1]].ToXYZ();
var start2 = cell.Vertices[face[1]].ToXYZ();
var end2 = cell.Vertices[face[2]].ToXYZ();
var start3 = cell.Vertices[face[2]].ToXYZ();
var end3 = cell.Vertices[face[0]].ToXYZ();
var l1 = this.UIDocument.Application.Application.Create.NewLineBound(start1, end1);
_tessellationLines.Add(l1);
var l2 = this.UIDocument.Application.Application.Create.NewLineBound(start2, end2);
_tessellationLines.Add(l2);
var l3 = this.UIDocument.Application.Application.Create.NewLineBound(start3, end3);
_tessellationLines.Add(l3);
result = FSharpList <Value> .Cons(Value.NewContainer(l1), result);
result = FSharpList <Value> .Cons(Value.NewContainer(l2), result);
result = FSharpList <Value> .Cons(Value.NewContainer(l3), result);
}
}
return(Value.NewList(result));
}
return(Value.NewList(result));
}
/// <summary>
/// Calculate the triangulation of the supplied vertices.
///
/// This overload allows you to reuse the result object, to prevent
/// garbage from being created.
/// </summary>
/// <param name="verts">List of vertices to use for calculation</param>
/// <param name="result">Result object to store the triangulation in</param>
public void CalculateTriangulation(IList <Vector2> verts, ref DelaunayTriangulation result)
{
if (verts == null)
{
throw new ArgumentNullException("points");
}
if (verts.Count < 3)
{
throw new ArgumentException("You need at least 3 points for a triangulation");
}
triangles.Clear();
this.verts = verts;
highest = 0;
for (int i = 0; i < verts.Count; i++)
{
if (Higher(highest, i))
{
highest = i;
}
}
//ShuffleIndices();
// Add first triangle, the bounding triangle.
triangles.Add(new TriangleNode(-2, -1, highest));
RunBowyerWatson();
GenerateResult(ref result);
this.verts = null;
}
public List <Vector3> Fibonacci_Spiral_Sphere(int num_Points3D, float r)
{
List <Vector3> positions = new List <Vector3>();
for (int i = 0; i < num_Points3D; i++)
{
float lat = Mathf.Asin((float)-1.0 + (float)2.0 * (float)i / (num_Points3D + 1));
float lon = ga * (float)i;
float x = Mathf.Cos(lon) * Mathf.Cos(lat);
float y = Mathf.Sin(lon) * Mathf.Cos(lat);
float z = Mathf.Sin(lat);
Vector3 pos = (new Vector3(x, y, z) * r);
positions.Add(Rotate_Points(pos, new Vector3(0f, 0f, 90f)));
}
Points3D = positions;
Vertices = Points3D.ToArray();
Stereograph_Project_Sphere(r);
Dt = Dc.CalculateTriangulation(Points2D);
Triangles = Dt.Triangles.ToArray();
return(positions);
}
/// <summary>
/// Filter the points array and triangle tree into a readable result.
/// </summary>
void GenerateResult(ref DelaunayTriangulation result)
{
if (result == null)
{
result = new DelaunayTriangulation();
}
result.Clear();
for (int i = 0; i < verts.Count; i++)
{
result.Vertices.Add(verts[i]);
}
for (int i = 1; i < triangles.Count; i++)
{
var t = triangles[i];
if (t.IsLeaf && t.IsInner)
{
result.Triangles.Add(t.P0);
result.Triangles.Add(t.P1);
result.Triangles.Add(t.P2);
}
}
}
public static List <OrTriangle> GetTriangles(List <Point2d> plist)
{
DelaunayTriangulation del = new DelaunayTriangulation();
for (int i = 1; i <= plist.Count; i++)
{
del.Vertex[i].x = (int)plist[i - 1].X;
del.Vertex[i].y = (int)plist[i - 1].Y;
}
int ntri = del.Triangulate(plist.Count);
List <OrTriangle> tlist = new List <OrTriangle>();
for (int i = 1; i <= ntri; i++)
{
OrTriangle t = new OrTriangle();
t.p0.X = del.Vertex[del.Triangle[i].vv0].x;
t.p0.Y = del.Vertex[del.Triangle[i].vv0].y;
t.p1.X = del.Vertex[del.Triangle[i].vv1].x;
t.p1.Y = del.Vertex[del.Triangle[i].vv1].y;
t.p2.X = del.Vertex[del.Triangle[i].vv2].x;
t.p2.Y = del.Vertex[del.Triangle[i].vv2].y;
tlist.Add(t);
}
return(tlist);
}
/// <summary>
/// Creates a Delaunay triangulation of a surface with a given set of UV parameters.
/// </summary>
/// <param name="uvs">Set of UV parameters.</param>
/// <param name="face">Surface to triangulate.</param>
public static IEnumerable <Curve> ByParametersOnSurface(IEnumerable <UV> uvs, Surface face)
{
var verts = uvs.Select(Vertex2.FromUV);
var triangulation = DelaunayTriangulation <Vertex2, Cell2> .Create(verts);
// there are three vertices per cell in 2D
foreach (var cell in triangulation.Cells)
{
var v1 = cell.Vertices[0].AsVector();
var v2 = cell.Vertices[1].AsVector();
var v3 = cell.Vertices[2].AsVector();
var xyz1 = face.PointAtParameter(v1.X, v1.Y);
var xyz2 = face.PointAtParameter(v2.X, v2.Y);
var xyz3 = face.PointAtParameter(v3.X, v3.Y);
if (xyz1.DistanceTo(xyz2) > 0.1)
{
var l1 = Line.ByStartPointEndPoint(xyz1, xyz2);
yield return(l1);
}
if (xyz2.DistanceTo(xyz3) > 0.1)
{
var l1 = Line.ByStartPointEndPoint(xyz3, xyz2);
yield return(l1);
}
if (xyz3.DistanceTo(xyz1) > 0.1)
{
var l1 = Line.ByStartPointEndPoint(xyz1, xyz3);
yield return(l1);
}
}
}
public static DelaunayMesh2d GetMesh(List <Point2d> plist)
{
DelaunayMesh2d mesh = new DelaunayMesh2d();
DelaunayTriangulation del = new DelaunayTriangulation();
for (int i = 1; i <= plist.Count; i++)
{
del.Vertex[i].x = (int)plist[i - 1].X;
del.Vertex[i].y = (int)plist[i - 1].Y;
}
int ntri = del.Triangulate(plist.Count);
for (int i = 0; i < plist.Count; i++)
{
mesh.AddVertex(plist[i]);
}
for (int i = 1; i <= ntri; i++)
{
mesh.AddFace(new Triangle((int)del.Triangle[i].vv0 - 1, (int)del.Triangle[i].vv1 - 1, (int)del.Triangle[i].vv2 - 1));
}
for (int i = 0; i < ntri; i++)
{
Triangle t = mesh.Faces[i];
t.Index = i;
mesh.Faces[i] = t;
}
return(mesh);
}
void Start()
{
delaunayTriangulation = GameObject.Find("delaunayTriangulation");
delaunayScript = GameObject.Find("delaunayTriangulation").GetComponent <DelaunayTriangulation>();
trackingAreaThresh = delaunayTriangulation.GetComponent <DelaunayTriangulation>().voidTrackingAreaThresh;
xfadeAreaThresh = delaunayTriangulation.GetComponent <DelaunayTriangulation>().voidXfadeAreaThresh;
GetSelfID();
// CROSSCHECK destroy if go already exists
otherVoidsSelfIdCounter = 0;
otherVoids = GameObject.FindGameObjectsWithTag("void");
foreach (GameObject otherVoid in otherVoids)
{
if (self_id == otherVoid.GetComponent <VoidMesh>().self_id)
{
otherVoidsSelfIdCounter++;
}
if (otherVoidsSelfIdCounter > 1)
{
Destroy(gameObject);
}
}
}
public IEnumerable <(Vector3 v0, Vector3 v1, Vector3 v2)> GetLevelingTriangles()
{
// get the delaunay triangulation
var zDictionary = new Dictionary <(double, double), double>();
var vertices = new List <DefaultVertex>();
if (SampledPositions.Count > 2)
{
foreach (var sample in SampledPositions)
{
vertices.Add(new DefaultVertex()
{
Position = new double[] { sample.X, sample.Y }
});
var key = (sample.X, sample.Y);
if (!zDictionary.ContainsKey(key))
{
zDictionary.Add(key, sample.Z);
}
}
}
else
{
vertices.Add(new DefaultVertex()
{
Position = new double[] { 0, 0 }
});
zDictionary.Add((0, 0), 0);
vertices.Add(new DefaultVertex()
{
Position = new double[] { 200, 0 }
});
zDictionary.Add((200, 0), 0);
vertices.Add(new DefaultVertex()
{
Position = new double[] { 100, 200 }
});
zDictionary.Add((100, 200), 0);
}
int extraXPosition = -50000;
vertices.Add(new DefaultVertex()
{
Position = new double[] { extraXPosition, vertices[0].Position[1] }
});
var triangles = DelaunayTriangulation <DefaultVertex, DefaultTriangulationCell <DefaultVertex> > .Create(vertices, .001);
// make all the triangle planes for these triangles
foreach (var triangle in triangles.Cells)
{
var p0 = triangle.Vertices[0].Position;
var p1 = triangle.Vertices[1].Position;
var p2 = triangle.Vertices[2].Position;
if (p0[0] != extraXPosition && p1[0] != extraXPosition && p2[0] != extraXPosition)
{
var v0 = new Vector3(p0[0], p0[1], zDictionary[(p0[0], p0[1])]);
/// <summary>
/// Creates a Delaunay triangulation of a set of points.
/// </summary>
/// <param name="points">A set of points.</param>
public static IEnumerable <Curve> ByPoints(IEnumerable <Point> points)
{
var verts = points.Select(Vertex3.FromPoint);
var triResult = DelaunayTriangulation <Vertex3, Tetrahedron> .Create(verts);
// make edges
foreach (var cell in triResult.Cells)
{
foreach (var face in cell.MakeFaces())
{
var start1 = cell.Vertices[face[0]].AsPoint();
var end1 = cell.Vertices[face[1]].AsPoint();
var start2 = cell.Vertices[face[1]].AsPoint();
var end2 = cell.Vertices[face[2]].AsPoint();
var start3 = cell.Vertices[face[2]].AsPoint();
var end3 = cell.Vertices[face[0]].AsPoint();
var l1 = Line.ByStartPointEndPoint(start1, end1);
yield return(l1);
var l2 = Line.ByStartPointEndPoint(start2, end2);
yield return(l2);
var l3 = Line.ByStartPointEndPoint(start3, end3);
yield return(l3);
}
}
}
public void Generate()
{
InstancedTiles = new GameObject[size, size];
DungeonTerrainTiles = new DungeonTerrainTile[size, size];
Rooms = new List <Room>();
for (int i = 0; i < attempts; i++)
{
CreateRoom(roomSize.x, roomSize.y);
}
mesh = DelaunayTriangulation.TriangulatePoints(centerWorldTiles);
spanningTree.AddRange(MST.FormTree(mesh, centerWorldTiles.Count, generateExtraEdges));
for (int i = 0; i < spanningTree.Count; i++)
{
CreatePaths(spanningTree[i].edge);
}
onComplete?.Invoke();
if (instantiateDebugTiles)
{
InstantiateTiles();
}
}
void GenerateMap()
{
var startTime = DateTime.Now;
points = BlueNoiseGenerator.PoissonDiscSampling(rMin, rMax, 30, mapSize);
List <Vertex> scaffolding = BlueNoiseGenerator.Scaffolding(mapSize);
points.AddRange(scaffolding);
var duration = DateTime.Now - startTime;
Debug.Log("SeedPoints Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
List <Triangle> convexPoly = Triangulation.TriangulateConvexPolygon(scaffolding);
triangles = Triangulation.TriangleSplittingAlgorithm(points, convexPoly);
//triangles = Triangulation.IncrementalAlgorithm(points);
duration = DateTime.Now - startTime;
Debug.Log("Triangulation Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
triangles = DelaunayTriangulation.MakeTriangulationDelaunay(triangles);
duration = DateTime.Now - startTime;
Debug.Log("Delaunayification Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
triangles = DelaunayTriangulation.FillInNeighbours(triangles);
duration = DateTime.Now - startTime;
Debug.Log("Neighbours Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
// fill heightmap into y coordinates
points = HeightField.PerlinIsland(points, mapSize, 0.1f, 0.7f, 4f, 3f, 6);
duration = DateTime.Now - startTime;
Debug.Log("Heightmap Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
triangles = Voronoi.GenerateCentroids(triangles, points);
duration = DateTime.Now - startTime;
Debug.Log("Centroids Done in " + duration.TotalSeconds + "s");
startTime = DateTime.Now;
cells = CellMeshCreator.SpawnMeshes(points, cell);
duration = DateTime.Now - startTime;
Debug.Log("Meshes Done in " + duration.TotalSeconds + "s");
var camHeight = mapSize * 0.5f / Mathf.Tan(Camera.main.fieldOfView * 0.5f * Mathf.Deg2Rad);
Camera.main.transform.position = new Vector3(mapSize / 2, camHeight * 1.1f, mapSize / 2);
//DebugDraw();
}
/// <summary>
/// Calculate the triangulation of the supplied vertices
/// </summary>
/// <param name="verts">List of vertices to use for calculation</param>
/// <returns>The calculated Delaunay triangulation<returns>
public DelaunayTriangulation CalculateTriangulation(IList <Vector2> verts)
{
DelaunayTriangulation result = null;
CalculateTriangulation(verts, ref result);
return(result);
}
public void Triangulation()
{
triangles.Clear();
if (points.Count >= 3)
{
triangles = DelaunayTriangulation.Triangulate(points);
}
Debug.Log(triangles.Count);
}
public static SphereMeshData GenerateSphere(float density, float planetRadius)
{
List <Vector3> points = GeneratePoints(density, planetRadius);
//triangulate the projection of the points
DelaunayCalculator delaunayCalculator = new DelaunayCalculator();
DelaunayTriangulation triangulation = new DelaunayTriangulation();
delaunayCalculator.CalculateTriangulation(StereographicProjection(points), ref triangulation);
return(GenerateMesh(triangulation, points, planetRadius));
}
void Init()
{
delaunayTriangulation = new DelaunayTriangulation();
Color.RGBToHSV(color, out hsvColor.h, out hsvColor.s, out hsvColor.v);
orgPosList = new List <Vector3> ();
// randomPoints
for (var i = 0; i < num; i++)
{
orgPosList.Add(createVector(random(rect.xMin, rect.xMax), random(rect.yMin, rect.yMax)));
}
int pointCount = orgPosList.Count;
// speed
spList = new List <Vector3> ();
for (int i = 0; i < pointCount; i++)
{
Vector3 sp = new Vector3(Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f), Random.Range(-1.0f, 1.0f));
spList.Add(sp);
}
// current
currentPosList = new List <Vector3> ();
currentPosList.AddRange(orgPosList);
movePosList = new List <Vector3> ();
for (int i = 0; i < pointCount; i++)
{
movePosList.Add(Vector3.zero);
}
// v color
float h = hsvColor.h;
hsvColors = new List <HSVColor> ();
for (int i = 0; i < 7; i++)
{
HSVColor c = new HSVColor(h, 0, 0);
hsvColors.Add(c);
}
for (int i = 0; i < pointCount; i++)
{
float s = Random.Range(0.5f, 1) * 0.5f;
float b = Random.Range(0.3f, 1) * 0.5f;
HSVColor c = new HSVColor(h, s, b);
hsvColors.Add(c);
}
// mesh
mesh = new Mesh();
mf.mesh = mesh;
}
public override void SetupScene(int level)
{
this.level = level;
SetupParameters();
initilizationFinished = false;
initializationStarted = false;
startingRoomsList.Clear();
roomList.Clear();
traingulationScript = new DelaunayTriangulation();
treeScript = new DTMinSpanningTree();
CreateLevel();
}
public void Execute(IVectorImageProvider imageProvider)
{
DelaunayTriangulation triangulator = new DelaunayTriangulation(new VectorCloud2D(imageProvider.CurrImage.GetPrimitives <Vector2D>()));
imageProvider.CurrImage.primitives.AddRange(triangulator.Triangulate());
/*
* foreach (Shape2D s in image.GetPrimitives<Shape2D>())
* {
* s.RemoveDuplicates();
* }
*/
}
public void TestTriangulation()
{
List <DelaunayTriangulation.Point> points = new List <DelaunayTriangulation.Point>();
points.Add(new DelaunayTriangulation.Point(0, 0));
points.Add(new DelaunayTriangulation.Point(0, 2));
points.Add(new DelaunayTriangulation.Point(0, -2));
points.Add(new DelaunayTriangulation.Point(2, 1));
points.Add(new DelaunayTriangulation.Point(2, -1));
points.Add(new DelaunayTriangulation.Point(-2, 1));
points.Add(new DelaunayTriangulation.Point(-2, -1));
List <DelaunayTriangulation.Triangle> triangles = DelaunayTriangulation.CreateDelaunayTriangulation(points);
}
public FibonacciPoints3D(int numPoints, float radius)
{
Points3D = new List <Vector3>();
Points2D = new List <Vector2>();
PointsM = new List <Vector3>();
PointsU = new List <Vector3>();
Triangles = new int[Points3D.Count * 3];
Dc = new DelaunayCalculator();
Dt = null;
Update_Points(numPoints, radius);
}
public IrregularDtm(AttributedPointCollection collection)
{
this.collection = collection;
//PointCollection c = new PointCollection();
//for (int i = 0; i < collection.Count; i++)
//{
// c.Add(new Point(collection[i].X, collection[i].Y));
//}
this.triangulation = new DelaunayTriangulation(this.collection);
currenTriangle = triangulation.triangles[0];
}
public FibonacciPoints3D()
{
Points3D = new List <Vector3>();
Points2D = new List <Vector2>();
PointsM = new List <Vector3>();
PointsU = new List <Vector3>();
Triangles = new int[Points3D.Count * 3];
Vertices = new Vector3[Points3D.Count];
Dc = new DelaunayCalculator();
Dt = null;
Update_Points(50, 0.5f);
}
public void Reset()
{
toAddQueue = new Queue <Measurement3D>();
Triangulation = new DelaunayTriangulation();
tetrahedrons = new List <MonoTetrahedron>();
measurements = new List <MonoMeasurement3D>();
measurementsContainer = new GameObject("Measurements");
tetrahedronsContainer = new GameObject("Tetrahedrons");
allMeshes = new GameObject("All Meshed");
measurementsContainer.transform.parent = transform;
tetrahedronsContainer.transform.parent = transform;
allMeshes.transform.parent = transform;
allMeshes.AddComponent <MeshRenderer>().material = new Material(Shader.Find("Custom/Tetrahedron"));
allMeshes.AddComponent <MeshFilter>();
}
private List <Triangle> Triangulation()
{
List <Vector3> pointList = new List <Vector3>();
for (int i = 0; i < mainRoomList.Count; i++)
{
pointList.Add(new Vector3(mainRoomList[i].center.x, mainRoomList[i].center.y, mainRoomList[i].id));
}
List <Triangle> triangleList = DelaunayTriangulation.TriangulateByFlippingEdges(pointList);
///
//DrawTriangles(triangleList);
return(triangleList);
}
public IrregularDtm(double[] east, double[] north, double[] value)
{
try
{
this.collection = new AttributedPointCollection(new List <double>(east),
new List <double>(north),
new List <double>(value));
triangulation = new DelaunayTriangulation(collection);
currenTriangle = triangulation.triangles[0];
}
catch (Exception ex)
{
throw ex;
}
}
public LevelingFunctions(PrinterSettings printerSettings, PrintLevelingData levelingData)
{
this.printerSettings = printerSettings;
this.SampledPositions = new List <Vector3>(levelingData.SampledPositions);
bedSize = printerSettings.GetValue <Vector2>(SettingsKey.bed_size);
// get the delaunay triangulation
var zDictionary = new Dictionary <(double, double), double>();
var vertices = new List <DefaultVertex>();
foreach (var sample in SampledPositions)
{
vertices.Add(new DefaultVertex()
{
Position = new double[] { sample.X, sample.Y } //, sample.Z }
});
var key = (sample.X, sample.Y);
if (!zDictionary.ContainsKey(key))
{
zDictionary.Add(key, sample.Z);
}
}
;
int extraXPosition = -50000;
vertices.Add(new DefaultVertex()
{
Position = new double[] { extraXPosition, SampledPositions[0].Y }
});
var triangles = DelaunayTriangulation <DefaultVertex, DefaultTriangulationCell <DefaultVertex> > .Create(vertices, .001);
var probeOffset = new Vector3(0, 0, printerSettings.GetValue <double>(SettingsKey.z_probe_z_offset));
// make all the triangle planes for these triangles
foreach (var triangle in triangles.Cells)
{
var p0 = triangle.Vertices[0].Position;
var p1 = triangle.Vertices[1].Position;
var p2 = triangle.Vertices[2].Position;
if (p0[0] != extraXPosition && p1[0] != extraXPosition && p2[0] != extraXPosition)
{
var v0 = new Vector3(p0[0], p0[1], zDictionary[(p0[0], p0[1])]);
void Start()
{
// with a spawned GO...
// instantiate frame = the GO does nothing
// frame 2 = Start(), not Update() yet
// frame 3 = the first Update()
floorWidth = GameObject.Find("floor").GetComponent <Renderer>().bounds.size.x;
floorHeight = GameObject.Find("floor").GetComponent <Renderer>().bounds.size.z;
delaunayScript = GameObject.Find("delaunayTriangulation").GetComponent <DelaunayTriangulation>();
boundingQbits_allInfo = self_voidAllInfo.boundingQbits_allInfo;
self_id = self_voidAllInfo.id;
mouseRaycast_script = GameObject.Find("mouseRaycast").GetComponent <MouseRaycast>();
trackingAreaThresh = delaunayScript.voidTrackingAreaThresh;
xfadeAreaThresh = delaunayScript.voidXfadeAreaThresh;
// these interestingly have to be here in the Start() or the DelaunayTriangulation script
// won't be able to check the centroid of this mesh until the 3rd frame after instantiation,
// and you'd get two GOs spawned per void centroid
meshCentroid = self_voidAllInfo.centroid;
meshArea = self_voidAllInfo.area;
firstMeshFrame = true;
oscOutScript = GameObject.Find("osc").GetComponent <OscOut>();
oscInScript = GameObject.Find("osc").GetComponent <OscIn>();
oscInScript.MapInt("/void/" + (self_id + 1) + "/igniterEvent/click", OscIn_IgniterClick);
oscInScript.MapInt("/void/" + (self_id + 1) + "/igniterEvent/end", OscIn_IgniterEnd);
swarmParams_script = GameObject.Find("swarmParams").GetComponent <SwarmParams>();
springJoint = GetComponent <SpringJoint>();
voidRigidbody = GetComponent <Rigidbody>();
mixer = new Mixer();
MixerValues_Init();
localPosPrev = transform.position;
}
//generates the mesh from the triangulation
public static SphereMeshData GenerateMesh(DelaunayTriangulation triangles, List <Vector3> points, float planetRadius)
{
int numTris = triangles.Triangles.Count;
int numVertices = triangles.Vertices.Count;
SphereMeshData meshData = new SphereMeshData(numVertices, numTris);
Debug.Log(triangles.Vertices[0]);
Debug.Log(points[0]);
meshData.vertices = InverseStereographicProjection(triangles.Vertices, planetRadius).ToArray();
for (int triangleIndex = 0; triangleIndex < numTris / 3; triangleIndex++)
{
meshData.AddTriangle(
triangles.Triangles[triangleIndex * 3],
triangles.Triangles[triangleIndex * 3 + 1],
triangles.Triangles[triangleIndex * 3 + 2]
);
}
return(meshData);
}
public Triangle(DelaunayTriangulation dt_, int id1, int id2, int id3)
{
dt = dt_;
triIndexs = new int[3] {
id1, id2, id3
};
List <Vector3> vertices = dt.vertices;
Vector3 v1 = vertices[id1];
Vector3 v2 = vertices[id2];
Vector3 v3 = vertices[id3];
float c = 2.0f * ((v2.x - v1.x) * (v3.y - v1.y) - (v2.y - v1.y) * (v3.x - v1.x));
float x = ((v3.y - v1.y) * (sq(v2.x) - sq(v1.x) + sq(v2.y) - sq(v1.y)) + (v1.y - v2.y) * (sq(v3.x) - sq(v1.x) + sq(v3.y) - sq(v1.y))) / c;
float y = ((v1.x - v3.x) * (sq(v2.x) - sq(v1.x) + sq(v2.y) - sq(v1.y)) + (v2.x - v1.x) * (sq(v3.x) - sq(v1.x) + sq(v3.y) - sq(v1.y))) / c;
Vector3 center = createVector(x, y);
v1.z = 0;
center.z = 0;
float radiuqSqr = Vector3.SqrMagnitude(v1 - center);
this.center = center;
this.sqrRadius = radiuqSqr;
}
public void Generate()
{
// Dungeongeneration implementiert annhähernd nach https://www.gamasutra.com/blogs/AAdonaac/20150903/252889/Procedural_Dungeon_Generation_Algorithm.php
List <Room> rooms = new List <Room>(); // erstes Erstellen der Räume
for (int i = 0; i < Args.Rooms; i++)
{
Room r = MakeRoom();
if (r != null)
{
rooms.Add(r);
}
}
Vector[] centerPoints = new Vector[rooms.Count];
for (int i = 0; i < rooms.Count; i++)
{
centerPoints[i] = rooms[i].CenterPos;
}
DelaunayTriangulation triang = new DelaunayTriangulation(new Vector(Fields.GetLength(0), Fields.GetLength(1)), centerPoints);
MinimumSpanningTree mst = new MinimumSpanningTree(triang);
List <Edge> edges = new List <Edge>();
edges.AddRange(mst.Edges);
edges.AddRange(rnd.PickElements(triang.Edges.Where(x => !mst.Edges.Contains(x)), Args.LeaveConnectionPercentage)); // lässt manche redundante Verbindungen da, damit Dungeon nicht linear ist
List <Corridor> corridors = new List <Corridor>();
foreach (Edge e in edges) // versucht, Räume anhand der bestimmten Verbindungen mit Korridoren zu verbinden
{
Corridor c = ConnectRooms(Room.GetRoomByPosition(rooms, e.A), Room.GetRoomByPosition(rooms, e.B));
if (c != null)
{
corridors.Add(c);
c.A.Connections.Add(c);
c.B.Connections.Add(c);
}
}
StartRoom = FindRoomWithMostConnections(rooms);
RemoveUnreacheableRooms(rooms, StartRoom);
Rooms = rooms.ToArray();
for (int x = 0; x < Fields.GetLength(0); x++)
{
for (int y = 0; y < Fields.GetLength(1); y++)
{
Fields[x, y].SetFieldTypeAndAnimation(Fields);
}
}
List <Rectangle> b = new List <Rectangle>(); // Bounding-Rechtecke der Räume und Korridore
foreach (Room r in rooms)
{
b.AddRange(r.Bounds);
}
foreach (Corridor c in corridors)
{
b.AddRange(c.Bounds);
}
Bounds = b.ToArray();
}
public static DelaunayMesh2d GetMesh(List<Point2d> plist)
{
DelaunayMesh2d mesh = new DelaunayMesh2d();
DelaunayTriangulation del = new DelaunayTriangulation();
for (int i = 1; i <= plist.Count; i++)
{
del.Vertex[i].x = (int)plist[i - 1].x;
del.Vertex[i].y = (int)plist[i - 1].y;
}
int ntri = del.Triangulate(plist.Count);
for (int i = 0; i < plist.Count; i++)
{
mesh.AddVertex(plist[i]);
}
for (int i = 1; i <= ntri; i++)
{
mesh.AddFace(new Triangle((int)del.Triangle[i].vv0 - 1, (int)del.Triangle[i].vv1 - 1, (int)del.Triangle[i].vv2 - 1));
}
for (int i = 0; i < ntri; i++)
{
Triangle t = mesh.Faces[i];
t.Index = i;
mesh.Faces[i] = t;
}
return mesh;
}
public static List<OrTriangle> GetTriangles(List<Point2d> plist)
{
DelaunayTriangulation del = new DelaunayTriangulation();
for (int i = 1; i <= plist.Count; i++)
{
del.Vertex[i].x = (int)plist[i - 1].x;
del.Vertex[i].y = (int)plist[i - 1].y;
}
int ntri = del.Triangulate(plist.Count);
List<OrTriangle> tlist = new List<OrTriangle>();
for (int i = 1; i <= ntri; i++)
{
OrTriangle t = new OrTriangle();
t.p0.x = del.Vertex[del.Triangle[i].vv0].x;
t.p0.y = del.Vertex[del.Triangle[i].vv0].y;
t.p1.x = del.Vertex[del.Triangle[i].vv1].x;
t.p1.y = del.Vertex[del.Triangle[i].vv1].y;
t.p2.x = del.Vertex[del.Triangle[i].vv2].x;
t.p2.y = del.Vertex[del.Triangle[i].vv2].y;
tlist.Add(t);
}
return tlist;
}
