public override void Start()
{
base.Start();
verticesDraggablesTopDown = GetComponent <VerticesDraggablesTopDown> ();
polygonCreator = GetComponent <PolygonCreator> ();
OnVerticesChangeState(false);
}
public AddPolygonMode(List <Shape> Shapes, PictureBox canvas, Color vertexColor, Color sideColor)
: base(Shapes, canvas)
{
_vertexColor = vertexColor;
_sideColor = sideColor;
_currentPolygon = new PolygonCreator(_vertexColor, _sideColor);
}
public void Init()
{
polygonCreator = GetComponent <PolygonCreator> ();
verticeTop.SetFace(VerticeTopDown.faces.TOP);
verticeBottom.SetFace(VerticeTopDown.faces.BOTTOM);
verticeTop.transform.localPosition = polygonCreator.GetCenter(true);
verticeBottom.transform.localPosition = polygonCreator.GetCenter(false);
}
public void ShouldCreatePolygon()
{
var polygonCreator = new PolygonCreator();
var bottomLeft = new { Lat = 49.156411, Lon = -2.256576 };
var upperRight = new { Lat = 49.262943, Lon = -2.012237 };
var polygon = polygonCreator.FromBox(bottomLeft.Lat, bottomLeft.Lon, upperRight.Lat, upperRight.Lon);
polygon.Should().BeEquivalentTo(new[, ]
{
{ bottomLeft.Lon, bottomLeft.Lat },
{ upperRight.Lon, bottomLeft.Lat },
{ upperRight.Lon, upperRight.Lat },
{ bottomLeft.Lon, upperRight.Lat },
{ bottomLeft.Lon, bottomLeft.Lat },
});
}
void UpdatePolygon()
{
Vector2[] vertices2D = new Vector2[verticesAnglesManager.all.Count];
for (int a = 0; a < verticesAnglesManager.all.Count - 1; a++)
{
vertices2D[a] = verticesAnglesManager.all[a].transform.position;
}
if (polygonCreated != null)
{
polygonCreated.DeleteAll();
}
polygonCreated = Instantiate(polygonCreator, transform);
polygonCreated.Init(vertices2D);
}
private void _ProcessAddingPointD(PointD clickedPoint)
{
if (_currentPolygon.NumberOfVertices == 0)
{
_StartCreatingNewPolygon(clickedPoint);
}
else
{
_AddNewPointToPolygon(clickedPoint);
}
if (_currentPolygon.IsComplete())
{
_currentPolygon = new PolygonCreator(_vertexColor, _sideColor);
}
}
private void CreateRoadModels()
{
foreach (var rn in RoadNodes)
{
if (rn.HasAnyConnections)
{
PolygonCreator.CreatePolygon(new Vector3[] { rn.ModelVertices[0], rn.ModelVertices[1], rn.ModelVertices[3], rn.ModelVertices[2] }, roadNetworkParent, roadMaterial);
if (rn.Up_connection && rn.Up_connection.ActiveConnection)
{
PolygonCreator.CreatePolygon(new Vector3[] { rn.ModelVertices[0], rn.Up_connection.ConnectedNode.ModelVertices[2], rn.Up_connection.ConnectedNode.ModelVertices[3] }, roadNetworkParent, roadMaterial);
PolygonCreator.CreatePolygon(new Vector3[] { rn.Up_connection.ConnectedNode.ModelVertices[3], rn.ModelVertices[1], rn.ModelVertices[0] }, roadNetworkParent, roadMaterial);
}
if (rn.Right_connection && rn.Right_connection.ActiveConnection)
{
PolygonCreator.CreatePolygon(new Vector3[] { rn.ModelVertices[3], rn.ModelVertices[1], rn.Right_connection.ConnectedNode.ModelVertices[0] }, roadNetworkParent, roadMaterial);
PolygonCreator.CreatePolygon(new Vector3[] { rn.ModelVertices[3], rn.Right_connection.ConnectedNode.ModelVertices[0], rn.Right_connection.ConnectedNode.ModelVertices[2] }, roadNetworkParent, roadMaterial);
}
}
}
}
public string RenderingShapeTypeName()
{
return(PolygonCreator.getInstance().ShapeTypeName());
}
private void GenerateCurbs()
{
foreach (var rn in roadNodes)
{
if (rn.Up_connection && rn.Right_connection)
{
if (rn.Up_connection.ActiveConnection == false)
{
Vector3[] polygon = new Vector3[4]
{
rn.ModelVertices[0],
rn.Up_connection.ConnectedNode.ModelVertices[2],
rn.Up_connection.ConnectedNode.ModelVertices[3],
rn.ModelVertices[1],
};
PolygonCreator.ExtrudePolygon(polygon, curbHeight, curbsParent, curbFiller);
PolygonCreator.CreatePolygon(polygon, curbsParent, curbMaterial, 0.0f, curbHeight);
}
if (rn.Right_connection.ActiveConnection == false)
{
Vector3[] polygon = new Vector3[4]
{
rn.ModelVertices[1],
rn.Right_connection.ConnectedNode.ModelVertices[0],
rn.Right_connection.ConnectedNode.ModelVertices[2],
rn.ModelVertices[3]
};
PolygonCreator.ExtrudePolygon(polygon, curbHeight, curbsParent, curbFiller);
PolygonCreator.CreatePolygon(polygon, curbsParent, curbMaterial, 0.0f, curbHeight);
}
Vector3[] openAreaPolygon = new Vector3[4]
{
rn.ModelVertices[1],
rn.Up_connection.ConnectedNode.ModelVertices[3],
rn.Up_connection.ConnectedNode.Right_connection.ConnectedNode.ModelVertices[2],
rn.Right_connection.ConnectedNode.ModelVertices[0],
};
PolygonCreator.ExtrudePolygon(openAreaPolygon, curbHeight, curbsParent, curbFiller);
if (rn.IsPark == false)
{
PolygonCreator.CreatePolygon(openAreaPolygon, curbsParent, curbMaterial, 0.0f, curbHeight);
}
else
{
Vector3[] insetOpenAreaPolygon = PolygonCreator.InsetPolygon(openAreaPolygon, curbWidth);
PolygonCreator.ExtrudePolygon(insetOpenAreaPolygon, curbHeight, curbsParent, curbFiller, true);
PolygonCreator.CreatePolygon(insetOpenAreaPolygon, parksParent, grassMaterial);
PolygonCreator.CreatePolygon(new Vector3[] { openAreaPolygon[0], openAreaPolygon[1], insetOpenAreaPolygon[1], insetOpenAreaPolygon[0] }, curbsParent, curbMaterial, 0.0f, curbHeight);
PolygonCreator.CreatePolygon(new Vector3[] { openAreaPolygon[1], openAreaPolygon[2], insetOpenAreaPolygon[2], insetOpenAreaPolygon[1] }, curbsParent, curbMaterial, 0.0f, curbHeight);
PolygonCreator.CreatePolygon(new Vector3[] { openAreaPolygon[2], openAreaPolygon[3], insetOpenAreaPolygon[3], insetOpenAreaPolygon[2] }, curbsParent, curbMaterial, 0.0f, curbHeight);
PolygonCreator.CreatePolygon(new Vector3[] { openAreaPolygon[3], openAreaPolygon[0], insetOpenAreaPolygon[0], insetOpenAreaPolygon[3] }, curbsParent, curbMaterial, 0.0f, curbHeight);
}
}
if (rn.HasAnyConnections == false)
{
PolygonCreator.CreatePolygon(new Vector3[] { rn.ModelVertices[0], rn.ModelVertices[1], rn.ModelVertices[3], rn.ModelVertices[2] }, curbsParent, curbMaterial, 0.0f, curbHeight);
}
}
}
private void GenerateStreetLamps()
{
Transform parent = new GameObject("StreetLamps", typeof(MeshCombiner)).transform;
parent.parent = decorationsParent;
float lampsInset = 0.5f;
foreach (var rn in roadNodes)
{
if (rn.Up_connection && rn.Up_connection.ActiveConnection)
{
int lampsCount = Random.Range(minMaxLampsPerRoad.x, minMaxLampsPerRoad.y + 1);
(Vector3, Vector3)fromTo_02 = (rn.ModelVertices[0], rn.Up_connection.ConnectedNode.ModelVertices[2]);
(Vector3, Vector3)fromTo_13 = (rn.ModelVertices[1], rn.Up_connection.ConnectedNode.ModelVertices[3]);
Vector3 tangent_02 = (fromTo_02.Item2 - fromTo_02.Item1).normalized;
Vector3 normal_02 = Quaternion.Euler(0, -90.0f, 0) * tangent_02;
Vector3 tangent_13 = (fromTo_13.Item2 - fromTo_13.Item1).normalized;
Vector3 normal_13 = Quaternion.Euler(0, 90.0f, 0) * tangent_13;
Vector3[] lampPositions_02 = PolygonCreator.DivideSide(fromTo_02.Item1, fromTo_02.Item2, lampsCount);
Vector3[] lampPositions_13 = PolygonCreator.DivideSide(fromTo_13.Item1, fromTo_13.Item2, lampsCount);
Quaternion rotation_02 = Quaternion.LookRotation(normal_02, Vector3.up);
Quaternion rotation_13 = Quaternion.LookRotation(normal_13, Vector3.up);
for (int i = 1; i < lampPositions_02.Length - 1; i++)
{
Instantiate(streetLamp, lampPositions_02[i] + normal_02 * lampsInset, rotation_02, parent);
}
for (int i = 1; i < lampPositions_13.Length - 1; i++)
{
Instantiate(streetLamp, lampPositions_13[i] + normal_13 * lampsInset, rotation_13, parent);
}
}
if (rn.Right_connection && rn.Right_connection.ActiveConnection)
{
int lampsCount = Random.Range(minMaxLampsPerRoad.x, minMaxLampsPerRoad.y + 1);
(Vector3, Vector3)fromTo_32 = (rn.ModelVertices[3], rn.Right_connection.ConnectedNode.ModelVertices[2]);
(Vector3, Vector3)fromTo_10 = (rn.ModelVertices[1], rn.Right_connection.ConnectedNode.ModelVertices[0]);
Vector3 tangent_32 = (fromTo_32.Item2 - fromTo_32.Item1).normalized;
Vector3 normal_32 = Quaternion.Euler(0, 90.0f, 0) * tangent_32;
Vector3 tangent_10 = (fromTo_10.Item2 - fromTo_10.Item1).normalized;
Vector3 normal_10 = Quaternion.Euler(0, -90.0f, 0) * tangent_10;
Vector3[] lampPositions_32 = PolygonCreator.DivideSide(fromTo_32.Item1, fromTo_32.Item2, lampsCount);
Vector3[] lampPositions_10 = PolygonCreator.DivideSide(fromTo_10.Item1, fromTo_10.Item2, lampsCount);
Quaternion rotation_32 = Quaternion.LookRotation(normal_32, Vector3.up);
Quaternion rotation_10 = Quaternion.LookRotation(normal_10, Vector3.up);
for (int i = 1; i < lampPositions_32.Length - 1; i++)
{
Instantiate(streetLamp, lampPositions_32[i] + normal_32 * lampsInset, rotation_32, parent);
}
for (int i = 1; i < lampPositions_10.Length - 1; i++)
{
Instantiate(streetLamp, lampPositions_10[i] + normal_10 * lampsInset, rotation_10, parent);
}
}
}
parent.GetComponent <MeshCombiner>().CombineMeshes();
}
void Awake()
{
polygon_ = GetComponent <PolygonCreator>();
charge_ = GetComponent <ShotCharge>();
}
private List <SlicedMesh> GenerateMesh(SlicedMesh original, Plane plane, bool positiveSide, Transform objectTransform)
{
SlicedMesh slicePositive = new SlicedMesh();
SlicedMesh sliceNegative = new SlicedMesh();
//polygon we use to fill in the sliced surface
PolygonCreator polygonPositive = new PolygonCreator(objectTransform, plane.normal * -1);
PolygonCreator polygonNegative = new PolygonCreator(objectTransform, plane.normal);
bool matPositiveAdded = false, matNegativeAdded = false;
//we loop over all submeshes
for (int submesh = 0; submesh < original.triangles.Length; submesh++)
{
int[] originalTriangles = original.triangles[submesh];
setEdge = false;
//increase t by 3 because a triangle consist out of 3 vertices;
for (int t = 0; t < originalTriangles.Length; t += 3)
{
//which triangle we need
int t1 = t, t2 = t + 1, t3 = t + 2;
//Check if vertice is on positive side of the plane
bool sideA = plane.GetSide(original.vertices[originalTriangles[t1]]) == positiveSide;
bool sideB = plane.GetSide(original.vertices[originalTriangles[t2]]) == positiveSide;
bool sideC = plane.GetSide(original.vertices[originalTriangles[t3]]) == positiveSide;
//how many vertices are on the positive side of the plane
int sideCount = (sideA ? 1 : 0) +
(sideB ? 1 : 0) +
(sideC ? 1 : 0);
//if none of the vertices is located on the positive side
if (sideCount == 0)
{
//add entire triangle to negative side
sliceNegative.AddTriangle(submesh, original.vertices[originalTriangles[t1]], original.vertices[originalTriangles[t2]], original.vertices[originalTriangles[t3]],
original.normals[originalTriangles[t1]], original.normals[originalTriangles[t2]], original.normals[originalTriangles[t3]],
original.uv[originalTriangles[t1]], original.uv[originalTriangles[t2]], original.uv[originalTriangles[t3]]);
if (!matNegativeAdded)
{
matNegativeAdded = true;
sliceNegative.materialIndex.Add(submesh);
}
continue;
}
//if all the vertices are located on the positive side
else if (sideCount == 3)
{
//add entire triangle to positive side
slicePositive.AddTriangle(submesh, original.vertices[originalTriangles[t1]], original.vertices[originalTriangles[t2]], original.vertices[originalTriangles[t3]],
original.normals[originalTriangles[t1]], original.normals[originalTriangles[t2]], original.normals[originalTriangles[t3]],
original.uv[originalTriangles[t1]], original.uv[originalTriangles[t2]], original.uv[originalTriangles[t3]]);
if (!matPositiveAdded)
{
matPositiveAdded = true;
slicePositive.materialIndex.Add(submesh);
}
continue;
}
//else a triangle is cut and submesh material must be added to both sides
if (!matNegativeAdded)
{
matNegativeAdded = true;
sliceNegative.materialIndex.Add(submesh);
}
if (!matPositiveAdded)
{
matPositiveAdded = true;
slicePositive.materialIndex.Add(submesh);
}
//determines which vertex in the triangle is solely located on one side of the plane
int singleIndex = sideB == sideC ? 0 : sideA == sideC ? 1 : 2;
int indexB = t + ((singleIndex + 1) % 3), indexC = t + ((singleIndex + 2) % 3);
singleIndex += t;
//calculate which vertices/normals/uv should be used to calculate intersection points
Vector3 singleVertex = original.vertices[originalTriangles[singleIndex]],
vertexB = original.vertices[originalTriangles[indexB]], //right vertex
vertexC = original.vertices[originalTriangles[indexC]]; //left vertex
Vector3 singleNormal = original.normals[originalTriangles[singleIndex]],
normalB = original.normals[originalTriangles[indexB]],
normalC = original.normals[originalTriangles[indexC]];
Vector2 singleUv = original.uv[originalTriangles[singleIndex]],
uvB = original.uv[originalTriangles[indexB]],
uvC = original.uv[originalTriangles[indexC]];
//calculate new vertices/normals/uv where edge intersects plane
float lerpB, lerpC;
Vector3 newVertexB = PointOnPlane(plane, singleVertex, vertexB, out lerpB), //new right vertex
newVertexC = PointOnPlane(plane, singleVertex, vertexC, out lerpC); //new left vertex
Vector3 newNormalB = Vector3.Lerp(singleNormal, normalB, lerpB), //lerp to get the point between the old vertices where the new vertex is located
newNormalC = Vector3.Lerp(singleNormal, normalC, lerpC);
Vector2 newUvB = Vector2.Lerp(singleUv, uvB, lerpB),
newUvC = Vector2.Lerp(singleUv, uvC, lerpC);
if (!concave)
{
//add and edge to "fill" the mesh
AddSliceTriangle(submesh, slicePositive, newVertexB, newVertexC,
plane.normal * -1,
newUvB, newUvC);
AddSliceTriangle(submesh, sliceNegative, newVertexB, newVertexC,
plane.normal,
newUvB, newUvC);
}
if (sideCount == 1)
{
//positive data
slicePositive.AddTriangle(submesh, singleVertex, newVertexB, newVertexC, singleNormal, newNormalB, newNormalC, singleUv, newUvB, newUvC);
//negative data
sliceNegative.AddTriangle(submesh, newVertexB, vertexB, vertexC, newNormalB, normalB, normalC, newUvB, uvB, uvC);
sliceNegative.AddTriangle(submesh, newVertexB, vertexC, newVertexC, newNormalB, normalC, newNormalC, newUvB, uvC, newUvC);
if (concave)
{
//positive
Edge edgePositive = new Edge(newVertexB, newVertexC, plane.normal * -1, newUvB, newUvC);
polygonPositive.AddEdge(edgePositive);
//negative
Edge edgeNegative = new Edge(newVertexC, newVertexB, plane.normal, newUvC, newUvB);
polygonNegative.AddEdge(edgeNegative);
}
continue;
}
else if (sideCount == 2)
{
//positive data
slicePositive.AddTriangle(submesh, newVertexB, vertexB, vertexC, newNormalB, normalB, normalC, newUvB, uvB, uvC);
slicePositive.AddTriangle(submesh, newVertexB, vertexC, newVertexC, newNormalB, normalC, newNormalC, newUvB, uvC, newUvC);
//negative data
sliceNegative.AddTriangle(submesh, singleVertex, newVertexB, newVertexC, singleNormal, newNormalB, newNormalC, singleUv, newUvB, newUvC);
if (concave)
{
//positive
Edge edgePositive = new Edge(newVertexC, newVertexB, plane.normal * -1, newUvC, newUvB);
polygonPositive.AddEdge(edgePositive);
//negative
Edge edgeNegative = new Edge(newVertexB, newVertexC, plane.normal, newUvB, newUvC);
polygonNegative.AddEdge(edgeNegative);
}
continue;
}
}
}
if (concave)
{
//build polygons
polygonPositive.ConnectEdges();
polygonNegative.ConnectEdges();
//build meshdata for polygons
FinishedPolygon polygonPositiveFinished = Triangulation.Triangulate(polygonPositive, slicePositive.VertexCount);
FinishedPolygon polygonNegativeFinished = Triangulation.Triangulate(polygonNegative, sliceNegative.VertexCount);
//add meshdata to slices
slicePositive.AddPolygon(polygonPositiveFinished);
sliceNegative.AddPolygon(polygonNegativeFinished);
}
slicePositive.FillArray(correctData);
sliceNegative.FillArray(correctData);
return(new List <SlicedMesh>()
{
slicePositive, sliceNegative
});
}
