public bool BorderContainsXZ(Vector3 vPoint, out Vertex P, out Vertex Q)
{
// Check AB
if (GeometryToolbox.IsOverSegment(vPoint, mA.mvPos, mB.mvPos))
{
P = mA;
Q = mB;
return true;
}
// Check AC
if (GeometryToolbox.IsOverSegment(vPoint, mA.mvPos, mC.mvPos))
{
P = mA;
Q = mC;
return true;
}
// Check BC
if (GeometryToolbox.IsOverSegment(vPoint, mB.mvPos, mC.mvPos))
{
P = mB;
Q = mC;
return true;
}
P = null;
Q = null;
return false;
}
// Constructor to clone existing mesh
public CustomMesh(MeshFilter meshFilterOriginal)
{
// Retrieve data from original mesh
Vector3[] aVertices = meshFilterOriginal.mesh.vertices;
Vector2[] aUV = meshFilterOriginal.mesh.uv;
int[] aTriangles = meshFilterOriginal.mesh.triangles;
// Copy vertices
mlVertices = new List<Vertex>();
for (int i = 0; i < aVertices.Length; i++)
{
Vertex vertex = new Vertex(mlVertices.Count);
vertex.mvPos = aVertices[i];
vertex.mvUV = aUV[i];
#if UNITY_EDITOR
vertex.DEBUG_INFO = "Vertex from original mesh";
#endif
mlVertices.Add(vertex);
}
// Copy triangles
mlTriangles = new List<Triangle>();
for (int i = 0; i < aTriangles.Length; i += 3)
{
Vertex A = mlVertices[aTriangles[i]];
Vertex B = mlVertices[aTriangles[i + 1]];
Vertex C = mlVertices[aTriangles[i + 2]];
AddTriangle(A, B, C);
}
}
public Triangle(Vertex A, Vertex B, Vertex C, int i)
{
mA = A;
mB = B;
mC = C;
miIndex = i;
mfXMin = Mathf.Min(mA.mvPos.x, mB.mvPos.x, mC.mvPos.x);
mfXMax = Mathf.Max(mA.mvPos.x, mB.mvPos.x, mC.mvPos.x);
mfZMin = Mathf.Min(mA.mvPos.z, mB.mvPos.z, mC.mvPos.z);
mfZMax = Mathf.Max(mA.mvPos.z, mB.mvPos.z, mC.mvPos.z);
mvXZNormalA = new Vector3(mA.mvPos.z - mC.mvPos.z, 0.0f, mC.mvPos.x - mA.mvPos.x);
mvXZNormalB = new Vector3(mB.mvPos.z - mA.mvPos.z, 0.0f, mA.mvPos.x - mB.mvPos.x);
mvXZNormalC = new Vector3(mC.mvPos.z - mB.mvPos.z, 0.0f, mB.mvPos.x - mC.mvPos.x);
}
public override Triangle AddTriangle(Vertex A, Vertex B, Vertex C, bool bInverted = false)
{
if (bInverted)
{
return AddTriangle(A, C, B);
}
Triangle triangle = new Triangle(A, B, C, mlTriangles.Count);
mlTriangles.Add(triangle);
// The following three lines are the very reason CustomMeshInterlinked exists
// We don't need this in most meshes, only when we want to do a PunchOut operation.
// Also, it requires unnecessary CPU time and memory, which may lead to a nasty crash in iOS due to a UNITY bug.
A.mlAdjacentTriangles.Add(triangle);
B.mlAdjacentTriangles.Add(triangle);
C.mlAdjacentTriangles.Add(triangle);
return triangle;
}
// Constructor to clone existing custom mesh
public CustomMesh(CustomMesh customMeshOriginal)
{
// Copy vertices
mlVertices = new List<Vertex>();
for (int i = 0; i < customMeshOriginal.mlVertices.Count; i++)
{
Vertex vertex = new Vertex(mlVertices.Count);
vertex.mvPos = customMeshOriginal.mlVertices[i].mvPos;
vertex.mvUV = customMeshOriginal.mlVertices[i].mvUV;
mlVertices.Add(vertex);
}
// Copy triangles
mlTriangles = new List<Triangle>();
for (int i = 0; i < customMeshOriginal.mlTriangles.Count; i += 3)
{
Triangle originalTriangle = customMeshOriginal.mlTriangles[i];
Vertex A = AddVertex(originalTriangle.mA);
Vertex B = AddVertex(originalTriangle.mB);
Vertex C = AddVertex(originalTriangle.mC);
AddTriangle(A, B, C);
}
}
public Triangle GetAdjacentTriangleInDirection(Vector3 vDirection, out Vertex neighbour1, out Vertex neighbour2)
{
vDirection.y = 0.0f;
Vector3 vNormal = new Vector3(vDirection.z, 0.0f, -vDirection.x);
foreach (Triangle triangle in mlAdjacentTriangles)
{
if (triangle == null)
{
continue;
}
// Which are the neighbor points ?
if (this == triangle.mA)
{
neighbour1 = triangle.mB;
neighbour2 = triangle.mC;
}
else if (this == triangle.mB)
{
neighbour1 = triangle.mC;
neighbour2 = triangle.mA;
}
else // this == triangle.mC
{
neighbour1 = triangle.mA;
neighbour2 = triangle.mB;
// Note that we don't risk to overwrite the right neighbors, as we return as soon as we have found the right ones.
}
// Compute the two "arms" parting from this point
Vector3 vArm1 = (neighbour1.mvPos - mvPos);
Vector3 vArm2 = (neighbour2.mvPos - mvPos);
// Flatten and normalize
vArm1.y = 0.0f;
vArm1.Normalize();
vArm2.y = 0.0f;
vArm2.Normalize();
// Is the vector on the right halfplane?
// Are the two arms on different sides of the vector?
// (The latter ones means that Dot( vNormal, vArm1) has a different sign than Dot( vNormal, vArmZ). In other words, their product is < 0. We include the case "=0" out of kindness.)
if (Vector3.Dot(vDirection, vArm1 + vArm2) > 0
&& Vector3.Dot(vNormal, vArm1) * Vector3.Dot(vNormal, vArm2) <= 0)
{
// We have found the correct triangle
if (neighbour1 == neighbour2)
{
Debug.LogError("neighbour1 == neighbour2");
}
else if (neighbour1.mvPos == neighbour2.mvPos)
{
Debug.LogError("neighbour1.mvPos == neighbour2.mvPos");
}
if (Vector3.Dot(vNormal, vArm1) < 0)
{
Vertex temp = neighbour1;
neighbour1 = neighbour2;
neighbour2 = temp;
}
return triangle;
}
}
// Sorry, nothing found
neighbour1 = null;
neighbour2 = null;
return null;
}
public bool IsNeighbourOf(Vertex vOtherVertex)
{
foreach (Triangle triangle in mlAdjacentTriangles)
{
if (vOtherVertex == triangle.mA || vOtherVertex == triangle.mB || vOtherVertex == triangle.mC)
{
return true;
}
}
return false;
}
public Vertex AddVertex(Vertex original)
{
Vertex vertex = new Vertex(original.mvPos, mlVertices.Count);
mlVertices.Add(vertex);
return vertex;
}
public Vertex AddVertex(Vector3 vPosition)
{
Vertex vertex = new Vertex(vPosition, mlVertices.Count);
mlVertices.Add(vertex);
return vertex;
}
public Vertex AddVertex()
{
Vertex vertex = new Vertex(mlVertices.Count);
mlVertices.Add(vertex);
return vertex;
}
public virtual Triangle AddTriangle(Vertex A, Vertex B, Vertex C, bool bInverted = false)
{
if (bInverted)
{
return AddTriangle(A, C, B);
}
Triangle triangle = new Triangle(A, B, C, mlTriangles.Count);
mlTriangles.Add(triangle);
return triangle;
}
public void AddQuadrangle(Vertex A, Vertex B, Vertex C, Vertex D, bool bInverted = false)
{
AddTriangle(A, B, C, bInverted);
AddTriangle(A, C, D, bInverted);
}
public Triangle GetNeighbourTriangleBehind(Vertex P, Vertex Q)
{
foreach (Triangle triangle in P.mlAdjacentTriangles)
{
if (triangle != this && triangle.HasCorner(Q))
{
return triangle;
}
}
return null;
}
public bool HasCorner(Vertex P)
{
return (P == mA || P == mB || P == mC);
}
public Vertex GetThirdCorner(Vertex notThisOne, Vertex notThisOneEither)
{
if (notThisOne == mA)
{
if (notThisOneEither == mB)
{
return mC;
}
else
{
return mB;
}
}
else if (notThisOne == mB)
{
if (notThisOneEither == mA)
{
return mC;
}
else
{
return mA;
}
}
else // notThisOne == mC
{
if (notThisOneEither == mB)
{
return mA;
}
else
{
return mB;
}
}
}
