some more structs.

Author: LoneWandererProductions

CommonControls.Images/ColorPicker.xaml.cs

@@ -48,7 +48,7 @@ public sealed partial class ColorPicker : INotifyPropertyChanged
         public event PropertyChangedEventHandler? PropertyChanged;
 
         /// <summary>
-        /// 
+        ///
         /// </summary>
         /// <param name="colorHsv">The color HSV.</param>
         public delegate void DelegateColor(ColorHsv colorHsv);

CoreBuilder/Rules/UnusedClassAnalyzer.cs

@@ -25,7 +25,7 @@ namespace CoreBuilder.Rules
     /// Analyzer that detects unused classes across a project.
     /// Works by scanning all files for class declarations and then checking
     /// whether those classes are referenced anywhere else in the project.
-    /// 
+    ///
     /// Limitations:
     /// - Simple regex approach (not a full C# parser).
     /// - May flag false positives if a class is used via reflection or dynamically.

CoreBuilder/Rules/UnusedConstantAnalyzer.cs

@@ -25,7 +25,7 @@ namespace CoreBuilder.Rules
     /// Analyzer that detects unused constants and static readonly fields.
     /// Works by scanning all files for declarations and then checking
     /// whether those constants are referenced anywhere else in the project.
-    /// 
+    ///
     /// Limitations:
     /// - Simple regex approach (not a full C# parser).
     /// - May flag false positives if a constant is used via reflection, nameof(), etc.

DataFormatter/TertiaryFace.cs

@@ -16,7 +16,7 @@ namespace DataFormatter
     /// <summary>
     ///     Plot file for the vectors
     /// </summary>
-    public sealed class TertiaryFace
+    public readonly struct TertiaryFace
     {
         /// <summary>
         ///     Gets the x.

DataFormatter/TertiaryVector.cs

@@ -16,7 +16,7 @@ namespace DataFormatter
     /// <summary>
     ///     Three Numbers, here it will describe a 3dimensional Vector
     /// </summary>
-    public sealed class TertiaryVector
+    public readonly struct TertiaryVector
     {
         /// <summary>
         ///     Initializes a new instance of the <see cref="TertiaryVector" /> class.

Imaging/ImagingResources.cs

@@ -363,7 +363,7 @@ public static class ImagingResources
         /// <summary>
         ///     The File Appendix
         /// </summary>
-        public static readonly List<string> Appendix = 
+        public static readonly List<string> Appendix =
 
         [
             JpgExt,

Mathematics/Fraction.cs

@@ -159,7 +159,7 @@ public Fraction(int wholeNumber, int numerator, int denominator)
 
         /// <summary>
         /// Indicates whether the current object is equal to another object of the same type.
-        /// Because our constructor automatically reduces fractions (e.g., 2/4 becomes 1/2), 
+        /// Because our constructor automatically reduces fractions (e.g., 2/4 becomes 1/2),
         /// two equal fractions will ALWAYS have the exact same Numerator and Denominator.
         /// </summary>
         /// <param name="other">An object to compare with this object.</param>
@@ -181,7 +181,7 @@ public Fraction(int wholeNumber, int numerator, int denominator)
         /// Returns a hash code for this instance.
         /// </summary>
         /// <returns>
-        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
         /// </returns>
         public override int GetHashCode() => HashCode.Combine(Numerator, Denominator);
 

Mathematics/PolyTriangle.cs

@@ -13,36 +13,63 @@
 
 namespace Mathematics
 {
-    /// <inheritdoc />
     /// <summary>
-    ///     In the future will be retooled to polygons.
+    ///     Helper Object to handle the description of a 3D object.
+    ///     Supports triangles and larger polygons.
     /// </summary>
     public sealed class PolyTriangle : IEquatable<PolyTriangle>
     {
         /// <summary>
-        ///     Initializes a new instance of the <see cref="PolyTriangle" /> class.
+        /// Gets the vertices.
+        /// </summary>
+        /// <value>
+        /// The vertices.
+        /// </value>
+        public Vector3D[] Vertices { get; }
+
+        /// <summary>
+        /// Gets the vertex count.
+        /// </summary>
+        /// <value>
+        /// The vertex count.
+        /// </value>
+        public int VertexCount => Vertices.Length;
+
+        /// <summary>
+        /// Initializes a new instance for a generic polygon (N-gon).
         /// </summary>
         /// <param name="array">The array.</param>
         public PolyTriangle(IReadOnlyList<Vector3D> array)
         {
             Vertices = new Vector3D[array.Count];
-
             for (var i = 0; i < array.Count; i++)
             {
                 Vertices[i] = array[i];
             }
         }
 
         /// <summary>
-        ///     Gets the normal.
+        ///     HIGH PERFORMANCE CONSTRUCTOR: Specifically for standard Triangles.
+        ///     Prevents double heap-allocation of temporary arrays.
+        /// </summary>
+        public PolyTriangle(Vector3D v1, Vector3D v2, Vector3D v3)
+        {
+            Vertices = new[] { v1, v2, v3 };
+        }
+
+        /// <summary>
+        /// Gets the normal of the polygon.
         /// </summary>
         /// <value>
-        ///     The normal.
+        /// The normal.
         /// </value>
         public Vector3D Normal
         {
             get
             {
+                // Safety check: A line or point doesn't have a 3D normal
+                if (VertexCount < 3) return Vector3D.ZeroVector;
+
                 var u = Vertices[1] - Vertices[0];
                 var v = Vertices[2] - Vertices[0];
 
@@ -51,94 +78,38 @@ public Vector3D Normal
         }
 
         /// <summary>
-        ///     Gets the vertex count.
+        /// Gets or sets the <see cref="Vector3D"/> with the specified i.
         /// </summary>
         /// <value>
-        ///     The vertex count.
-        /// </value>
-        public int VertexCount => Vertices.Length;
-
-        /// <summary>
-        ///     Gets or sets the vertices.
-        /// </summary>
-        /// <value>
-        ///     The vertices.
-        /// </value>
-        public Vector3D[] Vertices { get; }
-
-        /// <summary>
-        ///     Gets or sets the <see cref="Vector3D" /> with the specified i.
-        /// </summary>
-        /// <value>
-        ///     The <see cref="Vector3D" />.
+        /// The <see cref="Vector3D"/>.
         /// </value>
         /// <param name="i">The i.</param>
-        /// <returns>vector by id</returns>
+        /// <returns></returns>
         public Vector3D this[int i]
         {
             get => Vertices[i];
             set => Vertices[i] = value;
         }
 
         /// <summary>
-        ///     Indicates whether the current object is equal to another object of the same type.
-        /// </summary>
-        /// <param name="other">An object to compare with this object.</param>
-        /// <returns>
-        ///     <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise,
-        ///     <see langword="false" />.
-        /// </returns>
-        public bool Equals(PolyTriangle other)
-        {
-            // If the other object is null, return false
-            if (other == null)
-            {
-                return false;
-            }
-
-            // If the other object is the same instance as this object, return true
-            if (ReferenceEquals(this, other))
-            {
-                return true;
-            }
-
-            // If the number of vertices is different, the triangles are not equal
-            if (VertexCount != other.VertexCount)
-            {
-                return false;
-            }
-
-            // Compare each vertex of the triangles
-            for (var i = 0; i < VertexCount; i++)
-            {
-                if (Vertices[i] != other.Vertices[i])
-                {
-                    return false;
-                }
-            }
-
-            // If all vertices are equal, the triangles are equal
-            return true;
-        }
-
-        /// <summary>
-        ///     Creates the triangle set.
-        ///     Triangles need to be supplied on a CLOCKWISE order
+        /// Creates the triangle set from a raw list of vertices.
+        /// Triangles need to be supplied in a CLOCKWISE order.
         /// </summary>
         /// <param name="triangles">The triangles.</param>
-        /// <returns>A list with Triangles, three Vectors in one Object</returns>
+        /// <returns>List of Poly Triangles.</returns>
         public static List<PolyTriangle> CreateTri(List<TertiaryVector> triangles)
         {
-            var polygons = new List<PolyTriangle>();
+            // Pre-allocate list capacity for a slight performance boost
+            var polygons = new List<PolyTriangle>(triangles.Count / 3);
 
             for (var i = 0; i <= triangles.Count - 3; i += 3)
             {
-                var v1 = triangles[i];
-                var v2 = triangles[i + 1];
-                var v3 = triangles[i + 2];
-
-                var array = new[] { (Vector3D)v1, (Vector3D)v2, (Vector3D)v3 };
-                var tri = new PolyTriangle(array);
+                // Use the new highly optimized constructor directly
+                var tri = new PolyTriangle(
+                    (Vector3D)triangles[i],
+                    (Vector3D)triangles[i + 1],
+                    (Vector3D)triangles[i + 2]
+                );
 
                 polygons.Add(tri);
             }
@@ -147,93 +118,98 @@ public static List<PolyTriangle> CreateTri(List<TertiaryVector> triangles)
         }
 
         /// <summary>
-        ///     Gets the plot point.
+        /// Gets the plot point.
         /// </summary>
         /// <param name="id">The identifier.</param>
-        /// <returns>2d Vector, we only need these anyways for drawing.</returns>
+        /// <returns></returns>
         public Vector2D GetPlotPoint(int id)
         {
-            if (id >= VertexCount || id < 0)
-            {
-                return Vector2D.ZeroVector;
-            }
+            if (id >= VertexCount || id < 0) return Vector2D.ZeroVector;
+
             return (Vector2D)Vertices[id];
         }
 
-        /// <summary>
-        ///     Returns a hash code for this instance.
-        /// </summary>
-        /// <returns>
-        ///     A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
-        /// </returns>
-        public override int GetHashCode()
-        {
-            return Vertices[0].GetHashCode();
-        }
 
         /// <summary>
-        ///     Converts to string.
+        /// Indicates whether the current object is equal to another object of the same type.
         /// </summary>
+        /// <param name="other">An object to compare with this object.</param>
         /// <returns>
-        ///     A <see cref="string" /> that represents this instance.
+        ///   <see langword="true" /> if the current object is equal to the <paramref name="other" /> parameter; otherwise, <see langword="false" />.
         /// </returns>
-        public override string ToString()
+        public bool Equals(PolyTriangle other)
         {
-            var sb = new StringBuilder();
-            for (var i = 0; i < Vertices.Length; i++)
+            if (other is null) return false;
+            if (ReferenceEquals(this, other)) return true;
+            if (VertexCount != other.VertexCount) return false;
+
+            for (var i = 0; i < VertexCount; i++)
             {
-                sb.Append(i).Append(MathResources.Separator).Append(Vertices[i]).Append(Environment.NewLine);
+                if (Vertices[i] != other.Vertices[i]) return false;
             }
 
-            return sb.ToString();
+            return true;
         }
 
         /// <summary>
-        ///     Determines whether the specified <see cref="Object" />, is equal to this instance.
+        /// Determines whether the specified <see cref="System.Object" />, is equal to this instance.
         /// </summary>
-        /// <param name="obj">The <see cref="Object" /> to compare with this instance.</param>
+        /// <param name="obj">The <see cref="System.Object" /> to compare with this instance.</param>
         /// <returns>
-        ///     <c>true</c> if the specified <see cref="Object" /> is equal to this instance; otherwise, <c>false</c>.
+        ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
         /// </returns>
-        public override bool Equals(object obj)
-        {
-            return obj is PolyTriangle other && Equals(other);
-        }
+        public override bool Equals(object obj) => obj is PolyTriangle other && Equals(other);
 
         /// <summary>
-        ///     Implements the operator ==.
+        /// Returns a hash code for this instance.
         /// </summary>
-        /// <param name="first">The first.</param>
-        /// <param name="second">The second.</param>
         /// <returns>
-        ///     The result of the operator.
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table.
         /// </returns>
-        public static bool operator ==(PolyTriangle first, PolyTriangle second)
+        public override int GetHashCode()
         {
-            if (first is null && second is null)
-            {
-                return true;
-            }
-
-            if (first is null || second is null)
-            {
-                return false;
-            }
+            // Safely combine the hashes of up to the first 3 vertices 
+            // to drastically reduce hash collisions for connected geometry.
+            if (VertexCount >= 3)
+                return HashCode.Combine(Vertices[0], Vertices[1], Vertices[2]);
+            if (VertexCount == 2)
+                return HashCode.Combine(Vertices[0], Vertices[1]);
+            if (VertexCount == 1)
+                return Vertices[0].GetHashCode();
+
+            return 0;
+        }
 
+        public static bool operator ==(PolyTriangle first, PolyTriangle second)
+        {
+            if (first is null) return second is null;
             return first.Equals(second);
         }
 
         /// <summary>
-        ///     Implements the operator !=.
+        /// Implements the operator !=.
         /// </summary>
         /// <param name="first">The first.</param>
         /// <param name="second">The second.</param>
         /// <returns>
-        ///     The result of the operator.
+        /// The result of the operator.
         /// </returns>
-        public static bool operator !=(PolyTriangle first, PolyTriangle second)
+        public static bool operator !=(PolyTriangle first, PolyTriangle second) => !(first == second);
+
+        /// <summary>
+        /// Converts to string.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="System.String" /> that represents this instance.
+        /// </returns>
+        public override string ToString()
         {
-            return !(first == second);
+            var sb = new StringBuilder();
+            for (var i = 0; i < Vertices.Length; i++)
+            {
+                sb.Append(i).Append(MathResources.Separator).Append(Vertices[i]).Append(Environment.NewLine);
+            }
+            return sb.ToString();
         }
     }
 }