public override InputGeometry Generate(double param0, double param1, double param2)
{
// Number of points on the outer circle
int n = GetParamValueInt(0, param0);
int count, npoints;
double radius = GetParamValueInt(1, param1);
// Step size on the outer circle
double h = 2 * Math.PI * radius / n;
// Current radius and step size
double r, dphi;
InputGeometry input = new InputGeometry(n + 1);
// Inner cirlce (radius = 1)
r = 1;
npoints = (int)(2 * Math.PI * r / h);
dphi = 2 * Math.PI / npoints;
for (int i = 0; i < npoints; i++)
{
input.AddPoint(r * Math.Cos(i * dphi), r * Math.Sin(i * dphi), 1);
input.AddSegment(i, (i + 1) % npoints, 1);
}
count = input.Count;
// Center cirlce
r = (radius + 1) / 2.0;
npoints = (int)(2 * Math.PI * r / h);
dphi = 2 * Math.PI / npoints;
for (int i = 0; i < npoints; i++)
{
input.AddPoint(r * Math.Cos(i * dphi), r * Math.Sin(i * dphi), 2);
input.AddSegment(count + i, count + (i + 1) % npoints, 2);
}
count = input.Count;
// Outer cirlce
r = radius;
npoints = (int)(2 * Math.PI * r / h);
dphi = 2 * Math.PI / npoints;
for (int i = 0; i < npoints; i++)
{
input.AddPoint(r * Math.Cos(i * dphi), r * Math.Sin(i * dphi), 3);
input.AddSegment(count + i, count + (i + 1) % npoints, 3);
}
input.AddHole(0, 0);
// Regions: |++++++|++++++|---|
// r 1 0
input.AddRegion((r + 3.0) / 4.0, 0, 1);
input.AddRegion((3 * r + 1.0) / 4.0, 0, 2);
return(input);
}
/// <summary> Inserts points and segments of the given polygon to the input geometry </summary>
static public void AddPolygon(this InputGeometry input, IList <Vector2> polygon)
{
int inputCount = input.Count;
input.AddPoint(polygon[0].x, polygon[0].y);
for (int i = 1, j = 0; i < polygon.Count; j = i++)
{
input.AddPoint(polygon[i].x, polygon[i].y);
input.AddSegment(inputCount + j, inputCount + i);
}
input.AddSegment(input.Count - 1, inputCount);
}
Mesh generateFaceMesh(ShapePoints shape)
{
var mesh = new Mesh();
var verts = new List <Vector3>();
var tris = new List <int>();
var uvs = new List <Vector2>();
var uv2 = new List <Vector2>();
var geometry = new InputGeometry();
for (int i = 0; i < shape.edge.Length; ++i)
{
var pt = shape.edge[i];
geometry.AddPoint(pt.x, pt.y);
verts.Add(pt.p.AsVector3(-pt.groundness * _groundPull));
uvs.Add(pt.p);
uv2.Add(new Vector2(pt.groundness * pt.groundness, 0));
geometry.AddSegment(i, (i + 1) % shape.edge.Length);
}
for (int i = 0; i < shape.interior.Length; ++i)
{
var pt = shape.interior[i];
geometry.AddPoint(pt.x, pt.y);
verts.Add(pt.p.AsVector3(-pt.groundness * _groundPull + UnityEngine.Random.value * 0.4f));
uvs.Add(pt.p);
uv2.Add(new Vector2(pt.groundness * pt.groundness, 0));
}
var behave = new TriangleNet.Behavior();
behave.Algorithm = TriangleNet.TriangulationAlgorithm.Incremental;
var meshRepresentation = new TriangleNet.Mesh(behave);
meshRepresentation.Triangulate(geometry);
foreach (var tri in meshRepresentation.Triangles)
{
tris.Add(tri.GetVertex(2).ID);
tris.Add(tri.GetVertex(1).ID);
tris.Add(tri.GetVertex(0).ID);
}
mesh.vertices = verts.ToArray();
mesh.triangles = tris.ToArray();
mesh.uv = uvs.ToArray();
mesh.uv2 = uv2.ToArray();
mesh.RecalculateNormals();
mesh.RecalculateBounds();
return(mesh);
}
/// <summary>
/// Rebuild the input geometry.
/// </summary>
private InputGeometry Rebuild()
{
InputGeometry geometry = new InputGeometry(mesh.vertices.Count);
foreach (var vertex in mesh.vertices.Values)
{
geometry.AddPoint(vertex.x, vertex.y, vertex.mark);
}
foreach (var segment in mesh.subsegs.Values)
{
geometry.AddSegment(segment.P0, segment.P1, segment.Boundary);
}
foreach (var hole in mesh.holes)
{
geometry.AddHole(hole.x, hole.y);
}
foreach (var region in mesh.regions)
{
geometry.AddRegion(region.point.x, region.point.y, region.id);
}
return(geometry);
}
private static void ReadVertex(InputGeometry data, int index, string[] line, int attributes, int marks)
{
double[] numArray;
double num = double.Parse(line[1], FileReader.nfi);
double num1 = double.Parse(line[2], FileReader.nfi);
int num2 = 0;
if (attributes == 0)
{
numArray = null;
}
else
{
numArray = new double[attributes];
}
double[] numArray1 = numArray;
for (int i = 0; i < attributes; i++)
{
if ((int)line.Length > 3 + i)
{
numArray1[i] = double.Parse(line[3 + i]);
}
}
if (marks > 0 && (int)line.Length > 3 + attributes)
{
num2 = int.Parse(line[3 + attributes]);
}
data.AddPoint(num, num1, num2, numArray1);
}
private void CreatePolygonMesh(Vector2d[] points, ref UnityEngine.Mesh mesh)
{
var inp = new InputGeometry(points.Length);
int i = 0;
foreach (var p in points)
{
var localMercPos = p - Tile.Rect.Center;
inp.AddPoint(localMercPos.x, localMercPos.y);
inp.AddSegment(i, (i + 1) % points.Length);
i++;
}
var md = new MeshData();
CreateMesh(inp, md);
//I want object center to be in the middle of object, not at the corner of the tile
var center = ChangeToRelativePositions(md.Vertices);
transform.localPosition = center;
mesh.vertices = md.Vertices.ToArray();
mesh.triangles = md.Indices.ToArray();
mesh.SetUVs(0, md.UV);
mesh.RecalculateNormals();
}
public static InputGeometry InputGeometry(this Polygon this_)
{
InputGeometry geometry = new InputGeometry();
int boundary;
// Add points.
boundary = 1;
int pointIndexOffset = 0;
this_.EnumeratePolygons((Polygon eachPolygon) =>
{
// Add points.
this_.EnumeratePoints((Vector2 eachPoint) =>
{
geometry.AddPoint(
(double)eachPoint.x,
(double)eachPoint.y,
boundary);
});
this_.EnumerateEdges((EPPZ.Geometry.Edge eachEdge) =>
{
int index_a = eachEdge.vertexA.index + pointIndexOffset;
int index_b = eachEdge.vertexB.index + pointIndexOffset;
geometry.AddSegment(index_a, index_b, boundary);
});
pointIndexOffset += eachPolygon.vertexCount; // Track point offsets.
boundary++;
});
return geometry;
}
/// <summary>
/// Add a polygon ring to the geometry and make it a hole.
/// </summary>
/// <remarks>
/// WARNING: This works for convex polygons, but not for non-convex regions in general.
/// </remarks>
/// <param name="points">List of points which make up the hole.</param>
/// <param name="mark">Common boundary mark for all segments of the hole.</param>
public static void AddRingAsHole(this InputGeometry geometry,
IEnumerable <Point> points, int mark = 0)
{
// Save the current number of points.
int N = geometry.Count;
// Hole coordinates
float x = 0.0f;
float y = 0.0f;
int m = 0;
foreach (var pt in points)
{
x += pt.X;
y += pt.Y;
geometry.AddPoint(pt.X, pt.Y, pt.Boundary, pt.Attributes);
m++;
}
for (int i = 0; i < m; i++)
{
geometry.AddSegment(N + i, N + ((i + 1) % m), mark);
}
geometry.AddHole(x / m, y / m);
}
private int CreateRoofTriangulation(List <Vector3> corners, float height, MeshData data)
{
_mesh = new TriangleNet.Mesh();
var inp = new InputGeometry(corners.Count);
for (int i = 0; i < corners.Count; i++)
{
var v = corners[i];
inp.AddPoint(v.x, v.z);
inp.AddSegment(i, (i + 1) % corners.Count);
}
_mesh.Behavior.Algorithm = TriangulationAlgorithm.SweepLine;
_mesh.Behavior.Quality = true;
_mesh.Triangulate(inp);
var vertsStartCount = data.Vertices.Count;
data.Vertices.AddRange(corners.Select(x => new Vector3(x.x, height, x.z)).ToList());
foreach (var tri in _mesh.Triangles)
{
data.Indices.Add(vertsStartCount + tri.P1);
data.Indices.Add(vertsStartCount + tri.P0);
data.Indices.Add(vertsStartCount + tri.P2);
}
return(vertsStartCount);
}
/// <summary>
/// Read vertex information of the given line.
/// </summary>
/// <param name="data">The input geometry.</param>
/// <param name="index">The current vertex index.</param>
/// <param name="line">The current line.</param>
/// <param name="attributes">Number of point attributes</param>
/// <param name="marks">Number of point markers (0 or 1)</param>
static void ReadVertex(InputGeometry data, int index, string[] line, int attributes, int marks)
{
double x = double.Parse(line[1], nfi);
double y = double.Parse(line[2], nfi);
int mark = 0;
double[] attribs = attributes == 0 ? null : new double[attributes];
// Read the vertex attributes.
for (int j = 0; j < attributes; j++)
{
if (line.Length > 3 + j)
{
attribs[j] = double.Parse(line[3 + j]);
}
}
// Read a vertex marker.
if (marks > 0 && line.Length > 3 + attributes)
{
mark = int.Parse(line[3 + attributes]);
}
data.AddPoint(x, y, mark, attribs);
}
public WaterSurfacePolygon(List<Point> points)
{
mesh = new TriangleNet.Mesh();
mesh.Behavior.Quality = true;
this.points = points;
triangleNormals = new List<Point>();
trianglePlaneEquationDs = new List<double>();
InputGeometry geomtery = new InputGeometry();
for (int i = 0; i < points.Count; i++)
{
Point p = points[i];
if (i == 0)
{
minX = maxX = p.X;
minY = maxY = p.Y;
minZ = maxZ = p.Z;
}
else
{
minX = Math.Min(p.X, minX);
maxX = Math.Max(p.X, maxX);
minY = Math.Min(p.Y, minY);
maxY = Math.Max(p.Y, maxY);
minZ = Math.Min(p.Z, minZ);
maxZ = Math.Max(p.Z, maxZ);
}
geomtery.AddPoint(p.X, p.Y, 0, p.Z);
//add segments
if (i > 0)
{
geomtery.AddSegment(i - 1, i, 0);
}
if (i == points.Count - 1)
{
geomtery.AddSegment(i, 0, 0);
}
}
mesh.Triangulate(geomtery);
triangles = new List<TriangleNet.Data.Triangle>();
foreach (TriangleNet.Data.Triangle tr in mesh.Triangles)
{
if (tr.P0 < points.Count && tr.P1 < points.Count && tr.P2 < points.Count)
{
triangles.Add(tr);
}
}
calculateNormalsAndDs();
}
protected override GameObject CreateLayer(Tile tile, List <JSONObject> items)
{
var main = new GameObject("Landuse Layer");
var _meshes = new Dictionary <LanduseKind, MeshData>();
foreach (var geo in items.Where(x => Query(x)))
{
var kind = geo["properties"]["kind"].str.ConvertToLanduseType();
if (!FactorySettings.HasSettingsFor(kind) && !JustDrawEverythingFam)
{
continue;
}
//var typeSettings = FactorySettings.GetSettingsFor<LanduseSettings>(kind);
if (!_meshes.ContainsKey(kind))
{
_meshes.Add(kind, new MeshData());
}
//foreach (var bb in geo["geometry"]["coordinates"].list)
//{
var bb = geo["geometry"]["coordinates"].list[0]; //this is wrong but cant fix it now
var count = bb.list.Count - 1;
if (count < 3)
{
continue;
}
var inp = new InputGeometry(count);
for (int i = 0; i < count; i++)
{
var c = bb.list[i];
var dotMerc = GM.LatLonToMeters(c[1].f, c[0].f);
var localMercPos = dotMerc - tile.Rect.Center;
inp.AddPoint(localMercPos.x, localMercPos.y);
inp.AddSegment(i, (i + 1) % count);
}
CreateMesh(inp, _meshes[kind]);
if (_meshes[kind].Vertices.Count > 64000)
{
CreateGameObject(kind, _meshes[kind], main.transform);
_meshes[kind] = new MeshData();
}
//}
}
foreach (var group in _meshes)
{
CreateGameObject(group.Key, group.Value, main.transform);
}
return(main);
}
protected override GameObject CreateLayer(Tile tile, List<JSONObject> items)
{
var main = new GameObject("Earth Layer");
var meshes = new Dictionary<EarthType, MeshData>();
foreach (var geo in items.Where(x => Query(x)))
{
var kind = geo["properties"].HasField("kind")
? geo["properties"]["kind"].str.ConvertToEarthType()
: EarthType.Earth;
var typeSettings = FactorySettings.GetSettingsFor<EarthSettings>(kind);
//if we dont have a setting defined for that, it'Ll be merged to "unknown"
if (!FactorySettings.HasSettingsFor(kind))
kind = EarthType.Earth;
if (!meshes.ContainsKey(kind))
meshes.Add(kind, new MeshData());
foreach (var bb in geo["geometry"]["coordinates"].list)
{
var jo = (bb.list[0].list[0].IsArray) ? bb.list[0] : bb;
var count = jo.list.Count - 1;
if (count < 3)
continue;
var inp = new InputGeometry(count);
for (int i = 0; i < count; i++)
{
var c = jo.list[i];
var dotMerc = GM.LatLonToMeters(c[1].f, c[0].f);
var localMercPos = dotMerc - tile.Rect.Center;
inp.AddPoint(localMercPos.x, localMercPos.y);
inp.AddSegment(i, (i + 1) % count);
}
//create mesh, actually just to get vertice&indices
//filling last two parameters, horrible call yea
CreateMesh(inp, meshes[kind]);
//unity cant handle more than 65k on single mesh
//so we'll finish current and start a new one
if (meshes[kind].Vertices.Count > 64000)
{
CreateGameObject(kind, meshes[kind], main.transform);
meshes[kind] = new MeshData();
}
}
}
foreach (var group in meshes)
{
CreateGameObject(group.Key, group.Value, main.transform);
}
return main;
}
public override InputGeometry Generate(double param0, double param1, double param2)
{
int n = GetParamValueInt(0, param0);
int m = n / 2;
InputGeometry input = new InputGeometry(n + 1);
double ro, r = 10;
double step = 2 * Math.PI / m;
// Inner ring
for (int i = 0; i < m; i++)
{
input.AddPoint(r * Math.Cos(i * step), r * Math.Sin(i * step));
input.AddSegment(i, (i + 1) % m);
}
r = 1.5 * r;
step = 2 * Math.PI / n;
double offset = step / 2;
// Outer ring
for (int i = 0; i < n; i++)
{
ro = r;
if (i % 2 == 0)
{
ro = r + r * Util.Random.NextDouble() * (param1 / 100);
}
input.AddPoint(ro * Math.Cos(i * step + offset), ro * Math.Sin(i * step + offset));
input.AddSegment(m + i, m + ((i + 1) % n));
}
input.AddHole(0, 0);
return(input);
}
protected override IEnumerable <MonoBehaviour> Create(Tile tile, JSONObject geo)
{
var kind = geo["properties"]["kind"].str.ConvertToLanduseType();
if (!FactorySettings.HasSettingsFor(kind) && !JustDrawEverythingFam)
{
yield break;
}
var bb = geo["geometry"]["coordinates"].list[0]; //this is wrong but cant fix it now
if (bb == null || bb.list == null)
{
yield break;
}
var count = bb.list.Count - 1;
if (count < 3)
{
yield break;
}
var inp = new InputGeometry(count);
for (var i = 0; i < count; i++)
{
var c = bb.list[i];
var dotMerc = GM.LatLonToMeters(c[1].f, c[0].f);
var localMercPos = dotMerc - tile.Rect.Center;
inp.AddPoint(localMercPos.x, localMercPos.y);
inp.AddSegment(i, (i + 1) % count);
}
var landuse = new GameObject("Landuse").AddComponent <Landuse>();
var md = new MeshData();
var mesh = landuse.GetComponent <MeshFilter>().mesh;
SetProperties(geo, landuse, kind);
CreateMesh(inp, md);
//I want object center to be in the middle of object, not at the corner of the tile
var landuseCenter = ChangeToRelativePositions(md.Vertices);
landuse.transform.localPosition = landuseCenter;
mesh.vertices = md.Vertices.ToArray();
mesh.triangles = md.Indices.ToArray();
mesh.SetUVs(0, md.UV);
mesh.RecalculateNormals();
yield return(landuse);
}
public override InputGeometry Generate(double param0, double param1, double param2)
{
int numRays = GetParamValueInt(0, param0);
InputGeometry input = new InputGeometry(numRays + 4);
input.AddPoint(0, 0); // Center
double x, y, r, e, step = 2 * Math.PI / numRays;
for (int i = 0; i < numRays; i++)
{
e = Util.Random.NextDouble() * step * 0.7;
r = (Util.Random.NextDouble() + 0.7) * 0.5;
x = r * Math.Cos(i * step + e);
y = r * Math.Sin(i * step + e);
input.AddPoint(x, y, 2);
input.AddSegment(0, i + 1, 2);
}
input.AddPoint(-1, -1, 1); // Box
input.AddPoint(1, -1, 1);
input.AddPoint(1, 1, 1);
input.AddPoint(-1, 1, 1);
numRays = input.Count;
input.AddSegment(numRays - 1, numRays - 2, 1);
input.AddSegment(numRays - 2, numRays - 3, 1);
input.AddSegment(numRays - 3, numRays - 4, 1);
input.AddSegment(numRays - 4, numRays - 1, 1);
return(input);
}
public override InputGeometry Generate(double param0, double param1, double param2)
{
int numPoints = GetParamValueInt(0, param0);
numPoints = (numPoints / 10) * 10;
if (numPoints < 5)
{
numPoints = 5;
}
double exp = (param1 + 10) / 100;
InputGeometry input = new InputGeometry(numPoints);
int i = 0, cNum = 2 * (int)Math.Floor(Math.Sqrt(numPoints));
double r, phi, radius = 100, step = 2 * Math.PI / cNum;
// Distrubute points equally on circle border
for (; i < cNum; i++)
{
// Add a little error
r = Util.Random.NextDouble();
input.AddPoint((radius + r) * Math.Cos(i * step),
(radius + r) * Math.Sin(i * step));
}
for (; i < numPoints; i++)
{
// Use sqrt(rand) to get normal distribution right.
r = Math.Pow(Util.Random.NextDouble(), exp) * radius;
phi = Util.Random.NextDouble() * Math.PI * 2;
input.AddPoint(r * Math.Cos(phi), r * Math.Sin(phi));
}
return(input);
}
public void Triangulate()
{
indices.Clear();
if (texVertices.Count >= 3)
{
InputGeometry inputGeometry = new InputGeometry(texVertices.Count);
for (int i = 0; i < texVertices.Count; ++i)
{
Vector2 vertex = texVertices[i].vertex;
inputGeometry.AddPoint(vertex.x, vertex.y);
}
for (int i = 0; i < edges.Count; ++i)
{
Edge edge = edges[i];
inputGeometry.AddSegment(texVertices.IndexOf(edge.vertex1),
texVertices.IndexOf(edge.vertex2));
}
for (int i = 0; i < holes.Count; ++i)
{
Vector2 hole = holes[i].vertex;
inputGeometry.AddHole(hole.x, hole.y);
}
TriangleNet.Mesh trangleMesh = new TriangleNet.Mesh();
trangleMesh.Triangulate(inputGeometry);
foreach (TriangleNet.Data.Triangle triangle in trangleMesh.Triangles)
{
if (triangle.P0 >= 0 && triangle.P0 < texVertices.Count &&
triangle.P0 >= 0 && triangle.P1 < texVertices.Count &&
triangle.P0 >= 0 && triangle.P2 < texVertices.Count)
{
indices.Add(triangle.P0);
indices.Add(triangle.P2);
indices.Add(triangle.P1);
}
}
}
isDirty = true;
}
static void SearchTree(InputGeometry inputGeometry, ref int pointIndex, PolyNode node)
{
foreach (PolyNode childNode in node.Childs)
{
int startIndex = pointIndex;
foreach (Vector2 point in childNode.Contour)
{
inputGeometry.AddPoint(point.X, point.Y);
if (pointIndex > startIndex)
{
inputGeometry.AddSegment(pointIndex - 1, pointIndex);
}
pointIndex++;
}
inputGeometry.AddSegment(pointIndex - 1, startIndex);
if (childNode.IsHole)
{
for (int i = 0, j = childNode.Contour.Count - 1, k = childNode.Contour.Count - 2; i < childNode.Contour.Count; k = j, j = i, i++)
{
Vector2 a1 = childNode.Contour[k];
Vector2 a2 = childNode.Contour[j];
Vector2 a3 = childNode.Contour[i];
if (Vector2.VectorProduct(a2 - a1, a3 - a1) < 0)
{
Vector2 c = (a1 + a3) / 2;
Vector2 d = a2 - c;
float x = c.Length * 2;
Vector2 hole;
do
{
x /= 2;
hole = c + (1 - x) * d;
} while (!IsInside(childNode, hole));
x /= 512;
hole = c + (1 - x) * d;
inputGeometry.AddHole(hole.X, hole.Y);
break;
}
}
}
SearchTree(inputGeometry, ref pointIndex, childNode);
}
}
private void ReadPoints(InputGeometry geometry, Dictionary <string, object> points, ref int count)
{
ArrayList data = points["data"] as ArrayList;
ArrayList markers = null;
ArrayList attributes = null;
if (points.ContainsKey("markers"))
{
markers = points["markers"] as ArrayList;
}
if (points.ContainsKey("attributes"))
{
attributes = points["attributes"] as ArrayList;
}
if (data != null)
{
int mark, n = data.Count;
if (n % 2 != 0)
{
throw new Exception("JSON format error (points).");
}
// Number of points
count = n / 2;
for (int i = 0; i < n; i += 2)
{
mark = 0;
if (markers != null && markers.Count == count)
{
mark = int.Parse(markers[i / 2].ToString());
}
geometry.AddPoint(
double.Parse(data[i].ToString(), Util.Nfi),
double.Parse(data[i + 1].ToString(), Util.Nfi),
mark
);
}
}
}
void SearchTree(InputGeometry inputGeometry, ref int pointIndex, PolyNode node)
{
foreach (PolyNode childNode in node.Childs)
{
int startIndex = pointIndex;
foreach (ControlPoint point in childNode.Contour)
{
inputGeometry.AddPoint(point.X, point.Y);
if (pointIndex > startIndex)
{
inputGeometry.AddSegment(pointIndex - 1, pointIndex);
}
pointIndex++;
}
inputGeometry.AddSegment(pointIndex - 1, startIndex);
if (childNode.IsHole)
{
for (int i = 0, j = childNode.Contour.Count - 1, k = childNode.Contour.Count - 2; i < childNode.Contour.Count; k = j, j = i, i++)
{
ControlPoint a1 = childNode.Contour[k];
ControlPoint a2 = childNode.Contour[j];
ControlPoint a3 = childNode.Contour[i];
if (ControlPoint.VectorProduct(a2 - a1, a3 - a1) < 0)
{
ControlPoint c = ((a1 + a3) / 2) - a2;
double x = 2;
ControlPoint hole;
do
{
x /= 2;
hole = a2 + (c * x);
} while (!IsInside(childNode, hole));
inputGeometry.AddHole(hole.X, hole.Y);
break;
}
}
}
SearchTree(inputGeometry, ref pointIndex, childNode);
}
}
/// <summary>
/// Add a polygon ring to the geometry.
/// </summary>
/// <param name="points">List of points which make up the polygon.</param>
/// <param name="mark">Common boundary mark for all segments of the polygon.</param>
public static void AddRing(this InputGeometry geometry, IEnumerable <Point> points, int mark = 0)
{
// Save the current number of points.
int N = geometry.Count;
int m = 0;
foreach (var pt in points)
{
geometry.AddPoint(pt.X, pt.Y, pt.Boundary, pt.Attributes);
m++;
}
for (int i = 0; i < m; i++)
{
geometry.AddSegment(N + i, N + ((i + 1) % m), mark);
}
}
public static void Triangulate(List <Vector2> vertices, List <IndexedEdge> edges, List <Hole> holes,
ref List <int> indices)
{
indices.Clear();
if (vertices.Count >= 3)
{
InputGeometry inputGeometry = new InputGeometry(vertices.Count);
for (int i = 0; i < vertices.Count; ++i)
{
Vector2 position = vertices[i];
inputGeometry.AddPoint(position.x, position.y);
}
for (int i = 0; i < edges.Count; ++i)
{
IndexedEdge edge = edges[i];
inputGeometry.AddSegment(edge.index1, edge.index2);
}
for (int i = 0; i < holes.Count; ++i)
{
Vector2 hole = holes[i].vertex;
inputGeometry.AddHole(hole.x, hole.y);
}
TriangleNet.Mesh triangleMesh = new TriangleNet.Mesh();
triangleMesh.Triangulate(inputGeometry);
foreach (TriangleNet.Data.Triangle triangle in triangleMesh.Triangles)
{
if (triangle.P0 >= 0 && triangle.P0 < vertices.Count &&
triangle.P0 >= 0 && triangle.P1 < vertices.Count &&
triangle.P0 >= 0 && triangle.P2 < vertices.Count)
{
indices.Add(triangle.P0);
indices.Add(triangle.P2);
indices.Add(triangle.P1);
}
}
}
}
protected override IEnumerable <MonoBehaviour> Create(Tile tile, JSONObject geo)
{
var kind = geo["properties"]["kind"].str.ConvertToWaterType();
var typeSettings = FactorySettings.GetSettingsFor <WaterSettings>(kind);
var go = new GameObject("water");
var water = go.AddComponent <Water>();
var mesh = water.GetComponent <MeshFilter>().mesh;
var md = new MeshData();
SetProperties(geo, water, typeSettings);
foreach (var bb in geo["geometry"]["coordinates"].list)
{
var jo = (bb.list[0].list[0].IsArray) ? bb.list[0] : bb;
var count = jo.list.Count - 1;
if (count < 3)
{
continue;
}
var inp = new InputGeometry(count);
for (int i = 0; i < count; i++)
{
var c = jo.list[i];
var dotMerc = GM.LatLonToMeters(c[1].f, c[0].f);
var localMercPos = dotMerc - tile.Rect.Center;
inp.AddPoint(localMercPos.x, localMercPos.y);
inp.AddSegment(i, (i + 1) % count);
}
CreateMesh(inp, md);
}
mesh.vertices = md.Vertices.ToArray();
mesh.triangles = md.Indices.ToArray();
mesh.SetUVs(0, md.UV);
mesh.RecalculateNormals();
yield return(water);
}
public override void Run(VectorFeatureUnity feature, MeshData md)
{
if (md.Vertices.Distinct().Count() < 3)
{
return;
}
var data = new List <int>();
var _mesh = new TriangleNet.Mesh();
var inp = new InputGeometry(md.Vertices.Count);
for (int i = 0; i < md.Vertices.Count; i++)
{
var v = md.Vertices[i];
inp.AddPoint(v.x, v.z);
inp.AddSegment(i, (i + 1) % md.Vertices.Count);
}
_mesh.Behavior.Algorithm = TriangulationAlgorithm.SweepLine;
_mesh.Behavior.Quality = true;
_mesh.Triangulate(inp);
foreach (var tri in _mesh.Triangles)
{
data.Add(tri.P1);
data.Add(tri.P0);
data.Add(tri.P2);
}
if (_mesh.Vertices.Count != md.Vertices.Count)
{
md.Vertices.Clear();
using (var sequenceEnum = _mesh.Vertices.GetEnumerator())
{
while (sequenceEnum.MoveNext())
{
md.Vertices.Add(new Vector3((float)sequenceEnum.Current.x, 0, (float)sequenceEnum.Current.y));
}
}
}
md.Triangles.Add(data);
}
private InputGeometry Rebuild()
{
InputGeometry inputGeometry = new InputGeometry(this.mesh.vertices.Count);
foreach (Vertex value in this.mesh.vertices.Values)
{
inputGeometry.AddPoint(value.x, value.y, value.mark);
}
foreach (Segment segment in this.mesh.subsegs.Values)
{
inputGeometry.AddSegment(segment.P0, segment.P1, segment.Boundary);
}
foreach (Point hole in this.mesh.holes)
{
inputGeometry.AddHole(hole.x, hole.y);
}
foreach (RegionPointer region in this.mesh.regions)
{
inputGeometry.AddRegion(region.point.x, region.point.y, region.id);
}
return(inputGeometry);
}
public static InputGeometry Generate(int n, double bounds = 10.0)
{
var geometry = new InputGeometry((n + 1) * (n + 1));
double x, y, d = 2 * bounds / n;
int mark = 0;
for (int i = 0; i <= n; i++)
{
y = -bounds + i * d;
for (int j = 0; j <= n; j++)
{
x = -bounds + j * d;
geometry.AddPoint(x, y, mark);
}
}
// Add boundary segments
for (int i = 0; i < n; i++)
{
// Bottom
geometry.AddSegment(i, i + 1);
// Right
geometry.AddSegment(i * (n + 1) + n, (i + 1) * (n + 1) + n);
// Top
geometry.AddSegment(n * (n + 1) + i, n * (n + 1) + (i + 1));
// Left
geometry.AddSegment(i * (n + 1), (i + 1) * (n + 1));
}
return(geometry);
}
private void RunTessellation(List <SampleVertexData> lVerts, MTMeshData.LOD lod)
{
if (lVerts.Count < 3)
{
++curIdx;
return;
}
InputGeometry geometry = new InputGeometry();
for (int i = 0; i < lVerts.Count; i++)
{
geometry.AddPoint(lVerts[i].Position.x, lVerts[i].Position.z, 0);
}
TriangleNet.Mesh meshRepresentation = new TriangleNet.Mesh();
meshRepresentation.Triangulate(geometry);
int vIdx = 0;
lod.vertices = new Vector3[meshRepresentation.Vertices.Count];
lod.normals = new Vector3[meshRepresentation.Vertices.Count];
lod.uvs = new Vector2[meshRepresentation.Vertices.Count];
lod.faces = new int[meshRepresentation.triangles.Count * 3];
foreach (var v in meshRepresentation.Vertices)
{
lod.vertices[vIdx] = new Vector3(v.x, lVerts[vIdx].Position.y, v.y);
lod.normals[vIdx] = lVerts[vIdx].Normal;
lod.uvs[vIdx] = lVerts[vIdx].UV;
++vIdx;
}
vIdx = 0;
foreach (var t in meshRepresentation.triangles.Values)
{
lod.faces[vIdx] = t.P2;
lod.faces[vIdx + 1] = t.P1;
lod.faces[vIdx + 2] = t.P0;
vIdx += 3;
}
}
public override InputGeometry Generate(double param0, double param1, double param2)
{
int numPoints = GetParamValueInt(0, param0);
numPoints = (numPoints / 10) * 10;
if (numPoints < 5)
{
numPoints = 5;
}
InputGeometry input = new InputGeometry(numPoints);
int width = GetParamValueInt(1, param1);
int height = GetParamValueInt(2, param2);
for (int i = 0; i < numPoints; i++)
{
input.AddPoint(Util.Random.NextDouble() * width,
Util.Random.NextDouble() * height);
}
return(input);
}
private List <int> CreateRoofTriangulation(List <Vector3> corners)
{
var data = new List <int>();
var _mesh = new TriangleNet.Mesh();
var inp = new InputGeometry(corners.Count);
for (int i = 0; i < corners.Count; i++)
{
var v = corners[i];
inp.AddPoint(v.x, v.z);
inp.AddSegment(i, (i + 1) % corners.Count);
}
_mesh.Behavior.Algorithm = TriangulationAlgorithm.SweepLine;
_mesh.Behavior.Quality = true;
_mesh.Triangulate(inp);
foreach (var tri in _mesh.Triangles)
{
data.Add(tri.P1);
data.Add(tri.P0);
data.Add(tri.P2);
}
return(data);
}
