fix: Primitive tests.

Author: freezy

VisualPinball.Engine/Math/Vertex3DNoTex2.cs

@@ -122,6 +122,19 @@ public bool Equals(Vertex3DNoTex2 other)
 		{
 			return X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z) && Nx.Equals(other.Nx) && Ny.Equals(other.Ny) && Nz.Equals(other.Nz) && Tu.Equals(other.Tu) && Tv.Equals(other.Tv);
 		}
+
+		public bool Equals(Vertex3DNoTex2 other, int precision)
+		{
+			return Round(X, precision) == Round(other.X, precision)
+			       && Round(Y, precision) == Round(other.Y, precision)
+			       && Round(Z, precision) == Round(other.Z, precision)
+			       && Round(Nx, precision) == Round(other.Nx, precision)
+			       && Round(Ny, precision) == Round(other.Ny, precision)
+			       && Round(Nz, precision) == Round(other.Nz, precision)
+			       && Round(Tu, precision) == Round(other.Tu, precision)
+			       && Round(Tv, precision) == Round(other.Tv, precision);
+		}
+
 		public override bool Equals(object obj)
 		{
 			return obj is Vertex3DNoTex2 other && Equals(other);
@@ -131,5 +144,13 @@ public override int GetHashCode()
 		{
 			return (X, Y, Z, Nx, Ny, Nz, Tu, Tv).GetHashCode();
 		}
+
+		public int GetRoundedHash(int digits) => (
+			Round(X, digits), Round(Y, digits), Round(Z, digits),
+			Round(Nx, digits), Round(Ny, digits), Round(Nz, digits),
+			Round(Tu, digits), Round(Tv, digits)
+		).GetHashCode();
+
+		private static int Round(float value, int digits) => (int)System.Math.Round(value * System.Math.Pow(10, digits));
 	}
 }

VisualPinball.Engine/VPT/Mesh.cs

@@ -494,20 +494,35 @@ public override int GetHashCode()
 
 		#region IEquatable
 
-		public bool Equals(Mesh other)
+		public bool SomewhatEquals(Mesh other, float trianglesToBeMatched, int precision)
 		{
 			if (ReferenceEquals(null, other)) {
 				return false;
 			}
 			if (ReferenceEquals(this, other)) {
 				return true;
 			}
-			if (!Name.Equals(other.Name) || Vertices.Length != other.Vertices.Length
-			                             || Indices.Length != other.Indices.Length
-			                             || AnimationFrames.Count != other.AnimationFrames.Count
-			                             || !AnimationDefaultPosition.Equals(other.AnimationDefaultPosition)) {
+			var triangles1 = IndexTriangles(Vertices, Indices, precision);
+			var triangles2 = IndexTriangles(other.Vertices, other.Indices, precision);
+
+			using var enumerator = triangles1.GetEnumerator();
+			var matched = 0;
+			foreach (var hash in triangles1.Keys) {
+				if (triangles2.ContainsKey(hash)) {
+					matched++;
+				}
+			}
+			return matched / (float)triangles1.Count > trianglesToBeMatched;
+		}
+
+		public bool Equals(Mesh other)
+		{
+			if (ReferenceEquals(null, other)) {
 				return false;
 			}
+			if (ReferenceEquals(this, other)) {
+				return true;
+			}
 
 			for (var i = 0; i < Vertices.Length; i++) {
 				if (!Vertices[i].Equals(other.Vertices[i])) {
@@ -532,6 +547,43 @@ public bool Equals(Mesh other)
 			return true;
 		}
 
+		private Vertex3DNoTex2[] Find(IEnumerable<Vertex3DNoTex2> vertices, Vertex3DNoTex2 vertex, int precision)
+		{
+			return vertices.Where(v => v.Equals(vertex, precision)).ToArray();
+		}
+
+		private static Dictionary<int, Vertex3DNoTex2[]> IndexTriangles(IReadOnlyList<Vertex3DNoTex2> vertices, IReadOnlyList<int> indices, int precision)
+		{
+			var triangles = new Dictionary<int, Vertex3DNoTex2[]>();
+			for (var i = 0; i < indices.Count; i += 3) {
+				var hash = HashTriangle(Sort(
+					vertices[indices[i]],
+					vertices[indices[i + 1]],
+					vertices[indices[i + 2]]
+				), precision);
+				triangles.Add(hash, new [] { vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]] });
+			}
+			return triangles;
+		}
+
+		private static Vertex3DNoTex2[] Sort(params Vertex3DNoTex2[] vertices)
+		{
+			var firstVertex = vertices
+				.OrderBy(s => s.X).ThenBy(s => s.Y).ThenBy(s => s.Z)
+				.ThenBy(s => s.Nx).ThenBy(s => s.Ny).ThenBy(s => s.Nz)
+				.ThenBy(s => s.Tu).ThenBy(s => s.Tv)
+				.First();
+			var firstVertexIndex = Array.IndexOf(vertices, firstVertex);
+			return new[] {
+				vertices[firstVertexIndex],
+				vertices[(firstVertexIndex + 1) % 3],
+				vertices[(firstVertexIndex + 2) % 3]
+			};
+		}
+
+		private static int HashTriangle(IReadOnlyList<Vertex3DNoTex2> vertices, int precision)
+			=> (vertices[0].GetRoundedHash(precision), vertices[1].GetRoundedHash(precision), vertices[2].GetRoundedHash(precision)).GetHashCode();
+
 		public override bool Equals(object obj)
 		{
 			if (ReferenceEquals(null, obj)) {

VisualPinball.Unity/VisualPinball.Unity.Test/VPT/PrimitiveTests.cs

@@ -57,7 +57,7 @@ public void ShouldWriteImportedMesh()
 			var table = FileTableContainer.Load(VpxPath.Primitive);
 			var originalMesh = table.Primitive(primitiveName).GetMesh();
 
-			Assert.AreEqual(originalMesh, writtenMesh);
+			Assert.IsTrue(originalMesh.SomewhatEquals(writtenMesh, 0.9f, 4));
 
 			File.Delete(tmpFileName);
 			Object.DestroyImmediate(go);

VisualPinball.Unity/VisualPinball.Unity/VPT/Primitive/PrimitiveComponent.cs

@@ -196,6 +196,8 @@ public override PrimitiveData CopyDataTo(PrimitiveData data, string[] materialNa
 					var mf = GetComponent<MeshFilter>();
 					if (mf) {
 						data.Mesh = mf.sharedMesh.ToVpMesh();
+						data.NumIndices = data.Mesh.Indices.Length;
+						data.NumVertices = data.Mesh.Vertices.Length;
 					}
 				}
 			}