From 3c95d6d43e69c75c34ddc35b8612d27bd9b0430c Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 19:10:11 +1000
Subject: [PATCH 01/52] start of 3.0 Silk.Net.Maths rewrite


From 04846e7715fc6cb0e0e5d2107dc8a1da52dda4f3 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 20:27:39 +1000
Subject: [PATCH 02/52] Start work on Vector2I.

---
 .../Maths/Maths/{ => Legacy}/Vector2D.Ops.cs  |  0
 sources/Maths/Maths/{ => Legacy}/Vector2D.cs  |  0
 .../Maths/Maths/{ => Legacy}/Vector3D.Ops.cs  |  0
 sources/Maths/Maths/{ => Legacy}/Vector3D.cs  |  0
 .../Maths/Maths/{ => Legacy}/Vector4D.Ops.cs  |  0
 sources/Maths/Maths/{ => Legacy}/Vector4D.cs  |  0
 sources/Maths/Maths/Vector2I.cs               | 96 +++++++++++++++++++
 7 files changed, 96 insertions(+)
 rename sources/Maths/Maths/{ => Legacy}/Vector2D.Ops.cs (100%)
 rename sources/Maths/Maths/{ => Legacy}/Vector2D.cs (100%)
 rename sources/Maths/Maths/{ => Legacy}/Vector3D.Ops.cs (100%)
 rename sources/Maths/Maths/{ => Legacy}/Vector3D.cs (100%)
 rename sources/Maths/Maths/{ => Legacy}/Vector4D.Ops.cs (100%)
 rename sources/Maths/Maths/{ => Legacy}/Vector4D.cs (100%)
 create mode 100644 sources/Maths/Maths/Vector2I.cs

diff --git a/sources/Maths/Maths/Vector2D.Ops.cs b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
similarity index 100%
rename from sources/Maths/Maths/Vector2D.Ops.cs
rename to sources/Maths/Maths/Legacy/Vector2D.Ops.cs
diff --git a/sources/Maths/Maths/Vector2D.cs b/sources/Maths/Maths/Legacy/Vector2D.cs
similarity index 100%
rename from sources/Maths/Maths/Vector2D.cs
rename to sources/Maths/Maths/Legacy/Vector2D.cs
diff --git a/sources/Maths/Maths/Vector3D.Ops.cs b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
similarity index 100%
rename from sources/Maths/Maths/Vector3D.Ops.cs
rename to sources/Maths/Maths/Legacy/Vector3D.Ops.cs
diff --git a/sources/Maths/Maths/Vector3D.cs b/sources/Maths/Maths/Legacy/Vector3D.cs
similarity index 100%
rename from sources/Maths/Maths/Vector3D.cs
rename to sources/Maths/Maths/Legacy/Vector3D.cs
diff --git a/sources/Maths/Maths/Vector4D.Ops.cs b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
similarity index 100%
rename from sources/Maths/Maths/Vector4D.Ops.cs
rename to sources/Maths/Maths/Legacy/Vector4D.Ops.cs
diff --git a/sources/Maths/Maths/Vector4D.cs b/sources/Maths/Maths/Legacy/Vector4D.cs
similarity index 100%
rename from sources/Maths/Maths/Vector4D.cs
rename to sources/Maths/Maths/Legacy/Vector4D.cs
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
new file mode 100644
index 0000000000..d3fd8fea4b
--- /dev/null
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -0,0 +1,96 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System.Collections;
+using System.Numerics;
+
+namespace Silk.NET.Maths
+{
+    /// <summary>A structure representing a 2D integer vector.</summary>
+    internal struct Vector2I<T> : IEquatable<Vector2I<T>>, IReadOnlyList<T>, ISpanFormattable
+        where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>Creates a vector whose elements have the specified values.</summary>
+        /// <param name="x">The value to assign to the <see cref="X"/> field.</param>
+        /// <param name="y">The value to assign to the <see cref="Y"/> field.</param>
+        public Vector2I(T x, T y) => (X, Y) = (x, y);
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
+        public T this[int index] => index switch {
+            0 => X,
+            1 => Y,
+            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
+        };
+
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 2;
+
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2I{T}"/> instance.</summary>
+        public bool Equals(Vector2I<T> other) => X.Equals(other.X) && Y.Equals(other.Y);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider)
+        {
+            return $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            // Not too sure about this implementation
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            // Calculate total required length: < + x + ", " + y + >
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}

From 7afd57ff1cd8f4b9532ffb1525a8772c3337dc93 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 20:52:29 +1000
Subject: [PATCH 03/52] Finish implementing Vector2I Interfaces.

---
 sources/Maths/Maths/Vector2I.cs | 151 ++++++++++++++++++++++++++++++--
 1 file changed, 143 insertions(+), 8 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index d3fd8fea4b..542193478c 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -3,12 +3,22 @@
 
 
 using System.Collections;
+using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
+using System.Text;
 
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
-    internal struct Vector2I<T> : IEquatable<Vector2I<T>>, IReadOnlyList<T>, ISpanFormattable
+    internal struct Vector2I<T> :
+        IEquatable<Vector2I<T>>,
+        IReadOnlyList<T>,
+        ISpanFormattable,
+        ISpanParsable<Vector2I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2I<T>>,
+        IParsable<Vector2I<T>>,
+        IFormattable
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -17,11 +27,22 @@ internal struct Vector2I<T> : IEquatable<Vector2I<T>>, IReadOnlyList<T>, ISpanFo
         /// <summary>The Y component of the vector.</summary>
         public T Y;
 
-        /// <summary>Creates a vector whose elements have the specified values.</summary>
-        /// <param name="x">The value to assign to the <see cref="X"/> field.</param>
-        /// <param name="y">The value to assign to the <see cref="Y"/> field.</param>
+        /// <summary>Initializes both components to the same value.</summary>
+        public Vector2I(T value) => (X, Y) = (value, value);
+
+        /// <summary>Initializes the vector with individual values for X and Y.</summary>
         public Vector2I(T x, T y) => (X, Y) = (x, y);
 
+        /// <summary>Initializes the vector from a span of two values.</summary>
+        public Vector2I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
         public T this[int index] => index switch {
             0 => X,
@@ -43,10 +64,7 @@ public IEnumerator<T> GetEnumerator()
         }
 
         /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider)
-        {
-            return $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-        }
+        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
 
         /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
         public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
@@ -90,7 +108,124 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
+        /// <summary>Parses a span to a Vector2I instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2I.");
+
+            return result;
+        }
+
+        /// <summary>Parses a string to a Vector2I instance.</summary>
+        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Tries to parse a span to a Vector2I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaIndex = s.IndexOf(',');
+            if (commaIndex < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2I<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+
+        /// <summary>Tries to parse a string to a Vector2I instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a Vector2I instance.</summary>
+        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a Vector2I instance.</summary>
+        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a Vector2I instance.</summary>
+        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a Vector2I instance.</summary>
+        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            // Not too sure about this implementation
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            // Estimate total required UTF-8 bytes
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Parses a UTF-8 span to a Vector2I instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a Vector2I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
     }
 }

From 249be1fc97763f1a6bb48306cf36b629a5fa6273 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 20:55:03 +1000
Subject: [PATCH 04/52] Add Vector2I Unit properties.

---
 sources/Maths/Maths/Vector2I.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 542193478c..e4bca600b4 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -43,6 +43,18 @@ public Vector2I(ReadOnlySpan<T> values)
             Y = values[1];
         }
 
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2I<T> Zero => default;
+
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
         public T this[int index] => index switch {
             0 => X,

From 709c14295d051c3131074189a1f395310c0bb2c4 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 21:10:07 +1000
Subject: [PATCH 05/52] Add Vector3I Maths methods.

---
 sources/Maths/Maths/Vector2I.cs | 99 ++++++++++++++++++++++++++++++++-
 1 file changed, 96 insertions(+), 3 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index e4bca600b4..5d0befb58a 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -5,6 +5,7 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
+using System.Runtime.InteropServices;
 using System.Text;
 
 namespace Silk.NET.Maths
@@ -55,6 +56,12 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
         public static Vector2I<T> Zero => default;
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => (X * X) + (Y * Y);
+
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 2;
+
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
         public T this[int index] => index switch {
             0 => X,
@@ -62,9 +69,6 @@ public Vector2I(ReadOnlySpan<T> values)
             _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
         };
 
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 2;
-
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2I{T}"/> instance.</summary>
         public bool Equals(Vector2I<T> other) => X.Equals(other.X) && Y.Equals(other.Y);
 
@@ -75,9 +79,59 @@ public IEnumerator<T> GetEnumerator()
             yield return Y;
         }
 
+        /// <summary> Computes the dot product of this vector with another vector. </summary>
+        public T Dot(Vector2I<T> other) => (X * other.X) + (Y * other.Y);
+
+        /// <summary> Computes the dot product of two vectors. </summary>
+        public static T Dot(Vector2I<T> left, Vector2I<T> right) => (left.X * right.X) + (left.Y * right.Y);
+
+        /// <summary> Computes the cross product of this vector with another vector. </summary>
+        public T Cross(Vector2I<T> other) => (X * other.Y) - (Y * other.X);
+
+        /// <summary> Computes the cross product of two vectors. </summary>
+        public static T Cross(Vector2I<T> left, Vector2I<T> right) => (left.X * right.Y) - (left.Y * right.X);
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
+        public Vector2I<T> Max(Vector2I<T> other) =>
+            new Vector2I<T>(T.Max(X, other.X), T.Max(Y, other.Y));
+
+        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
+        public static Vector2I<T> Max(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y));
+
+        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
+        public Vector2I<T> Max(T scalar) =>
+            new Vector2I<T>(T.Max(X, scalar), T.Max(Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
+        public static Vector2I<T> Max(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
+        public Vector2I<T> Min(Vector2I<T> other) =>
+            new Vector2I<T>(T.Min(X, other.X), T.Min(Y, other.Y));
+
+        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
+        public static Vector2I<T> Min(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y));
+
+        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
+        public Vector2I<T> Min(T scalar) =>
+            new Vector2I<T>(T.Min(X, scalar), T.Min(Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
+        public static Vector2I<T> Min(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar));
+
         /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
         public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
 
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() => $"<{X}, {Y}>";
+
         /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
         public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
         {
@@ -239,5 +293,44 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
             Encoding.UTF8.GetChars(utf8Text, charBuffer);
             return TryParse(charBuffer, provider, out result);
         }
+
+        // Component Operators
+        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
+
+        // Scalar Operators
+        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
+
+        // + operator: returns the vector (?)
+        public static Vector2I<T> operator +(Vector2I<T> vector) => vector;
+
+        //  - operator: returns the negated vector
+        public static Vector2I<T> operator -(Vector2I<T> vector) =>
+            new Vector2I<T>(-vector.X, -vector.Y);
     }
 }

From 94a912d94edd9fd5eb3b30690fdf49a24430dcef Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 21:25:44 +1000
Subject: [PATCH 06/52] Add more missing Vector2I requirements.

---
 sources/Maths/Maths/Vector2I.cs | 137 +++++++++++++++++++++++++++++++-
 1 file changed, 135 insertions(+), 2 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 5d0befb58a..dfe0d5060d 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -47,14 +47,17 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
         public static Vector2I<T> One => new(Scalar<T>.One);
 
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2I<T> Zero => default;
+
         /// <summary>Gets the vector (1, 0).</summary>
         public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
 
         /// <summary>Gets the vector (0, 1).</summary>
         public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
 
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2I<T> Zero => default;
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y);
@@ -126,6 +129,29 @@ public Vector2I<T> Min(T scalar) =>
         public static Vector2I<T> Min(Vector2I<T> vector, T scalar) =>
             new Vector2I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar));
 
+        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
+        public Vector2I<T> Clamp(Vector2I<T> min, Vector2I<T> max) =>
+            new Vector2I<T>(T.Clamp(X, min.X, max.X), T.Clamp(Y, min.Y, max.Y));
+
+        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
+        public static Vector2I<T> Clamp(Vector2I<T> vector, Vector2I<T> min, Vector2I<T> max) =>
+            new Vector2I<T>(T.Clamp(vector.X, min.X, max.X), T.Clamp(vector.Y, min.Y, max.Y));
+
+        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
+        public Vector2I<T> Clamp(T min, T max) =>
+            new Vector2I<T>(T.Clamp(X, min, max), T.Clamp(Y, min, max));
+
+        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
+        public static Vector2I<T> Clamp(Vector2I<T> vector, T min, T max) =>
+            new Vector2I<T>(T.Clamp(vector.X, min, max), T.Clamp(vector.Y, min, max));
+
+        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
+        public Vector2I<T> Abs() => new Vector2I<T>(T.Abs(X), T.Abs(Y));
+
+        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
+        public static Vector2I<T> Abs(Vector2I<T> vector) =>
+            new Vector2I<T>(T.Abs(vector.X), T.Abs(vector.Y));
+
         /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
         public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
 
@@ -183,6 +209,55 @@ public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
             return result;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
+        public Vector2I<T> Sign() => new Vector2I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
+
+        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
+        public static Vector2I<T> Sign(Vector2I<T> vector) =>
+            new Vector2I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)));
+
+        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
+        public Vector2I<T> CopySign(Vector2I<T> signSource) =>
+            new Vector2I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y));
+
+        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
+        public static Vector2I<T> CopySign(Vector2I<T> value, Vector2I<T> signSource) =>
+            new Vector2I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y));
+
+        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
+        public Vector2I<T> CopySign(T signScalar) =>
+            new Vector2I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar));
+
+        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
+        public static Vector2I<T> CopySign(Vector2I<T> value, T signScalar) =>
+            new Vector2I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
+
         /// <summary>Parses a string to a Vector2I instance.</summary>
         public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
@@ -294,6 +369,16 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
             return TryParse(charBuffer, provider, out result);
         }
 
+        // Casts
+
+        /// <summary>Explicitly casts a System.Numerics.Vector2 to a Vector2I.</summary>
+        public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
+            new Vector2I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
+
+        /// <summary>Explicitly casts a Vector2I to System.Numerics.Vector2.</summary>
+        public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
+            new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
+
         // Component Operators
         public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
             new Vector2I<T>(left.X + right.X, left.Y + right.Y);
@@ -332,5 +417,53 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
         //  - operator: returns the negated vector
         public static Vector2I<T> operator -(Vector2I<T> vector) =>
             new Vector2I<T>(-vector.X, -vector.Y);
+
+        // Bitwise Operators
+        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
+
+        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
+
+        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
+
+        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
+
+        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
+
+        // NOT operator
+        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
+            new Vector2I<T>(~vector.X, ~vector.Y);
+
+        // IBinaryInteger
+        // TODO: Verify these are actually correct
+
+        public static Vector2I<T> Log2(Vector2I<T> x) =>
+            new Vector2I<T>(T.Log2(x.X), T.Log2(x.Y));
+
+        public static (Vector2I<T> Quotient, Vector2I<T> Remainder) DivRem(Vector2I<T> left, Vector2I<T> right)
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            return (new Vector2I<T>(qX, qY), new Vector2I<T>(rX, rY));
+        }
+
+        public static Vector2I<T> PopCount(Vector2I<T> x) =>
+            new Vector2I<T>(T.PopCount(x.X), T.PopCount(x.Y));
     }
 }

From 051785de5d7ff7b774462bfd935d8a57873c4eb5 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 21:37:44 +1000
Subject: [PATCH 07/52] Add `Vector3I`.

---
 sources/Maths/Maths/Vector3I.cs | 530 ++++++++++++++++++++++++++++++++
 1 file changed, 530 insertions(+)
 create mode 100644 sources/Maths/Maths/Vector3I.cs

diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
new file mode 100644
index 0000000000..e6f3644c16
--- /dev/null
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -0,0 +1,530 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Maths
+{
+    /// <summary>A structure representing a 3D integer vector.</summary>
+    internal struct Vector3I<T> :
+        IEquatable<Vector3I<T>>,
+        IReadOnlyList<T>,
+        ISpanFormattable,
+        ISpanParsable<Vector3I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector3I<T>>,
+        IParsable<Vector3I<T>>,
+        IFormattable
+        where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>The Z component of the vector.</summary>
+        public T Z;
+
+        /// <summary>Initializes all components to the same value.</summary>
+        public Vector3I(T value) => (X, Y, Z) = (value, value, value);
+
+        /// <summary>Initializes the vector with individual values for X, Y and Z.</summary>
+        public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
+
+        /// <summary>Initializes the vector from a span of three values.</summary>
+        public Vector3I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 3)
+                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+        }
+
+        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
+        public static Vector3I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
+        public static Vector3I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0).</summary>
+        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0).</summary>
+        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1).</summary>
+        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
+
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 3;
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
+        public T this[int index] => index switch {
+            0 => X,
+            1 => Y,
+            2 => Z,
+            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, or 2.")
+        };
+
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector3I{T}"/> instance.</summary>
+        public bool Equals(Vector3I<T> other) => X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+        }
+
+        /// <summary> Computes the dot product of this vector with another vector. </summary>
+        public T Dot(Vector3I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z);
+
+        /// <summary> Computes the dot product of two vectors. </summary>
+        public static T Dot(Vector3I<T> left, Vector3I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z);
+
+        /// <summary> Computes the cross product of this vector with another vector. </summary>
+        public Vector3I<T> Cross(Vector3I<T> other) =>
+            new Vector3I<T>(
+                (Y * other.Z) - (Z * other.Y),
+                (Z * other.X) - (X * other.Z),
+                (X * other.Y) - (Y * other.X)
+            );
+
+        /// <summary> Computes the cross product of two vectors. </summary>
+        public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(
+                (left.Y * right.Z) - (left.Z * right.Y),
+                (left.Z * right.X) - (left.X * right.Z),
+                (left.X * right.Y) - (left.Y * right.X)
+            );
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
+
+        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
+        public Vector3I<T> Max(Vector3I<T> other) =>
+            new Vector3I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z));
+
+        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
+        public static Vector3I<T> Max(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y), T.Max(left.Z, right.Z));
+
+        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
+        public Vector3I<T> Max(T scalar) =>
+            new Vector3I<T>(T.Max(X, scalar), T.Max(Y, scalar), T.Max(Z, scalar));
+
+        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
+        public static Vector3I<T> Max(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar), T.Max(vector.Z, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
+        public Vector3I<T> Min(Vector3I<T> other) =>
+            new Vector3I<T>(T.Min(X, other.X), T.Min(Y, other.Y), T.Min(Z, other.Z));
+
+        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
+        public static Vector3I<T> Min(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y), T.Min(left.Z, right.Z));
+
+        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
+        public Vector3I<T> Min(T scalar) =>
+            new Vector3I<T>(T.Min(X, scalar), T.Min(Y, scalar), T.Min(Z, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
+        public static Vector3I<T> Min(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar), T.Min(vector.Z, scalar));
+
+        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
+        public Vector3I<T> Clamp(Vector3I<T> min, Vector3I<T> max) =>
+            new Vector3I<T>(
+                T.Clamp(X, min.X, max.X),
+                T.Clamp(Y, min.Y, max.Y),
+                T.Clamp(Z, min.Z, max.Z)
+            );
+
+        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
+        public static Vector3I<T> Clamp(Vector3I<T> vector, Vector3I<T> min, Vector3I<T> max) =>
+            new Vector3I<T>(
+                T.Clamp(vector.X, min.X, max.X),
+                T.Clamp(vector.Y, min.Y, max.Y),
+                T.Clamp(vector.Z, min.Z, max.Z)
+            );
+
+        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
+        public Vector3I<T> Clamp(T min, T max) =>
+            new Vector3I<T>(
+                T.Clamp(X, min, max),
+                T.Clamp(Y, min, max),
+                T.Clamp(Z, min, max)
+            );
+
+        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
+        public static Vector3I<T> Clamp(Vector3I<T> vector, T min, T max) =>
+            new Vector3I<T>(
+                T.Clamp(vector.X, min, max),
+                T.Clamp(vector.Y, min, max),
+                T.Clamp(vector.Z, min, max)
+            );
+
+        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
+        public Vector3I<T> Abs() => new Vector3I<T>(T.Abs(X), T.Abs(Y), T.Abs(Z));
+
+        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
+        public static Vector3I<T> Abs(Vector3I<T> vector) =>
+            new Vector3I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z));
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() => $"<{X}, {Y}, {Z}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            // Calculate total required length: < + x + ", " + y + ", " + z + >
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Parses a span to a Vector3I instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector3I.");
+
+            return result;
+        }
+
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 3 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 3 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+        }
+
+        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
+        public Vector3I<T> Sign() =>
+            new Vector3I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)));
+
+        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
+        public static Vector3I<T> Sign(Vector3I<T> vector) =>
+            new Vector3I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)), T.CreateChecked(T.Sign(vector.Z)));
+
+        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
+        public Vector3I<T> CopySign(Vector3I<T> signSource) =>
+            new Vector3I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y), T.CopySign(Z, signSource.Z));
+
+        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
+        public static Vector3I<T> CopySign(Vector3I<T> value, Vector3I<T> signSource) =>
+            new Vector3I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y), T.CopySign(value.Z, signSource.Z));
+
+        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
+        public Vector3I<T> CopySign(T signScalar) =>
+            new Vector3I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar), T.CopySign(Z, signScalar));
+
+        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
+        public static Vector3I<T> CopySign(Vector3I<T> value, T signScalar) =>
+            new Vector3I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar));
+
+        /// <summary>Parses a string to a Vector3I instance.</summary>
+        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Tries to parse a span to a Vector3I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 7 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int firstComma = s.IndexOf(',');
+            if (firstComma < 0)
+                return false;
+
+            // Kind of hacky, but it works
+            // TODO: See if there's a better way
+            ReadOnlySpan<char> remainder = s.Slice(firstComma + 1);
+            int secondCommaRelative = remainder.IndexOf(',');
+            if (secondCommaRelative < 0)
+                return false;
+
+            int secondComma = firstComma + 1 + secondCommaRelative;
+            if (secondComma < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
+            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
+            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z))
+            {
+                result = new Vector3I<T>(x, y, z);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Tries to parse a string to a Vector3I instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a Vector3I instance.</summary>
+        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a Vector3I instance.</summary>
+        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a Vector3I instance.</summary>
+        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a Vector3I instance.</summary>
+        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            // Estimate total required UTF-8 bytes
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                               Encoding.UTF8.GetByteCount("<, , >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Parses a UTF-8 span to a Vector3I instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a Vector3I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        // Casts
+
+        /// <summary>Explicitly casts a System.Numerics.Vector3 to a Vector3I.</summary>
+        public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
+            new Vector3I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
+
+        /// <summary>Explicitly casts a Vector3I to System.Numerics.Vector3.</summary>
+        public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
+            new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
+
+        // Component Operators
+        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+
+        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+
+        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+
+        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+
+        // Scalar Operators
+        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+
+        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+
+        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+
+        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+
+        // + operator: returns the vector (?)
+        public static Vector3I<T> operator +(Vector3I<T> vector) => vector;
+
+        //  - operator: returns the negated vector
+        public static Vector3I<T> operator -(Vector3I<T> vector) =>
+            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
+
+        // Bitwise Operators
+        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
+
+        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
+
+        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
+
+        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
+
+        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
+
+        // NOT operator
+        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
+            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
+
+        // IBinaryInteger
+        public static Vector3I<T> Log2(Vector3I<T> x) =>
+            new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
+
+        public static (Vector3I<T> Quotient, Vector3I<T> Remainder) DivRem(Vector3I<T> left, Vector3I<T> right)
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
+            return (new Vector3I<T>(qX, qY, qZ), new Vector3I<T>(rX, rY, rZ));
+        }
+
+        public static Vector3I<T> PopCount(Vector3I<T> x) =>
+            new Vector3I<T>(T.PopCount(x.X), T.PopCount(x.Y), T.PopCount(x.Z));
+    }
+}

From 88b840589f304a4cf56897bb0757ea7217462bfa Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 22:08:33 +1000
Subject: [PATCH 08/52] Change VectorI XML comments.

---
 sources/Maths/Maths/Vector2I.cs | 24 ++++++++++++------------
 sources/Maths/Maths/Vector3I.cs | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index dfe0d5060d..1e556d2a41 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -200,7 +200,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
-        /// <summary>Parses a span to a Vector2I instance.</summary>
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
         public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
         {
             if (!TryParse(s, provider, out var result))
@@ -258,10 +258,10 @@ public Vector2I<T> CopySign(T signScalar) =>
         public static Vector2I<T> CopySign(Vector2I<T> value, T signScalar) =>
             new Vector2I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
 
-        /// <summary>Parses a string to a Vector2I instance.</summary>
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
         public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
-        /// <summary>Tries to parse a span to a Vector2I instance.</summary>
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
         public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
         {
             result = default;
@@ -290,23 +290,23 @@ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [Ma
         }
 
 
-        /// <summary>Tries to parse a string to a Vector2I instance.</summary>
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
         public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
             TryParse(s.AsSpan(), provider, out result);
 
-        /// <summary>Parses a span to a Vector2I instance.</summary>
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
         static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Parses a string to a Vector2I instance.</summary>
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
         static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Tries to parse a span to a Vector2I instance.</summary>
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
         static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary>Tries to parse a string to a Vector2I instance.</summary>
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
         static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
             TryParse(s, provider, out result);
 
@@ -351,7 +351,7 @@ public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnly
             return true;
         }
 
-        /// <summary>Parses a UTF-8 span to a Vector2I instance.</summary>
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
         public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
@@ -360,7 +360,7 @@ public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? pr
             return Parse(charBuffer, provider);
         }
 
-        /// <summary>Tries to parse a UTF-8 span to a Vector2I instance.</summary>
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
         public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
@@ -371,11 +371,11 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
 
         // Casts
 
-        /// <summary>Explicitly casts a System.Numerics.Vector2 to a Vector2I.</summary>
+        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2I{T}"/>.</summary>
         public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
             new Vector2I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
 
-        /// <summary>Explicitly casts a Vector2I to System.Numerics.Vector2.</summary>
+        /// <summary>Explicitly casts a <see cref="Vector2I{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
         public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
             new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index e6f3644c16..842a391b42 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -243,7 +243,7 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
-        /// <summary>Parses a span to a Vector3I instance.</summary>
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
         public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
         {
             if (!TryParse(s, provider, out var result))
@@ -304,10 +304,10 @@ public Vector3I<T> CopySign(T signScalar) =>
         public static Vector3I<T> CopySign(Vector3I<T> value, T signScalar) =>
             new Vector3I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar));
 
-        /// <summary>Parses a string to a Vector3I instance.</summary>
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
         public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
-        /// <summary>Tries to parse a span to a Vector3I instance.</summary>
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
         public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
         {
             result = default;
@@ -348,23 +348,23 @@ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [Ma
             return false;
         }
 
-        /// <summary>Tries to parse a string to a Vector3I instance.</summary>
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
         public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
             TryParse(s.AsSpan(), provider, out result);
 
-        /// <summary>Parses a span to a Vector3I instance.</summary>
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
         static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Parses a string to a Vector3I instance.</summary>
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
         static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Tries to parse a span to a Vector3I instance.</summary>
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
         static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary>Tries to parse a string to a Vector3I instance.</summary>
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
         static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
             TryParse(s, provider, out result);
 
@@ -413,7 +413,7 @@ public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnly
             return true;
         }
 
-        /// <summary>Parses a UTF-8 span to a Vector3I instance.</summary>
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
         public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
@@ -422,7 +422,7 @@ public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? pr
             return Parse(charBuffer, provider);
         }
 
-        /// <summary>Tries to parse a UTF-8 span to a Vector3I instance.</summary>
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
         public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
@@ -433,11 +433,11 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
 
         // Casts
 
-        /// <summary>Explicitly casts a System.Numerics.Vector3 to a Vector3I.</summary>
+        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3I{T}"/>.</summary>
         public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
             new Vector3I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
 
-        /// <summary>Explicitly casts a Vector3I to System.Numerics.Vector3.</summary>
+        /// <summary>Explicitly casts a <see cref="Vector3I{T}"/> to <see cref="System.Numerics.Vector3"/>.</summary>
         public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
             new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
 

From d1eade9172bd5ecb30b8b5482f586f58a38de703 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 22:08:54 +1000
Subject: [PATCH 09/52] Add `Vector4I`.

---
 sources/Maths/Maths/Vector4I.cs | 546 ++++++++++++++++++++++++++++++++
 1 file changed, 546 insertions(+)
 create mode 100644 sources/Maths/Maths/Vector4I.cs

diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
new file mode 100644
index 0000000000..71480db468
--- /dev/null
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -0,0 +1,546 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Maths
+{
+    /// <summary>A structure representing a 4D integer vector.</summary>
+    internal struct Vector4I<T> :
+        IEquatable<Vector4I<T>>,
+        IReadOnlyList<T>,
+        ISpanFormattable,
+        ISpanParsable<Vector4I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector4I<T>>,
+        IParsable<Vector4I<T>>,
+        IFormattable
+        where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>The Z component of the vector.</summary>
+        public T Z;
+
+        /// <summary>The W component of the vector.</summary>
+        public T W;
+
+        /// <summary>Initializes all components to the same value.</summary>
+        public Vector4I(T value) => (X, Y, Z, W) = (value, value, value, value);
+
+        /// <summary>Initializes the vector with individual values for X, Y, Z and W.</summary>
+        public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
+
+        /// <summary>Initializes the vector from a span of four values.</summary>
+        public Vector4I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 4)
+                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+            W = values[3];
+        }
+
+        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
+        public static Vector4I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
+        public static Vector4I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
+        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
+        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
+        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
+        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
+
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 4;
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
+        public T this[int index] => index switch {
+            0 => X,
+            1 => Y,
+            2 => Z,
+            3 => W,
+            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, 2, or 3.")
+        };
+
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector4I{T}"/> instance.</summary>
+        public bool Equals(Vector4I<T> other) => X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z) && W.Equals(other.W);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+            yield return W;
+        }
+
+        /// <summary> Computes the dot product of this vector with another vector. </summary>
+        public T Dot(Vector4I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z) + (W * other.W);
+
+        /// <summary> Computes the dot product of two vectors. </summary>
+        public static T Dot(Vector4I<T> left, Vector4I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z) + (left.W * right.W);
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
+
+        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
+        public Vector4I<T> Max(Vector4I<T> other) =>
+            new Vector4I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z), T.Max(W, other.W));
+
+        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
+        public static Vector4I<T> Max(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y), T.Max(left.Z, right.Z), T.Max(left.W, right.W));
+
+        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
+        public Vector4I<T> Max(T scalar) =>
+            new Vector4I<T>(T.Max(X, scalar), T.Max(Y, scalar), T.Max(Z, scalar), T.Max(W, scalar));
+
+        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
+        public static Vector4I<T> Max(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar), T.Max(vector.Z, scalar), T.Max(vector.W, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
+        public Vector4I<T> Min(Vector4I<T> other) =>
+            new Vector4I<T>(T.Min(X, other.X), T.Min(Y, other.Y), T.Min(Z, other.Z), T.Min(W, other.W));
+
+        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
+        public static Vector4I<T> Min(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y), T.Min(left.Z, right.Z), T.Min(left.W, right.W));
+
+        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
+        public Vector4I<T> Min(T scalar) =>
+            new Vector4I<T>(T.Min(X, scalar), T.Min(Y, scalar), T.Min(Z, scalar), T.Min(W, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
+        public static Vector4I<T> Min(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar), T.Min(vector.Z, scalar), T.Min(vector.W, scalar));
+
+        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
+        public Vector4I<T> Clamp(Vector4I<T> min, Vector4I<T> max) =>
+            new Vector4I<T>(
+                T.Clamp(X, min.X, max.X),
+                T.Clamp(Y, min.Y, max.Y),
+                T.Clamp(Z, min.Z, max.Z),
+                T.Clamp(W, min.W, max.W)
+            );
+
+        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
+        public static Vector4I<T> Clamp(Vector4I<T> vector, Vector4I<T> min, Vector4I<T> max) =>
+            new Vector4I<T>(
+                T.Clamp(vector.X, min.X, max.X),
+                T.Clamp(vector.Y, min.Y, max.Y),
+                T.Clamp(vector.Z, min.Z, max.Z),
+                T.Clamp(vector.W, min.W, max.W)
+            );
+
+        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
+        public Vector4I<T> Clamp(T min, T max) =>
+            new Vector4I<T>(
+                T.Clamp(X, min, max),
+                T.Clamp(Y, min, max),
+                T.Clamp(Z, min, max),
+                T.Clamp(W, min, max)
+            );
+
+        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
+        public static Vector4I<T> Clamp(Vector4I<T> vector, T min, T max) =>
+            new Vector4I<T>(
+                T.Clamp(vector.X, min, max),
+                T.Clamp(vector.Y, min, max),
+                T.Clamp(vector.Z, min, max),
+                T.Clamp(vector.W, min, max)
+            );
+
+        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
+        public Vector4I<T> Abs() => new Vector4I<T>(T.Abs(X), T.Abs(Y), T.Abs(Z), T.Abs(W));
+
+        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
+        public static Vector4I<T> Abs(Vector4I<T> vector) =>
+            new Vector4I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z), T.Abs(vector.W));
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() => $"<{X}, {Y}, {Z}, {W}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            // Calculate total required length: < + x + ", " + y + ", " + z + ", " + w + >
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            wBuffer[..wChars].CopyTo(destination[pos..]);
+            pos += wChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Parses a span to a Vector4I instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector4I.");
+
+            return result;
+        }
+
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 4 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+            array[startIndex + 3] = W;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 4 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+            span[startIndex + 3] = W;
+        }
+
+        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
+        public Vector4I<T> Sign() =>
+            new Vector4I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)), T.CreateChecked(T.Sign(W)));
+
+        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
+        public static Vector4I<T> Sign(Vector4I<T> vector) =>
+            new Vector4I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)), T.CreateChecked(T.Sign(vector.Z)), T.CreateChecked(T.Sign(vector.W)));
+
+        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
+        public Vector4I<T> CopySign(Vector4I<T> signSource) =>
+            new Vector4I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y), T.CopySign(Z, signSource.Z), T.CopySign(W, signSource.W));
+
+        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
+        public static Vector4I<T> CopySign(Vector4I<T> value, Vector4I<T> signSource) =>
+            new Vector4I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y), T.CopySign(value.Z, signSource.Z), T.CopySign(value.W, signSource.W));
+
+        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
+        public Vector4I<T> CopySign(T signScalar) =>
+            new Vector4I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar), T.CopySign(Z, signScalar), T.CopySign(W, signScalar));
+
+        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
+        public static Vector4I<T> CopySign(Vector4I<T> value, T signScalar) =>
+            new Vector4I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar), T.CopySign(value.W, signScalar));
+
+        /// <summary>Parses a string to a Vector4I instance.</summary>
+        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 9 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int firstComma = s.IndexOf(',');
+            if (firstComma < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(firstComma + 1);
+            int secondCommaRelative = remainder1.IndexOf(',');
+            if (secondCommaRelative < 0)
+                return false;
+            int secondComma = firstComma + 1 + secondCommaRelative;
+
+            ReadOnlySpan<char> remainder2 = s.Slice(secondComma + 1);
+            int thirdCommaRelative = remainder2.IndexOf(',');
+            if (thirdCommaRelative < 0)
+                return false;
+            int thirdComma = secondComma + 1 + thirdCommaRelative;
+
+            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
+            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
+            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..thirdComma].Trim();
+            ReadOnlySpan<char> wSpan = s[(thirdComma + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z) &&
+                T.TryParse(wSpan, provider, out var w))
+            {
+                result = new Vector4I<T>(x, y, z, w);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a Vector4I instance.</summary>
+        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a Vector4I instance.</summary>
+        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
+        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
+        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            // Format components individually into temporary buffers
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            // Estimate total required UTF-8 bytes
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                               Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
+                               Encoding.UTF8.GetByteCount("<, , , >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Parses a UTF-8 span to a Vector4I instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a Vector4I instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        // Casts
+
+        /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4I.</summary>
+        public static explicit operator Vector4I<T>(System.Numerics.Vector4 v) =>
+            new Vector4I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)), (T)Convert.ChangeType(v.W, typeof(T)));
+
+        /// <summary>Explicitly casts a Vector4I to System.Numerics.Vector4.</summary>
+        public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
+            new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
+
+        // Component Operators
+        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+
+        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+
+        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+
+        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+
+        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+
+        // Scalar Operators
+        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+
+        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+
+        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+
+        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+
+        // + operator: returns the vector (?)
+        public static Vector4I<T> operator +(Vector4I<T> vector) => vector;
+
+        //  - operator: returns the negated vector
+        public static Vector4I<T> operator -(Vector4I<T> vector) =>
+            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+
+        // Bitwise Operators
+        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
+
+        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
+
+        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
+
+        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
+
+        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
+
+        // NOT operator
+        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
+            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
+
+        // IBinaryInteger
+        public static Vector4I<T> Log2(Vector4I<T> x) =>
+            new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));
+
+        public static (Vector4I<T> Quotient, Vector4I<T> Remainder) DivRem(Vector4I<T> left, Vector4I<T> right)
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
+            var (qW, rW) = T.DivRem(left.W, right.W);
+            return (new Vector4I<T>(qX, qY, qZ, qW), new Vector4I<T>(rX, rY, rZ, rW));
+        }
+
+        public static Vector4I<T> PopCount(Vector4I<T> x) =>
+            new Vector4I<T>(T.PopCount(x.X), T.PopCount(x.Y), T.PopCount(x.Z), T.PopCount(x.W));
+    }
+}

From 9b68e351c363a6f7fceb6d898f719539dd2ac852 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 22:41:15 +1000
Subject: [PATCH 10/52] Improve VectorI equality checks.

---
 sources/Maths/Maths/Vector2I.cs | 15 ++++++++++++++-
 sources/Maths/Maths/Vector3I.cs | 15 ++++++++++++++-
 sources/Maths/Maths/Vector4I.cs | 21 ++++++++++++++++++++-
 3 files changed, 48 insertions(+), 3 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 1e556d2a41..ab8ba58dfc 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -73,7 +73,13 @@ public Vector2I(ReadOnlySpan<T> values)
         };
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2I{T}"/> instance.</summary>
-        public bool Equals(Vector2I<T> other) => X.Equals(other.X) && Y.Equals(other.Y);
+        public override bool Equals(object? obj) => obj is Vector2I<T> other && Equals(other);
+
+        /// <summary>Returns a boolean indicating whether the given Vector2I is equal to this <see cref="Vector2I{T}"/> instance.</summary>
+        public bool Equals(Vector2I<T> other) => this == other;
+
+        /// <summary>Returns the hash code for this instance.</summary>
+        public override int GetHashCode() => HashCode.Combine(X, Y);
 
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
@@ -450,6 +456,13 @@ public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
         public static Vector2I<T> operator ~(Vector2I<T> vector) =>
             new Vector2I<T>(~vector.X, ~vector.Y);
 
+        // Equality Operators
+        public static bool operator ==(Vector2I<T> left, Vector2I<T> right) =>
+            left.X == right.X && left.Y == right.Y;
+
+        public static bool operator !=(Vector2I<T> left, Vector2I<T> right) =>
+            left.X != right.X || left.Y != right.Y;
+
         // IBinaryInteger
         // TODO: Verify these are actually correct
 
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 842a391b42..357643abd9 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -81,7 +81,13 @@ public Vector3I(ReadOnlySpan<T> values)
         };
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector3I{T}"/> instance.</summary>
-        public bool Equals(Vector3I<T> other) => X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z);
+        public override bool Equals(object? obj) => obj is Vector3I<T> other && Equals(other);
+
+        /// <summary>Returns a boolean indicating whether the given Vector3I is equal to this <see cref="Vector3I{T}"/> instance.</summary>
+        public bool Equals(Vector3I<T> other) => this == other;
+
+        /// <summary>Returns the hash code for this instance.</summary>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z);
 
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
@@ -512,6 +518,13 @@ public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
         public static Vector3I<T> operator ~(Vector3I<T> vector) =>
             new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
 
+        // Equality Operators
+        public static bool operator ==(Vector3I<T> left, Vector3I<T> right) =>
+            left.X == right.X && left.Y == right.Y && left.Z == right.Z;
+
+        public static bool operator !=(Vector3I<T> left, Vector3I<T> right) =>
+            left.X != right.X || left.Y != right.Y || left.Z != right.Z;
+
         // IBinaryInteger
         public static Vector3I<T> Log2(Vector3I<T> x) =>
             new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 71480db468..b1866d3f00 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -89,7 +89,13 @@ public Vector4I(ReadOnlySpan<T> values)
         };
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector4I{T}"/> instance.</summary>
-        public bool Equals(Vector4I<T> other) => X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z) && W.Equals(other.W);
+        public override bool Equals(object? obj) => obj is Vector4I<T> other && Equals(other);
+
+        /// <summary>Returns a boolean indicating whether the given Vector4I is equal to this <see cref="Vector4I{T}"/> instance.</summary>
+        public bool Equals(Vector4I<T> other) => this == other;
+
+        /// <summary>Returns the hash code for this instance.</summary>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
 
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
@@ -527,6 +533,19 @@ public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
         public static Vector4I<T> operator ~(Vector4I<T> vector) =>
             new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
 
+        // Equality Operators
+        public static bool operator ==(Vector4I<T> left, Vector4I<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y &&
+            left.Z == right.Z &&
+            left.W == right.W;
+
+        public static bool operator !=(Vector4I<T> left, Vector4I<T> right) =>
+            left.X != right.X ||
+            left.Y != right.Y ||
+            left.Z != right.Z ||
+            left.W != right.W;
+
         // IBinaryInteger
         public static Vector4I<T> Log2(Vector4I<T> x) =>
             new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));

From 6a3cf885afd2f5c1e4487dc270adec6351814886 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 22:49:16 +1000
Subject: [PATCH 11/52] Start work on new `Quaternion`.

---
 sources/Maths/Maths/Legacy/Quaternion.cs | 794 +++++++++++++++++++++++
 sources/Maths/Maths/Quaternion.cs        | 771 +---------------------
 2 files changed, 818 insertions(+), 747 deletions(-)
 create mode 100644 sources/Maths/Maths/Legacy/Quaternion.cs

diff --git a/sources/Maths/Maths/Legacy/Quaternion.cs b/sources/Maths/Maths/Legacy/Quaternion.cs
new file mode 100644
index 0000000000..b0c46916b9
--- /dev/null
+++ b/sources/Maths/Maths/Legacy/Quaternion.cs
@@ -0,0 +1,794 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using Silk.NET.Maths;
+
+namespace Silk.NET.Maths.Legacy
+{
+    /// <summary>
+    /// Represents a vector that is used to encode three-dimensional physical rotations.
+    /// </summary>
+    /// <typeparam name="T">The type used to store values.</typeparam>
+    [Serializable]
+    [DataContract]
+    public struct Quaternion<T>
+        : IEquatable<Quaternion<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    {
+        private const float SlerpEpsilon = 1e-6f;
+
+        /// <summary>Specifies the X-value of the vector component of the Quaternion.</summary>
+        [DataMember]
+        public T X;
+
+        /// <summary>Specifies the Y-value of the vector component of the Quaternion.</summary>
+        [DataMember]
+        public T Y;
+
+        /// <summary>Specifies the Z-value of the vector component of the Quaternion.</summary>
+        [DataMember]
+        public T Z;
+
+        /// <summary>Specifies the rotation component of the Quaternion.</summary>
+        [DataMember]
+        public T W;
+
+        /// <summary>Constructs a Quaternion from the given components.</summary>
+        /// <param name="x">The X component of the Quaternion.</param>
+        /// <param name="y">The Y component of the Quaternion.</param>
+        /// <param name="z">The Z component of the Quaternion.</param>
+        /// <param name="w">The W component of the Quaternion.</param>
+        public Quaternion(T x, T y, T z, T w)
+        {
+            X = x;
+            Y = y;
+            Z = z;
+            W = w;
+        }
+
+        /// <summary>Constructs a Quaternion from the given vector and rotation parts.</summary>
+        /// <param name="vectorPart">The vector part of the Quaternion.</param>
+        /// <param name="scalarPart">The rotation part of the Quaternion.</param>
+        public Quaternion(Vector3D<T> vectorPart, T scalarPart)
+        {
+            X = vectorPart.X;
+            Y = vectorPart.Y;
+            Z = vectorPart.Z;
+            W = scalarPart;
+        }
+
+        /// <summary>Returns a Quaternion representing no rotation.</summary>
+        public static Quaternion<T> Identity => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Returns whether the Quaternion is the identity Quaternion.</summary>
+        [IgnoreDataMember]
+        public readonly bool IsIdentity => this == Identity;
+
+        /// <summary>Adds two Quaternions element-by-element.</summary>
+        /// <param name="value1">The first source Quaternion.</param>
+        /// <param name="value2">The second source Quaternion.</param>
+        /// <returns>The result of adding the Quaternions.</returns>
+        public static Quaternion<T> operator +(Quaternion<T> value1, Quaternion<T> value2)
+        {
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Add(value1.X, value2.X);
+            ans.Y = Scalar.Add(value1.Y, value2.Y);
+            ans.Z = Scalar.Add(value1.Z, value2.Z);
+            ans.W = Scalar.Add(value1.W, value2.W);
+
+            return ans;
+        }
+
+        /// <summary>Divides a Quaternion by another Quaternion.</summary>
+        /// <param name="value1">The source Quaternion.</param>
+        /// <param name="value2">The divisor.</param>
+        /// <returns>The result of the division.</returns>
+        public static Quaternion<T> operator /(Quaternion<T> value1, Quaternion<T> value2)
+        {
+            Quaternion<T> ans;
+
+            T q1x = value1.X;
+            T q1y = value1.Y;
+            T q1z = value1.Z;
+            T q1w = value1.W;
+
+            //-------------------------------------
+            // Inverse part.
+            T ls = Scalar.Add(
+                Scalar.Add(
+                    Scalar.Add(Scalar.Multiply(value2.X, value2.X), Scalar.Multiply(value2.Y, value2.Y)),
+                    Scalar.Multiply(value2.Z, value2.Z)), Scalar.Multiply(value2.W, value2.W));
+            T invNorm = Scalar.Reciprocal(ls);
+
+            T q2x = Scalar.Negate(Scalar.Multiply(value2.X, invNorm));
+            T q2y = Scalar.Negate(Scalar.Multiply(value2.Y, invNorm));
+            T q2z = Scalar.Negate(Scalar.Multiply(value2.Z, invNorm));
+            T q2w = Scalar.Multiply(value2.W, invNorm);
+
+            //-------------------------------------
+            // Multiply part.
+
+            // cross(av, bv)
+            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+
+            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+                Scalar.Multiply(q1z, q2z));
+
+            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
+            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
+            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
+            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
+
+            return ans;
+        }
+
+        /// <summary>Returns a boolean indicating whether the two given Quaternions are equal.</summary>
+        /// <param name="value1">The first Quaternion to compare.</param>
+        /// <param name="value2">The second Quaternion to compare.</param>
+        /// <returns>True if the Quaternions are equal; False otherwise.</returns>
+        public static bool operator ==(Quaternion<T> value1, Quaternion<T> value2)
+            => Scalar.Equal(value1.X, value2.X)
+            && Scalar.Equal(value1.Y, value2.Y)
+            && Scalar.Equal(value1.Z, value2.Z)
+            && Scalar.Equal(value1.W, value2.W);
+
+        /// <summary>Returns a boolean indicating whether the two given Quaternions are not equal.</summary>
+        /// <param name="value1">The first Quaternion to compare.</param>
+        /// <param name="value2">The second Quaternion to compare.</param>
+        /// <returns>True if the Quaternions are not equal; False if they are equal.</returns>
+        public static bool operator !=(Quaternion<T> value1, Quaternion<T> value2)
+            => !(value1 == value2);
+
+        /// <summary>Multiplies two Quaternions together.</summary>
+        /// <param name="value1">The Quaternion on the left side of the multiplication.</param>
+        /// <param name="value2">The Quaternion on the right side of the multiplication.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Quaternion<T> operator *(Quaternion<T> value1, Quaternion<T> value2)
+        {
+            Quaternion<T> ans;
+
+            T q1x = value1.X;
+            T q1y = value1.Y;
+            T q1z = value1.Z;
+            T q1w = value1.W;
+
+            T q2x = value2.X;
+            T q2y = value2.Y;
+            T q2z = value2.Z;
+            T q2w = value2.W;
+
+            // cross(av, bv)
+            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+
+            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+                Scalar.Multiply(q1z, q2z));
+
+            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
+            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
+            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
+            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
+
+            return ans;
+        }
+
+        /// <summary>Multiplies a Quaternion by a scalar value.</summary>
+        /// <param name="value1">The source Quaternion.</param>
+        /// <param name="value2">The scalar value.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Quaternion<T> operator *(Quaternion<T> value1, T value2)
+        {
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Multiply(value1.X, value2);
+            ans.Y = Scalar.Multiply(value1.Y, value2);
+            ans.Z = Scalar.Multiply(value1.Z, value2);
+            ans.W = Scalar.Multiply(value1.W, value2);
+
+            return ans;
+        }
+
+        /// <summary>Subtracts one Quaternion from another.</summary>
+        /// <param name="value1">The first source Quaternion.</param>
+        /// <param name="value2">The second Quaternion, to be subtracted from the first.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Quaternion<T> operator -(Quaternion<T> value1, Quaternion<T> value2)
+        {
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Subtract(value1.X, value2.X);
+            ans.Y = Scalar.Subtract(value1.Y, value2.Y);
+            ans.Z = Scalar.Subtract(value1.Z, value2.Z);
+            ans.W = Scalar.Subtract(value1.W, value2.W);
+
+            return ans;
+        }
+
+        /// <summary>Flips the sign of each component of the quaternion.</summary>
+        /// <param name="value">The source Quaternion.</param>
+        /// <returns>The negated Quaternion.</returns>
+        public static Quaternion<T> operator -(Quaternion<T> value)
+        {
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Negate(value.X);
+            ans.Y = Scalar.Negate(value.Y);
+            ans.Z = Scalar.Negate(value.Z);
+            ans.W = Scalar.Negate(value.W);
+
+            return ans;
+        }
+
+        /// <summary>Adds two Quaternions element-by-element.</summary>
+        /// <param name="value1">The first source Quaternion.</param>
+        /// <param name="value2">The second source Quaternion.</param>
+        /// <returns>The result of adding the Quaternions.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Add(Quaternion<T> value1, Quaternion<T> value2)
+            => value1 + value2;
+
+        /// <summary>Concatenates two Quaternions; the result represents the value1 rotation followed by the value2 rotation.</summary>
+        /// <param name="value1">The first Quaternion rotation in the series.</param>
+        /// <param name="value2">The second Quaternion rotation in the series.</param>
+        /// <returns>A new Quaternion representing the concatenation of the value1 rotation followed by the value2 rotation.</returns>
+        public static Quaternion<T> Concatenate(Quaternion<T> value1, Quaternion<T> value2)
+        {
+            Quaternion<T> ans;
+
+            // Concatenate rotation is actually q2 * q1 instead of q1 * q2.
+            // So that's why value2 goes q1 and value1 goes q2.
+            T q1x = value2.X;
+            T q1y = value2.Y;
+            T q1z = value2.Z;
+            T q1w = value2.W;
+
+            T q2x = value1.X;
+            T q2y = value1.Y;
+            T q2z = value1.Z;
+            T q2w = value1.W;
+
+            // cross(av, bv)
+            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+
+            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+                Scalar.Multiply(q1z, q2z));
+
+            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
+            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
+            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
+            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
+
+            return ans;
+        }
+
+        /// <summary>Creates the conjugate of a specified Quaternion.</summary>
+        /// <param name="value">The Quaternion of which to return the conjugate.</param>
+        /// <returns>A new Quaternion that is the conjugate of the specified one.</returns>
+        public static Quaternion<T> Conjugate(Quaternion<T> value)
+        {
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Negate(value.X);
+            ans.Y = Scalar.Negate(value.Y);
+            ans.Z = Scalar.Negate(value.Z);
+            ans.W = value.W;
+
+            return ans;
+        }
+
+        /// <summary>Creates a Quaternion from a normalized vector axis and an angle to rotate about the vector.</summary>
+        /// <param name="axis">The unit vector to rotate around.
+        /// This vector must be normalized before calling this function or the resulting Quaternion will be incorrect.</param>
+        /// <param name="angle">The angle, in radians, to rotate around the vector.</param>
+        /// <returns>The created Quaternion.</returns>
+        public static Quaternion<T> CreateFromAxisAngle(Vector3D<T> axis, T angle)
+        {
+            Quaternion<T> ans;
+
+            T halfAngle = Scalar.Divide(angle, Scalar<T>.Two);
+            T s = Scalar.Sin(halfAngle);
+            T c = Scalar.Cos(halfAngle);
+
+            ans.X = Scalar.Multiply(axis.X, s);
+            ans.Y = Scalar.Multiply(axis.Y, s);
+            ans.Z = Scalar.Multiply(axis.Z, s);
+            ans.W = c;
+
+            return ans;
+        }
+
+        /// <summary>Creates a Quaternion from the given rotation matrix.</summary>
+        /// <param name="matrix">The rotation matrix.</param>
+        /// <returns>The created Quaternion.</returns>
+        public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
+        {
+            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
+
+            Quaternion<T> q = default;
+
+            if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
+            {
+                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
+                q.W = Scalar.Divide(s, Scalar<T>.Two);
+                s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
+                q.Y = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), s);
+                q.Z = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), s);
+            }
+            else
+            {
+                if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Divide(s, Scalar<T>.Two);
+                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
+                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), invS);
+                }
+                else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
+                    q.Y = Scalar.Divide(s, Scalar<T>.Two);
+                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), invS);
+                }
+                else
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
+                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
+                    q.Z = Scalar.Divide(s, Scalar<T>.Two);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), invS);
+                }
+            }
+
+            return q;
+        }
+
+        /// <summary>Creates a Quaternion from the given rotation matrix.</summary>
+        /// <param name="matrix">The rotation matrix.</param>
+        /// <returns>The created Quaternion.</returns>
+        public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
+        {
+            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
+
+            Quaternion<T> q = default;
+
+            if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
+            {
+                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
+                q.W = Scalar.Divide(s, Scalar<T>.Two);
+                s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
+                q.Y = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), s);
+                q.Z = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), s);
+            }
+            else
+            {
+                if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Divide(s, Scalar<T>.Two);
+                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
+                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), invS);
+                }
+                else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
+                    q.Y = Scalar.Divide(s, Scalar<T>.Two);
+                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), invS);
+                }
+                else
+                {
+                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
+                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
+                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
+                    q.Z = Scalar.Divide(s, Scalar<T>.Two);
+                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), invS);
+                }
+            }
+
+            return q;
+        }
+
+        /// <summary>Creates a new Quaternion from the given yaw, pitch, and roll, in radians.</summary>
+        /// <param name="yaw">The yaw angle, in radians, around the Y-axis.</param>
+        /// <param name="pitch">The pitch angle, in radians, around the X-axis.</param>
+        /// <param name="roll">The roll angle, in radians, around the Z-axis.</param>
+        /// <returns></returns>
+        public static Quaternion<T> CreateFromYawPitchRoll(T yaw, T pitch, T roll)
+        {
+            //  Roll first, about axis the object is facing, then
+            //  pitch upward, then yaw to face into the new heading
+            T sr, cr, sp, cp, sy, cy;
+
+            T halfRoll = Scalar.Divide(roll, Scalar<T>.Two);
+            sr = Scalar.Sin(halfRoll);
+            cr = Scalar.Cos(halfRoll);
+
+            T halfPitch = Scalar.Divide(pitch, Scalar<T>.Two);
+            sp = Scalar.Sin(halfPitch);
+            cp = Scalar.Cos(halfPitch);
+
+            T halfYaw = Scalar.Divide(yaw, Scalar<T>.Two);
+            sy = Scalar.Sin(halfYaw);
+            cy = Scalar.Cos(halfYaw);
+
+            Quaternion<T> result;
+
+            result.X = Scalar.Add(Scalar.Multiply(Scalar.Multiply(cy, sp), cr), Scalar.Multiply(Scalar.Multiply(sy, cp), sr));
+            result.Y = Scalar.Subtract(Scalar.Multiply(Scalar.Multiply(sy, cp), cr), Scalar.Multiply(Scalar.Multiply(cy, sp), sr));
+            result.Z = Scalar.Subtract(Scalar.Multiply(Scalar.Multiply(cy, cp), sr), Scalar.Multiply(Scalar.Multiply(sy, sp), cr));
+            result.W = Scalar.Add(Scalar.Multiply(Scalar.Multiply(cy, cp), cr), Scalar.Multiply(Scalar.Multiply(sy, sp), sr));
+
+            return result;
+        }
+
+        /// <summary>Divides a Quaternion by another Quaternion.</summary>
+        /// <param name="value1">The source Quaternion.</param>
+        /// <param name="value2">The divisor.</param>
+        /// <returns>The result of the division.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Divide(Quaternion<T> value1, Quaternion<T> value2)
+            => value1 / value2;
+
+        /// <summary>Calculates the dot product of two Quaternions.</summary>
+        /// <param name="quaternion1">The first source Quaternion.</param>
+        /// <param name="quaternion2">The second source Quaternion.</param>
+        /// <returns>The dot product of the Quaternions.</returns>
+        public static T Dot(Quaternion<T> quaternion1, Quaternion<T> quaternion2)
+        {
+            return Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X),
+                   Scalar.Multiply(quaternion1.Y, quaternion2.Y)),
+                   Scalar.Multiply(quaternion1.Z, quaternion2.Z)),
+                   Scalar.Multiply(quaternion1.W, quaternion2.W));
+        }
+
+        /// <summary>Returns the inverse of a Quaternion.</summary>
+        /// <param name="value">The source Quaternion.</param>
+        /// <returns>The inverted Quaternion.</returns>
+        public static Quaternion<T> Inverse(Quaternion<T> value)
+        {
+            //  -1   (       a              -v       )
+            // q   = ( -------------   ------------- )
+            //       (  a^2 + |v|^2  ,  a^2 + |v|^2  )
+
+            Quaternion<T> ans;
+
+            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
+            T invNorm = Scalar.Reciprocal(ls);
+
+            ans.X = Scalar.Negate(Scalar.Multiply(value.X, invNorm));
+            ans.Y = Scalar.Negate(Scalar.Multiply(value.Y, invNorm));
+            ans.Z = Scalar.Negate(Scalar.Multiply(value.Z, invNorm));
+            ans.W = Scalar.Multiply(value.W, invNorm);
+
+            return ans;
+        }
+
+        /// <summary> Linearly interpolates between two quaternions.</summary>
+        /// <param name="quaternion1">The first source Quaternion.</param>
+        /// <param name="quaternion2">The second source Quaternion.</param>
+        /// <param name="amount">The relative weight of the second source Quaternion in the interpolation.</param>
+        /// <returns>The interpolated Quaternion.</returns>
+        public static Quaternion<T> Lerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
+        {
+            T t = amount;
+            T t1 = Scalar.Subtract(Scalar<T>.One, t);
+
+            Quaternion<T> r = default;
+
+            T dot = Scalar.Add(
+                Scalar.Add(
+                    Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X),
+                        Scalar.Multiply(quaternion1.Y, quaternion2.Y)),
+                    Scalar.Multiply(quaternion1.Z, quaternion2.Z)),
+                Scalar.Multiply(quaternion1.W, quaternion2.W));
+
+            if (Scalar.GreaterThanOrEqual(dot, Scalar<T>.Zero))
+            {
+                r.X = Scalar.Add(Scalar.Multiply(t1, quaternion1.X), Scalar.Multiply(t, quaternion2.X));
+                r.Y = Scalar.Add(Scalar.Multiply(t1, quaternion1.Y), Scalar.Multiply(t, quaternion2.Y));
+                r.Z = Scalar.Add(Scalar.Multiply(t1, quaternion1.Z), Scalar.Multiply(t, quaternion2.Z));
+                r.W = Scalar.Add(Scalar.Multiply(t1, quaternion1.W), Scalar.Multiply(t, quaternion2.W));
+            }
+            else
+            {
+                r.X = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.X), Scalar.Multiply(t, quaternion2.X));
+                r.Y = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.Y), Scalar.Multiply(t, quaternion2.Y));
+                r.Z = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.Z), Scalar.Multiply(t, quaternion2.Z));
+                r.W = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.W), Scalar.Multiply(t, quaternion2.W));
+            }
+
+            // Normalize it.
+            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(r.X, r.X), Scalar.Multiply(r.Y, r.Y)), Scalar.Multiply(r.Z, r.Z)), Scalar.Multiply(r.W, r.W));
+            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
+
+            r.X = Scalar.Multiply(r.X, invNorm);
+            r.Y = Scalar.Multiply(r.Y, invNorm);
+            r.Z = Scalar.Multiply(r.Z, invNorm);
+            r.W = Scalar.Multiply(r.W, invNorm);
+
+            return r;
+        }
+
+        /// <summary>Multiplies two Quaternions together.</summary>
+        /// <param name="value1">The Quaternion on the left side of the multiplication.</param>
+        /// <param name="value2">The Quaternion on the right side of the multiplication.</param>
+        /// <returns>The result of the multiplication.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Multiply(Quaternion<T> value1, Quaternion<T> value2)
+            => value1 * value2;
+
+        /// <summary>Multiplies a Quaternion by a scalar value.</summary>
+        /// <param name="value1">The source Quaternion.</param>
+        /// <param name="value2">The scalar value.</param>
+        /// <returns>The result of the multiplication.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Multiply(Quaternion<T> value1, T value2)
+            => value1 * value2;
+
+        /// <summary>Flips the sign of each component of the quaternion.</summary>
+        /// <param name="value">The source Quaternion.</param>
+        /// <returns>The negated Quaternion.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Negate(Quaternion<T> value)
+            => -value;
+
+        /// <summary>Divides each component of the Quaternion by the length of the Quaternion.</summary>
+        /// <param name="value">The source Quaternion.</param>
+        /// <returns>The normalized Quaternion.</returns>
+        public static Quaternion<T> Normalize(Quaternion<T> value)
+        {
+            Quaternion<T> ans;
+
+            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
+            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
+
+            ans.X = Scalar.Multiply(value.X, invNorm);
+            ans.Y = Scalar.Multiply(value.Y, invNorm);
+            ans.Z = Scalar.Multiply(value.Z, invNorm);
+            ans.W = Scalar.Multiply(value.W, invNorm);
+
+            return ans;
+        }
+
+        /// <summary>Interpolates between two quaternions, using spherical linear interpolation.</summary>
+        /// <param name="quaternion1">The first source Quaternion.</param>
+        /// <param name="quaternion2">The second source Quaternion.</param>
+        /// <param name="amount">The relative weight of the second source Quaternion in the interpolation.</param>
+        /// <returns>The interpolated Quaternion.</returns>
+        public static Quaternion<T> Slerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
+        {
+            T t = amount;
+
+            T cosOmega = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X), Scalar.Multiply(quaternion1.Y, quaternion2.Y)), Scalar.Multiply(quaternion1.Z, quaternion2.Z)), Scalar.Multiply(quaternion1.W, quaternion2.W));
+
+            bool flip = false;
+
+            if (!Scalar.GreaterThanOrEqual(cosOmega, Scalar<T>.Zero))
+            {
+                flip = true;
+                cosOmega = Scalar.Negate(cosOmega);
+            }
+
+            T s1, s2;
+
+            if (Scalar.GreaterThan(cosOmega, Scalar.Subtract(Scalar<T>.One, Scalar.As<float, T>(SlerpEpsilon))))
+            {
+                // Too close, do straight linear interpolation.
+                s1 = Scalar.Subtract(Scalar<T>.One, t);
+                s2 = flip ? Scalar.Negate(t) : t;
+            }
+            else
+            {
+                T omega = Scalar.Acos(cosOmega);
+                T invSinOmega = Scalar.Reciprocal(Scalar.Sin(omega));
+
+                s1 = Scalar.Multiply(Scalar.Sin(Scalar.Multiply(Scalar.Subtract(Scalar<T>.One, t), omega)), invSinOmega);
+                s2 = (flip)
+                    ? Scalar.Negate(Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega))
+                    : Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega);
+            }
+
+            Quaternion<T> ans;
+
+            ans.X = Scalar.Add(Scalar.Multiply(s1, quaternion1.X), Scalar.Multiply(s2, quaternion2.X));
+            ans.Y = Scalar.Add(Scalar.Multiply(s1, quaternion1.Y), Scalar.Multiply(s2, quaternion2.Y));
+            ans.Z = Scalar.Add(Scalar.Multiply(s1, quaternion1.Z), Scalar.Multiply(s2, quaternion2.Z));
+            ans.W = Scalar.Add(Scalar.Multiply(s1, quaternion1.W), Scalar.Multiply(s2, quaternion2.W));
+
+            return ans;
+        }
+
+        /// <summary>Subtracts one Quaternion from another.</summary>
+        /// <param name="value1">The first source Quaternion.</param>
+        /// <param name="value2">The second Quaternion, to be subtracted from the first.</param>
+        /// <returns>The result of the subtraction.</returns>
+        [MethodImpl((MethodImplOptions) 768)]
+        public static Quaternion<T> Subtract(Quaternion<T> value1, Quaternion<T> value2)
+            => value1 - value2;
+
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this Quaternion instance.</summary>
+        /// <param name="obj">The Object to compare against.</param>
+        /// <returns>True if the Object is equal to this Quaternion; False otherwise.</returns>
+        public override readonly bool Equals(object? obj)
+            => (obj is Quaternion<T> other) && Equals(other);
+
+        /// <summary>Returns a boolean indicating whether the given Quaternion is equal to this Quaternion instance.</summary>
+        /// <param name="other">The Quaternion to compare this instance to.</param>
+        /// <returns>True if the other Quaternion is equal to this instance; False otherwise.</returns>
+        public readonly bool Equals(Quaternion<T> other)
+            => this == other;
+
+        /// <summary>Returns the hash code for this instance.</summary>
+        /// <returns>The hash code.</returns>
+        public override readonly int GetHashCode()
+        {
+            return unchecked(X.GetHashCode() + Y.GetHashCode() + Z.GetHashCode() + W.GetHashCode());
+        }
+
+        /// <summary>Calculates the length of the Quaternion.</summary>
+        /// <returns>The computed length of the Quaternion.</returns>
+        public readonly T Length()
+            => Scalar.Sqrt(LengthSquared());
+
+        /// <summary>Calculates the length squared of the Quaternion. This operation is cheaper than Length().</summary>
+        /// <returns>The length squared of the Quaternion.</returns>
+        public readonly T LengthSquared()
+            => Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(X, X), Scalar.Multiply(Y, Y)), Scalar.Multiply(Z, Z)), Scalar.Multiply(W, W));
+
+        /// <summary>Returns a String representing this Quaternion instance.</summary>
+        /// <returns>The string representation.</returns>
+        public override readonly string ToString()
+        {
+            return string.Format(CultureInfo.CurrentCulture, "{{X:{0} Y:{1} Z:{2} W:{3}}}", X, Y, Z, W);
+        }
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Quaternion<Half>(Quaternion<T> from)
+            => new(Scalar.As<T, Half>(from.X), Scalar.As<T, Half>(from.Y), Scalar.As<T, Half>(from.Z),
+                Scalar.As<T, Half>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Quaternion<float>(Quaternion<T> from)
+            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
+                Scalar.As<T, float>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into <see cref="System.Numerics.Quaternion"/>
+        /// </summary>
+        /// <param name="from">The source quaternion</param>
+        /// <returns>The <see cref="System.Numerics"/> quaternion</returns>
+        public static explicit operator System.Numerics.Quaternion(Quaternion<T> from)
+            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
+                Scalar.As<T, float>(from.W));
+        
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Quaternion<double>(Quaternion<T> from)
+            => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y), Scalar.As<T, double>(from.Z),
+                Scalar.As<T, double>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Quaternion<decimal>(Quaternion<T> from)
+            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y), Scalar.As<T, decimal>(from.Z),
+                Scalar.As<T, decimal>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Quaternion<sbyte>(Quaternion<T> from)
+            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y), Scalar.As<T, sbyte>(from.Z),
+                Scalar.As<T, sbyte>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Quaternion<byte>(Quaternion<T> from)
+            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y), Scalar.As<T, byte>(from.Z),
+                Scalar.As<T, byte>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Quaternion<ushort>(Quaternion<T> from)
+            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y), Scalar.As<T, ushort>(from.Z),
+                Scalar.As<T, ushort>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Quaternion<short>(Quaternion<T> from)
+            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y), Scalar.As<T, short>(from.Z),
+                Scalar.As<T, short>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Quaternion<uint>(Quaternion<T> from)
+            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y), Scalar.As<T, uint>(from.Z),
+                Scalar.As<T, uint>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Quaternion<int>(Quaternion<T> from)
+            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y), Scalar.As<T, int>(from.Z),
+                Scalar.As<T, int>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Quaternion<ulong>(Quaternion<T> from)
+            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y), Scalar.As<T, ulong>(from.Z),
+                Scalar.As<T, ulong>(from.W));
+
+        /// <summary>
+        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Quaternion<long>(Quaternion<T> from)
+            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y), Scalar.As<T, long>(from.Z),
+                Scalar.As<T, long>(from.W));
+        
+        /// <summary>
+        /// Returns this quaternion casted to <typeparamref name="TOther"></typeparamref>
+        /// </summary>
+        /// <typeparam name="TOther">The type to cast to</typeparam>
+        /// <returns>The casted quaternion</returns>
+        public Quaternion<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        {
+            return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z), Scalar.As<T, TOther>(W));
+        }
+    }
+}
diff --git a/sources/Maths/Maths/Quaternion.cs b/sources/Maths/Maths/Quaternion.cs
index 67f99086a2..fc7921fb15 100644
--- a/sources/Maths/Maths/Quaternion.cs
+++ b/sources/Maths/Maths/Quaternion.cs
@@ -2,37 +2,31 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
-using System.Globalization;
-using System.Runtime.CompilerServices;
-using System.Runtime.Serialization;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
 
 namespace Silk.NET.Maths
 {
     /// <summary>
-    /// Represents a vector that is used to encode three-dimensional physical rotations.
+    /// Represents a four-dimensional vector used to encode 3D rotations.
     /// </summary>
-    /// <typeparam name="T">The type used to store values.</typeparam>
-    [Serializable]
-    [DataContract]
-    public struct Quaternion<T>
-        : IEquatable<Quaternion<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    internal struct Quaternion<T> :
+        IEquatable<Quaternion<T>>
+        where T : IBinaryFloatingPointIeee754<T>
     {
-        private const float SlerpEpsilon = 1e-6f;
-
         /// <summary>Specifies the X-value of the vector component of the Quaternion.</summary>
-        [DataMember]
         public T X;
 
         /// <summary>Specifies the Y-value of the vector component of the Quaternion.</summary>
-        [DataMember]
         public T Y;
 
         /// <summary>Specifies the Z-value of the vector component of the Quaternion.</summary>
-        [DataMember]
         public T Z;
 
-        /// <summary>Specifies the rotation component of the Quaternion.</summary>
-        [DataMember]
+        /// <summary>Specifies the W-value of the scalar component of the Quaternion.</summary>
         public T W;
 
         /// <summary>Constructs a Quaternion from the given components.</summary>
@@ -48,746 +42,29 @@ public Quaternion(T x, T y, T z, T w)
             W = w;
         }
 
-        /// <summary>Constructs a Quaternion from the given vector and rotation parts.</summary>
-        /// <param name="vectorPart">The vector part of the Quaternion.</param>
-        /// <param name="scalarPart">The rotation part of the Quaternion.</param>
-        public Quaternion(Vector3D<T> vectorPart, T scalarPart)
-        {
-            X = vectorPart.X;
-            Y = vectorPart.Y;
-            Z = vectorPart.Z;
-            W = scalarPart;
-        }
+        // TODO: Vector4F/Vector3F constructors
 
         /// <summary>Returns a Quaternion representing no rotation.</summary>
-        public static Quaternion<T> Identity => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Returns whether the Quaternion is the identity Quaternion.</summary>
-        [IgnoreDataMember]
-        public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Adds two Quaternions element-by-element.</summary>
-        /// <param name="value1">The first source Quaternion.</param>
-        /// <param name="value2">The second source Quaternion.</param>
-        /// <returns>The result of adding the Quaternions.</returns>
-        public static Quaternion<T> operator +(Quaternion<T> value1, Quaternion<T> value2)
-        {
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Add(value1.X, value2.X);
-            ans.Y = Scalar.Add(value1.Y, value2.Y);
-            ans.Z = Scalar.Add(value1.Z, value2.Z);
-            ans.W = Scalar.Add(value1.W, value2.W);
-
-            return ans;
-        }
-
-        /// <summary>Divides a Quaternion by another Quaternion.</summary>
-        /// <param name="value1">The source Quaternion.</param>
-        /// <param name="value2">The divisor.</param>
-        /// <returns>The result of the division.</returns>
-        public static Quaternion<T> operator /(Quaternion<T> value1, Quaternion<T> value2)
-        {
-            Quaternion<T> ans;
-
-            T q1x = value1.X;
-            T q1y = value1.Y;
-            T q1z = value1.Z;
-            T q1w = value1.W;
-
-            //-------------------------------------
-            // Inverse part.
-            T ls = Scalar.Add(
-                Scalar.Add(
-                    Scalar.Add(Scalar.Multiply(value2.X, value2.X), Scalar.Multiply(value2.Y, value2.Y)),
-                    Scalar.Multiply(value2.Z, value2.Z)), Scalar.Multiply(value2.W, value2.W));
-            T invNorm = Scalar.Reciprocal(ls);
-
-            T q2x = Scalar.Negate(Scalar.Multiply(value2.X, invNorm));
-            T q2y = Scalar.Negate(Scalar.Multiply(value2.Y, invNorm));
-            T q2z = Scalar.Negate(Scalar.Multiply(value2.Z, invNorm));
-            T q2w = Scalar.Multiply(value2.W, invNorm);
-
-            //-------------------------------------
-            // Multiply part.
-
-            // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
-
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
-                Scalar.Multiply(q1z, q2z));
-
-            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
-            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
-            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
-            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
-
-            return ans;
-        }
-
-        /// <summary>Returns a boolean indicating whether the two given Quaternions are equal.</summary>
-        /// <param name="value1">The first Quaternion to compare.</param>
-        /// <param name="value2">The second Quaternion to compare.</param>
-        /// <returns>True if the Quaternions are equal; False otherwise.</returns>
-        public static bool operator ==(Quaternion<T> value1, Quaternion<T> value2)
-            => Scalar.Equal(value1.X, value2.X)
-            && Scalar.Equal(value1.Y, value2.Y)
-            && Scalar.Equal(value1.Z, value2.Z)
-            && Scalar.Equal(value1.W, value2.W);
-
-        /// <summary>Returns a boolean indicating whether the two given Quaternions are not equal.</summary>
-        /// <param name="value1">The first Quaternion to compare.</param>
-        /// <param name="value2">The second Quaternion to compare.</param>
-        /// <returns>True if the Quaternions are not equal; False if they are equal.</returns>
-        public static bool operator !=(Quaternion<T> value1, Quaternion<T> value2)
-            => !(value1 == value2);
-
-        /// <summary>Multiplies two Quaternions together.</summary>
-        /// <param name="value1">The Quaternion on the left side of the multiplication.</param>
-        /// <param name="value2">The Quaternion on the right side of the multiplication.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Quaternion<T> operator *(Quaternion<T> value1, Quaternion<T> value2)
-        {
-            Quaternion<T> ans;
-
-            T q1x = value1.X;
-            T q1y = value1.Y;
-            T q1z = value1.Z;
-            T q1w = value1.W;
-
-            T q2x = value2.X;
-            T q2y = value2.Y;
-            T q2z = value2.Z;
-            T q2w = value2.W;
-
-            // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
-
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
-                Scalar.Multiply(q1z, q2z));
-
-            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
-            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
-            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
-            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
-
-            return ans;
-        }
-
-        /// <summary>Multiplies a Quaternion by a scalar value.</summary>
-        /// <param name="value1">The source Quaternion.</param>
-        /// <param name="value2">The scalar value.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Quaternion<T> operator *(Quaternion<T> value1, T value2)
-        {
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Multiply(value1.X, value2);
-            ans.Y = Scalar.Multiply(value1.Y, value2);
-            ans.Z = Scalar.Multiply(value1.Z, value2);
-            ans.W = Scalar.Multiply(value1.W, value2);
-
-            return ans;
-        }
-
-        /// <summary>Subtracts one Quaternion from another.</summary>
-        /// <param name="value1">The first source Quaternion.</param>
-        /// <param name="value2">The second Quaternion, to be subtracted from the first.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Quaternion<T> operator -(Quaternion<T> value1, Quaternion<T> value2)
-        {
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Subtract(value1.X, value2.X);
-            ans.Y = Scalar.Subtract(value1.Y, value2.Y);
-            ans.Z = Scalar.Subtract(value1.Z, value2.Z);
-            ans.W = Scalar.Subtract(value1.W, value2.W);
-
-            return ans;
-        }
-
-        /// <summary>Flips the sign of each component of the quaternion.</summary>
-        /// <param name="value">The source Quaternion.</param>
-        /// <returns>The negated Quaternion.</returns>
-        public static Quaternion<T> operator -(Quaternion<T> value)
-        {
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Negate(value.X);
-            ans.Y = Scalar.Negate(value.Y);
-            ans.Z = Scalar.Negate(value.Z);
-            ans.W = Scalar.Negate(value.W);
-
-            return ans;
-        }
-
-        /// <summary>Adds two Quaternions element-by-element.</summary>
-        /// <param name="value1">The first source Quaternion.</param>
-        /// <param name="value2">The second source Quaternion.</param>
-        /// <returns>The result of adding the Quaternions.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Add(Quaternion<T> value1, Quaternion<T> value2)
-            => value1 + value2;
-
-        /// <summary>Concatenates two Quaternions; the result represents the value1 rotation followed by the value2 rotation.</summary>
-        /// <param name="value1">The first Quaternion rotation in the series.</param>
-        /// <param name="value2">The second Quaternion rotation in the series.</param>
-        /// <returns>A new Quaternion representing the concatenation of the value1 rotation followed by the value2 rotation.</returns>
-        public static Quaternion<T> Concatenate(Quaternion<T> value1, Quaternion<T> value2)
-        {
-            Quaternion<T> ans;
-
-            // Concatenate rotation is actually q2 * q1 instead of q1 * q2.
-            // So that's why value2 goes q1 and value1 goes q2.
-            T q1x = value2.X;
-            T q1y = value2.Y;
-            T q1z = value2.Z;
-            T q1w = value2.W;
-
-            T q2x = value1.X;
-            T q2y = value1.Y;
-            T q2z = value1.Z;
-            T q2w = value1.W;
-
-            // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
-
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
-                Scalar.Multiply(q1z, q2z));
-
-            ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
-            ans.Y = Scalar.Add(Scalar.Add(Scalar.Multiply(q1y, q2w), Scalar.Multiply(q2y, q1w)), cy);
-            ans.Z = Scalar.Add(Scalar.Add(Scalar.Multiply(q1z, q2w), Scalar.Multiply(q2z, q1w)), cz);
-            ans.W = Scalar.Subtract(Scalar.Multiply(q1w, q2w), dot);
-
-            return ans;
-        }
-
-        /// <summary>Creates the conjugate of a specified Quaternion.</summary>
-        /// <param name="value">The Quaternion of which to return the conjugate.</param>
-        /// <returns>A new Quaternion that is the conjugate of the specified one.</returns>
-        public static Quaternion<T> Conjugate(Quaternion<T> value)
-        {
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Negate(value.X);
-            ans.Y = Scalar.Negate(value.Y);
-            ans.Z = Scalar.Negate(value.Z);
-            ans.W = value.W;
-
-            return ans;
-        }
-
-        /// <summary>Creates a Quaternion from a normalized vector axis and an angle to rotate about the vector.</summary>
-        /// <param name="axis">The unit vector to rotate around.
-        /// This vector must be normalized before calling this function or the resulting Quaternion will be incorrect.</param>
-        /// <param name="angle">The angle, in radians, to rotate around the vector.</param>
-        /// <returns>The created Quaternion.</returns>
-        public static Quaternion<T> CreateFromAxisAngle(Vector3D<T> axis, T angle)
-        {
-            Quaternion<T> ans;
-
-            T halfAngle = Scalar.Divide(angle, Scalar<T>.Two);
-            T s = Scalar.Sin(halfAngle);
-            T c = Scalar.Cos(halfAngle);
-
-            ans.X = Scalar.Multiply(axis.X, s);
-            ans.Y = Scalar.Multiply(axis.Y, s);
-            ans.Z = Scalar.Multiply(axis.Z, s);
-            ans.W = c;
-
-            return ans;
-        }
-
-        /// <summary>Creates a Quaternion from the given rotation matrix.</summary>
-        /// <param name="matrix">The rotation matrix.</param>
-        /// <returns>The created Quaternion.</returns>
-        public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
-        {
-            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
-
-            Quaternion<T> q = default;
-
-            if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
-            {
-                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
-                q.W = Scalar.Divide(s, Scalar<T>.Two);
-                s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
-                q.Y = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), s);
-                q.Z = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), s);
-            }
-            else
-            {
-                if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Divide(s, Scalar<T>.Two);
-                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
-                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), invS);
-                }
-                else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
-                    q.Y = Scalar.Divide(s, Scalar<T>.Two);
-                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), invS);
-                }
-                else
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
-                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
-                    q.Z = Scalar.Divide(s, Scalar<T>.Two);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), invS);
-                }
-            }
-
-            return q;
-        }
-
-        /// <summary>Creates a Quaternion from the given rotation matrix.</summary>
-        /// <param name="matrix">The rotation matrix.</param>
-        /// <returns>The created Quaternion.</returns>
-        public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
-        {
-            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
-
-            Quaternion<T> q = default;
-
-            if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
-            {
-                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
-                q.W = Scalar.Divide(s, Scalar<T>.Two);
-                s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
-                q.Y = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), s);
-                q.Z = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), s);
-            }
-            else
-            {
-                if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Divide(s, Scalar<T>.Two);
-                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
-                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), invS);
-                }
-                else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
-                    q.Y = Scalar.Divide(s, Scalar<T>.Two);
-                    q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M31, matrix.M13), invS);
-                }
-                else
-                {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
-                    q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
-                    q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
-                    q.Z = Scalar.Divide(s, Scalar<T>.Two);
-                    q.W = Scalar.Multiply(Scalar.Subtract(matrix.M12, matrix.M21), invS);
-                }
-            }
-
-            return q;
-        }
-
-        /// <summary>Creates a new Quaternion from the given yaw, pitch, and roll, in radians.</summary>
-        /// <param name="yaw">The yaw angle, in radians, around the Y-axis.</param>
-        /// <param name="pitch">The pitch angle, in radians, around the X-axis.</param>
-        /// <param name="roll">The roll angle, in radians, around the Z-axis.</param>
-        /// <returns></returns>
-        public static Quaternion<T> CreateFromYawPitchRoll(T yaw, T pitch, T roll)
-        {
-            //  Roll first, about axis the object is facing, then
-            //  pitch upward, then yaw to face into the new heading
-            T sr, cr, sp, cp, sy, cy;
-
-            T halfRoll = Scalar.Divide(roll, Scalar<T>.Two);
-            sr = Scalar.Sin(halfRoll);
-            cr = Scalar.Cos(halfRoll);
-
-            T halfPitch = Scalar.Divide(pitch, Scalar<T>.Two);
-            sp = Scalar.Sin(halfPitch);
-            cp = Scalar.Cos(halfPitch);
-
-            T halfYaw = Scalar.Divide(yaw, Scalar<T>.Two);
-            sy = Scalar.Sin(halfYaw);
-            cy = Scalar.Cos(halfYaw);
-
-            Quaternion<T> result;
-
-            result.X = Scalar.Add(Scalar.Multiply(Scalar.Multiply(cy, sp), cr), Scalar.Multiply(Scalar.Multiply(sy, cp), sr));
-            result.Y = Scalar.Subtract(Scalar.Multiply(Scalar.Multiply(sy, cp), cr), Scalar.Multiply(Scalar.Multiply(cy, sp), sr));
-            result.Z = Scalar.Subtract(Scalar.Multiply(Scalar.Multiply(cy, cp), sr), Scalar.Multiply(Scalar.Multiply(sy, sp), cr));
-            result.W = Scalar.Add(Scalar.Multiply(Scalar.Multiply(cy, cp), cr), Scalar.Multiply(Scalar.Multiply(sy, sp), sr));
-
-            return result;
-        }
-
-        /// <summary>Divides a Quaternion by another Quaternion.</summary>
-        /// <param name="value1">The source Quaternion.</param>
-        /// <param name="value2">The divisor.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Divide(Quaternion<T> value1, Quaternion<T> value2)
-            => value1 / value2;
-
-        /// <summary>Calculates the dot product of two Quaternions.</summary>
-        /// <param name="quaternion1">The first source Quaternion.</param>
-        /// <param name="quaternion2">The second source Quaternion.</param>
-        /// <returns>The dot product of the Quaternions.</returns>
-        public static T Dot(Quaternion<T> quaternion1, Quaternion<T> quaternion2)
-        {
-            return Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X),
-                   Scalar.Multiply(quaternion1.Y, quaternion2.Y)),
-                   Scalar.Multiply(quaternion1.Z, quaternion2.Z)),
-                   Scalar.Multiply(quaternion1.W, quaternion2.W));
-        }
-
-        /// <summary>Returns the inverse of a Quaternion.</summary>
-        /// <param name="value">The source Quaternion.</param>
-        /// <returns>The inverted Quaternion.</returns>
-        public static Quaternion<T> Inverse(Quaternion<T> value)
-        {
-            //  -1   (       a              -v       )
-            // q   = ( -------------   ------------- )
-            //       (  a^2 + |v|^2  ,  a^2 + |v|^2  )
-
-            Quaternion<T> ans;
-
-            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
-            T invNorm = Scalar.Reciprocal(ls);
-
-            ans.X = Scalar.Negate(Scalar.Multiply(value.X, invNorm));
-            ans.Y = Scalar.Negate(Scalar.Multiply(value.Y, invNorm));
-            ans.Z = Scalar.Negate(Scalar.Multiply(value.Z, invNorm));
-            ans.W = Scalar.Multiply(value.W, invNorm);
-
-            return ans;
-        }
-
-        /// <summary> Linearly interpolates between two quaternions.</summary>
-        /// <param name="quaternion1">The first source Quaternion.</param>
-        /// <param name="quaternion2">The second source Quaternion.</param>
-        /// <param name="amount">The relative weight of the second source Quaternion in the interpolation.</param>
-        /// <returns>The interpolated Quaternion.</returns>
-        public static Quaternion<T> Lerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
-        {
-            T t = amount;
-            T t1 = Scalar.Subtract(Scalar<T>.One, t);
-
-            Quaternion<T> r = default;
-
-            T dot = Scalar.Add(
-                Scalar.Add(
-                    Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X),
-                        Scalar.Multiply(quaternion1.Y, quaternion2.Y)),
-                    Scalar.Multiply(quaternion1.Z, quaternion2.Z)),
-                Scalar.Multiply(quaternion1.W, quaternion2.W));
-
-            if (Scalar.GreaterThanOrEqual(dot, Scalar<T>.Zero))
-            {
-                r.X = Scalar.Add(Scalar.Multiply(t1, quaternion1.X), Scalar.Multiply(t, quaternion2.X));
-                r.Y = Scalar.Add(Scalar.Multiply(t1, quaternion1.Y), Scalar.Multiply(t, quaternion2.Y));
-                r.Z = Scalar.Add(Scalar.Multiply(t1, quaternion1.Z), Scalar.Multiply(t, quaternion2.Z));
-                r.W = Scalar.Add(Scalar.Multiply(t1, quaternion1.W), Scalar.Multiply(t, quaternion2.W));
-            }
-            else
-            {
-                r.X = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.X), Scalar.Multiply(t, quaternion2.X));
-                r.Y = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.Y), Scalar.Multiply(t, quaternion2.Y));
-                r.Z = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.Z), Scalar.Multiply(t, quaternion2.Z));
-                r.W = Scalar.Subtract(Scalar.Multiply(t1, quaternion1.W), Scalar.Multiply(t, quaternion2.W));
-            }
-
-            // Normalize it.
-            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(r.X, r.X), Scalar.Multiply(r.Y, r.Y)), Scalar.Multiply(r.Z, r.Z)), Scalar.Multiply(r.W, r.W));
-            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
-
-            r.X = Scalar.Multiply(r.X, invNorm);
-            r.Y = Scalar.Multiply(r.Y, invNorm);
-            r.Z = Scalar.Multiply(r.Z, invNorm);
-            r.W = Scalar.Multiply(r.W, invNorm);
-
-            return r;
-        }
-
-        /// <summary>Multiplies two Quaternions together.</summary>
-        /// <param name="value1">The Quaternion on the left side of the multiplication.</param>
-        /// <param name="value2">The Quaternion on the right side of the multiplication.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Multiply(Quaternion<T> value1, Quaternion<T> value2)
-            => value1 * value2;
-
-        /// <summary>Multiplies a Quaternion by a scalar value.</summary>
-        /// <param name="value1">The source Quaternion.</param>
-        /// <param name="value2">The scalar value.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Multiply(Quaternion<T> value1, T value2)
-            => value1 * value2;
-
-        /// <summary>Flips the sign of each component of the quaternion.</summary>
-        /// <param name="value">The source Quaternion.</param>
-        /// <returns>The negated Quaternion.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Negate(Quaternion<T> value)
-            => -value;
-
-        /// <summary>Divides each component of the Quaternion by the length of the Quaternion.</summary>
-        /// <param name="value">The source Quaternion.</param>
-        /// <returns>The normalized Quaternion.</returns>
-        public static Quaternion<T> Normalize(Quaternion<T> value)
-        {
-            Quaternion<T> ans;
-
-            T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
-            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
-
-            ans.X = Scalar.Multiply(value.X, invNorm);
-            ans.Y = Scalar.Multiply(value.Y, invNorm);
-            ans.Z = Scalar.Multiply(value.Z, invNorm);
-            ans.W = Scalar.Multiply(value.W, invNorm);
-
-            return ans;
-        }
-
-        /// <summary>Interpolates between two quaternions, using spherical linear interpolation.</summary>
-        /// <param name="quaternion1">The first source Quaternion.</param>
-        /// <param name="quaternion2">The second source Quaternion.</param>
-        /// <param name="amount">The relative weight of the second source Quaternion in the interpolation.</param>
-        /// <returns>The interpolated Quaternion.</returns>
-        public static Quaternion<T> Slerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
-        {
-            T t = amount;
-
-            T cosOmega = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X), Scalar.Multiply(quaternion1.Y, quaternion2.Y)), Scalar.Multiply(quaternion1.Z, quaternion2.Z)), Scalar.Multiply(quaternion1.W, quaternion2.W));
-
-            bool flip = false;
-
-            if (!Scalar.GreaterThanOrEqual(cosOmega, Scalar<T>.Zero))
-            {
-                flip = true;
-                cosOmega = Scalar.Negate(cosOmega);
-            }
-
-            T s1, s2;
-
-            if (Scalar.GreaterThan(cosOmega, Scalar.Subtract(Scalar<T>.One, Scalar.As<float, T>(SlerpEpsilon))))
-            {
-                // Too close, do straight linear interpolation.
-                s1 = Scalar.Subtract(Scalar<T>.One, t);
-                s2 = flip ? Scalar.Negate(t) : t;
-            }
-            else
-            {
-                T omega = Scalar.Acos(cosOmega);
-                T invSinOmega = Scalar.Reciprocal(Scalar.Sin(omega));
-
-                s1 = Scalar.Multiply(Scalar.Sin(Scalar.Multiply(Scalar.Subtract(Scalar<T>.One, t), omega)), invSinOmega);
-                s2 = (flip)
-                    ? Scalar.Negate(Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega))
-                    : Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega);
-            }
-
-            Quaternion<T> ans;
-
-            ans.X = Scalar.Add(Scalar.Multiply(s1, quaternion1.X), Scalar.Multiply(s2, quaternion2.X));
-            ans.Y = Scalar.Add(Scalar.Multiply(s1, quaternion1.Y), Scalar.Multiply(s2, quaternion2.Y));
-            ans.Z = Scalar.Add(Scalar.Multiply(s1, quaternion1.Z), Scalar.Multiply(s2, quaternion2.Z));
-            ans.W = Scalar.Add(Scalar.Multiply(s1, quaternion1.W), Scalar.Multiply(s2, quaternion2.W));
-
-            return ans;
-        }
-
-        /// <summary>Subtracts one Quaternion from another.</summary>
-        /// <param name="value1">The first source Quaternion.</param>
-        /// <param name="value2">The second Quaternion, to be subtracted from the first.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Quaternion<T> Subtract(Quaternion<T> value1, Quaternion<T> value2)
-            => value1 - value2;
+        public static Quaternion<T> Identity => new Quaternion<T>(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this Quaternion instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this Quaternion; False otherwise.</returns>
-        public override readonly bool Equals(object? obj)
-            => (obj is Quaternion<T> other) && Equals(other);
+        public override bool Equals(object? obj) =>
+            obj is Quaternion<T> other && Equals(other);
 
         /// <summary>Returns a boolean indicating whether the given Quaternion is equal to this Quaternion instance.</summary>
-        /// <param name="other">The Quaternion to compare this instance to.</param>
-        /// <returns>True if the other Quaternion is equal to this instance; False otherwise.</returns>
-        public readonly bool Equals(Quaternion<T> other)
-            => this == other;
+        public bool Equals(Quaternion<T> other) =>
+            this == other;
 
         /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode()
-        {
-            return unchecked(X.GetHashCode() + Y.GetHashCode() + Z.GetHashCode() + W.GetHashCode());
-        }
-
-        /// <summary>Calculates the length of the Quaternion.</summary>
-        /// <returns>The computed length of the Quaternion.</returns>
-        public readonly T Length()
-            => Scalar.Sqrt(LengthSquared());
-
-        /// <summary>Calculates the length squared of the Quaternion. This operation is cheaper than Length().</summary>
-        /// <returns>The length squared of the Quaternion.</returns>
-        public readonly T LengthSquared()
-            => Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(X, X), Scalar.Multiply(Y, Y)), Scalar.Multiply(Z, Z)), Scalar.Multiply(W, W));
-
-        /// <summary>Returns a String representing this Quaternion instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{X:{0} Y:{1} Z:{2} W:{3}}}", X, Y, Z, W);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Quaternion<Half>(Quaternion<T> from)
-            => new(Scalar.As<T, Half>(from.X), Scalar.As<T, Half>(from.Y), Scalar.As<T, Half>(from.Z),
-                Scalar.As<T, Half>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Quaternion<float>(Quaternion<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
-                Scalar.As<T, float>(from.W));
+        public override int GetHashCode() =>
+            HashCode.Combine(X, Y, Z, W);
 
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into <see cref="System.Numerics.Quaternion"/>
-        /// </summary>
-        /// <param name="from">The source quaternion</param>
-        /// <returns>The <see cref="System.Numerics"/> quaternion</returns>
-        public static explicit operator System.Numerics.Quaternion(Quaternion<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
-                Scalar.As<T, float>(from.W));
-        
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Quaternion<double>(Quaternion<T> from)
-            => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y), Scalar.As<T, double>(from.Z),
-                Scalar.As<T, double>(from.W));
 
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Quaternion<decimal>(Quaternion<T> from)
-            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y), Scalar.As<T, decimal>(from.Z),
-                Scalar.As<T, decimal>(from.W));
+        // Equality Operators
+        public static bool operator ==(Quaternion<T> left, Quaternion<T> right) =>
+            left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
 
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Quaternion<sbyte>(Quaternion<T> from)
-            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y), Scalar.As<T, sbyte>(from.Z),
-                Scalar.As<T, sbyte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Quaternion<byte>(Quaternion<T> from)
-            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y), Scalar.As<T, byte>(from.Z),
-                Scalar.As<T, byte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Quaternion<ushort>(Quaternion<T> from)
-            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y), Scalar.As<T, ushort>(from.Z),
-                Scalar.As<T, ushort>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Quaternion<short>(Quaternion<T> from)
-            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y), Scalar.As<T, short>(from.Z),
-                Scalar.As<T, short>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Quaternion<uint>(Quaternion<T> from)
-            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y), Scalar.As<T, uint>(from.Z),
-                Scalar.As<T, uint>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Quaternion<int>(Quaternion<T> from)
-            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y), Scalar.As<T, int>(from.Z),
-                Scalar.As<T, int>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Quaternion<ulong>(Quaternion<T> from)
-            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y), Scalar.As<T, ulong>(from.Z),
-                Scalar.As<T, ulong>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Quaternion<long>(Quaternion<T> from)
-            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y), Scalar.As<T, long>(from.Z),
-                Scalar.As<T, long>(from.W));
-        
-        /// <summary>
-        /// Returns this quaternion casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted quaternion</returns>
-        public Quaternion<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
-        {
-            return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z), Scalar.As<T, TOther>(W));
-        }
+        public static bool operator !=(Quaternion<T> left, Quaternion<T> right) =>
+            !(left == right);
     }
-}
\ No newline at end of file
+}

From cc7ebb62218e2ce42526c31fe899647b00159b26 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Wed, 28 May 2025 23:14:09 +1000
Subject: [PATCH 12/52] Clarify current state of new Math type's indexers.

---
 sources/Maths/Maths/Quaternion.cs | 19 ++++++++++++++++---
 sources/Maths/Maths/Vector2I.cs   |  1 +
 sources/Maths/Maths/Vector3I.cs   |  1 +
 sources/Maths/Maths/Vector4I.cs   |  1 +
 4 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/sources/Maths/Maths/Quaternion.cs b/sources/Maths/Maths/Quaternion.cs
index fc7921fb15..4df87b736a 100644
--- a/sources/Maths/Maths/Quaternion.cs
+++ b/sources/Maths/Maths/Quaternion.cs
@@ -42,16 +42,29 @@ public Quaternion(T x, T y, T z, T w)
             W = w;
         }
 
+        /// <summary>Gets the rotation angle represented by the <see cref="Quaternion{T}"/>.</summary>
+        public T Angle => T.CreateChecked(2) * T.Acos(W);
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
+        // TODO: Make this a ref
+        public T this[int index] => index switch {
+            0 => X,
+            1 => Y,
+            2 => Z,
+            3 => W,
+            _ => throw new IndexOutOfRangeException(nameof(index))
+        };
+
         // TODO: Vector4F/Vector3F constructors
 
-        /// <summary>Returns a Quaternion representing no rotation.</summary>
+        /// <summary>Returns a <see cref="Quaternion{T}"/> representing no rotation.</summary>
         public static Quaternion<T> Identity => new Quaternion<T>(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
 
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this Quaternion instance.</summary>
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Quaternion{T}"/> instance.</summary>
         public override bool Equals(object? obj) =>
             obj is Quaternion<T> other && Equals(other);
 
-        /// <summary>Returns a boolean indicating whether the given Quaternion is equal to this Quaternion instance.</summary>
+        /// <summary>Returns a boolean indicating whether the given <see cref="Quaternion{T}"/> is equal to this <see cref="Quaternion{T}"/> instance.</summary>
         public bool Equals(Quaternion<T> other) =>
             this == other;
 
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index ab8ba58dfc..2fde654cb2 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -66,6 +66,7 @@ public Vector2I(ReadOnlySpan<T> values)
         public int Count => 2;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
+        // TODO: Make this a ref
         public T this[int index] => index switch {
             0 => X,
             1 => Y,
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 357643abd9..83d14d802f 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -73,6 +73,7 @@ public Vector3I(ReadOnlySpan<T> values)
         public int Count => 3;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
+        // TODO: Make this a ref
         public T this[int index] => index switch {
             0 => X,
             1 => Y,
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index b1866d3f00..42a095e035 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -80,6 +80,7 @@ public Vector4I(ReadOnlySpan<T> values)
         public int Count => 4;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
+        // TODO: Make this a ref
         public T this[int index] => index switch {
             0 => X,
             1 => Y,

From 6af8612da32a4df532bee67a023cb9552de3912c Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Fri, 30 May 2025 17:56:20 +1000
Subject: [PATCH 13/52] Add lower-dimensional VectorI constructors.

---
 sources/Maths/Maths/Vector3I.cs | 4 ++++
 sources/Maths/Maths/Vector4I.cs | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 83d14d802f..9aa815c588 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -48,6 +48,10 @@ public Vector3I(ReadOnlySpan<T> values)
             Z = values[2];
         }
 
+        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z. </summary>
+        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
+        public Vector3I(Vector2I<T> xy, T z) => (X, Y, Z) = (xy.X, xy.Y, z);
+
         /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
         public static Vector3I<T> One => new(Scalar<T>.One);
 
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 42a095e035..038c4be24b 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -52,6 +52,13 @@ public Vector4I(ReadOnlySpan<T> values)
             W = values[3];
         }
 
+        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z and W. </summary>
+        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
+        public Vector4I(Vector2I<T> xy, T z, T w) => (X, Y, Z, W) = (xy.X, xy.Y, z, w);
+
+        /// <summary> Initializes the vector using a Vector3I for X, Y and Z, and a separate value for W. </summary>
+        public Vector4I(Vector3I<T> xyz, T w) => (X, Y, Z, W) = (xyz.X, xyz.Y, xyz.Z, w);
+
         /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
         public static Vector4I<T> One => new(Scalar<T>.One);
 

From 737b5a8d1b7963aaf35f48619936ef6aa07d11dc Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Fri, 30 May 2025 18:26:22 +1000
Subject: [PATCH 14/52] Add `Vector2F`.

---
 sources/Maths/Maths/Vector2F.cs | 669 ++++++++++++++++++++++++++++++++
 1 file changed, 669 insertions(+)
 create mode 100644 sources/Maths/Maths/Vector2F.cs

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
new file mode 100644
index 0000000000..6f563ced9e
--- /dev/null
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -0,0 +1,669 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System;
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Maths
+{
+    /// <summary>A structure representing a 2D floating-point vector.</summary>
+    internal struct Vector2F<T> :
+        IEquatable<Vector2F<T>>,
+        IReadOnlyList<T>,
+        ISpanFormattable,
+        ISpanParsable<Vector2F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2F<T>>,
+        IParsable<Vector2F<T>>,
+        IFormattable
+        where T : IBinaryFloatingPointIeee754<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>Initializes both components to the same value.</summary>
+        public Vector2F(T value) => (X, Y) = (value, value);
+
+        /// <summary>Initializes the vector with individual values for X and Y.</summary>
+        public Vector2F(T x, T y) => (X, Y) = (x, y);
+
+        /// <summary>Initializes the vector from a span of two values.</summary>
+        public Vector2F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector2F<T> AllBitsSet => new(T.AllBitsSet, T.AllBitsSet);
+
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => (X * X) + (Y * Y);
+
+        /// <summary>Gets the length of the vector.</summary>
+        public T Length => T.Sqrt(LengthSquared);
+
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 2;
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
+        public T this[int index] => index switch {
+            0 => X,
+            1 => Y,
+            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
+        };
+
+        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2F{T}"/> instance.</summary>
+        public override bool Equals(object? obj) => obj is Vector2F<T> other && Equals(other);
+
+        /// <summary>Returns a boolean indicating whether the given Vector2F is equal to this <see cref="Vector2F{T}"/> instance.</summary>
+        public bool Equals(Vector2F<T> other) => this == other;
+
+        /// <summary>Returns the hash code for this instance.</summary>
+        public override int GetHashCode() => HashCode.Combine(X, Y);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+        }
+
+        /// <summary> Computes the dot product of this vector with another vector. </summary>
+        public T Dot(Vector2F<T> other) => (X * other.X) + (Y * other.Y);
+
+        /// <summary> Computes the dot product of two vectors. </summary>
+        public static T Dot(Vector2F<T> left, Vector2F<T> right) => (left.X * right.X) + (left.Y * right.Y);
+
+        /// <summary> Computes the cross product of this vector with another vector. </summary>
+        public T Cross(Vector2F<T> other) => (X * other.Y) - (Y * other.X);
+
+        /// <summary> Computes the cross product of two vectors. </summary>
+        public static T Cross(Vector2F<T> left, Vector2F<T> right) => (left.X * right.Y) - (left.Y * right.X);
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Normalizes this vector.</summary>
+        public Vector2F<T> Normalize()
+        {
+            T length = Length;
+            return length != T.Zero ? this / length : Zero;
+        }
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector2F<T> Normalize(Vector2F<T> vector)
+        {
+            T length = vector.Length;
+            return length != T.Zero ? vector / length : Zero;
+        }
+
+        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
+        public Vector2F<T> Max(Vector2F<T> other) =>
+            new(T.Max(X, other.X), T.Max(Y, other.Y));
+
+        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
+        public static Vector2F<T> Max(Vector2F<T> left, Vector2F<T> right) =>
+            new(T.Max(left.X, right.X), T.Max(left.Y, right.Y));
+
+        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
+        public Vector2F<T> Max(T scalar) =>
+            new(T.Max(X, scalar), T.Max(Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
+        public static Vector2F<T> Max(Vector2F<T> vector, T scalar) =>
+            new(T.Max(vector.X, scalar), T.Max(vector.Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
+        public Vector2F<T> Min(Vector2F<T> other) =>
+            new(T.Min(X, other.X), T.Min(Y, other.Y));
+
+        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
+        public static Vector2F<T> Min(Vector2F<T> left, Vector2F<T> right) =>
+            new(T.Min(left.X, right.X), T.Min(left.Y, right.Y));
+
+        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
+        public Vector2F<T> Min(T scalar) =>
+            new(T.Min(X, scalar), T.Min(Y, scalar));
+
+        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
+        public static Vector2F<T> Min(Vector2F<T> vector, T scalar) =>
+            new(T.Min(vector.X, scalar), T.Min(vector.Y, scalar));
+
+        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
+        public Vector2F<T> Clamp(Vector2F<T> min, Vector2F<T> max) =>
+            new(T.Clamp(X, min.X, max.X), T.Clamp(Y, min.Y, max.Y));
+
+        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
+        public static Vector2F<T> Clamp(Vector2F<T> vector, Vector2F<T> min, Vector2F<T> max) =>
+            new(T.Clamp(vector.X, min.X, max.X), T.Clamp(vector.Y, min.Y, max.Y));
+
+        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
+        public Vector2F<T> Clamp(T min, T max) =>
+            new(T.Clamp(X, min, max), T.Clamp(Y, min, max));
+
+        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
+        public static Vector2F<T> Clamp(Vector2F<T> vector, T min, T max) =>
+            new(T.Clamp(vector.X, min, max), T.Clamp(vector.Y, min, max));
+
+        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
+        public Vector2F<T> Abs() => new(T.Abs(X), T.Abs(Y));
+
+        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
+        public static Vector2F<T> Abs(Vector2F<T> vector) =>
+            new(T.Abs(vector.X), T.Abs(vector.Y));
+
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value.</summary>
+        public static Vector2F<T> Lerp(Vector2F<T> a, Vector2F<T> b, T t) =>
+            new(a.X + (b.X - a.X) * t, a.Y + (b.Y - a.Y) * t);
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value.</summary>
+        public static Vector2F<T> Lerp(Vector2F<T> a, Vector2F<T> b, Vector2F<T> t) =>
+            new(a.X + (b.X - a.X) * t.X, a.Y + (b.Y - a.Y) * t.Y);
+
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
+        public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, T t) =>
+            Lerp(a, b, T.Clamp(t, T.Zero, T.One));
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
+        public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T> t) =>
+            new(
+                a.X + (b.X - a.X) * T.Clamp(t.X, T.Zero, T.One),
+                a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
+            );
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public Vector2F<T> Reflect(Vector2F<T> normal)
+        {
+            T dot = Dot(normal);
+            return this - (normal * (dot + dot));
+        }
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector2F<T> Reflect(Vector2F<T> vector, Vector2F<T> normal)
+        {
+            T dot = Dot(vector, normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() => $"<{X}, {Y}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2F.");
+
+            return result;
+        }
+
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
+        public Vector2F<T> Sign() => new(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
+
+        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
+        public static Vector2F<T> Sign(Vector2F<T> vector) =>
+            new(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)));
+
+        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
+        public Vector2F<T> CopySign(Vector2F<T> signSource) =>
+            new(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y));
+
+        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
+        public static Vector2F<T> CopySign(Vector2F<T> value, Vector2F<T> signSource) =>
+            new(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y));
+
+        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
+        public Vector2F<T> CopySign(T signScalar) =>
+            new(T.CopySign(X, signScalar), T.CopySign(Y, signScalar));
+
+        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
+        public static Vector2F<T> CopySign(Vector2F<T> value, T signScalar) =>
+            new(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaIndex = s.IndexOf(',');
+            if (commaIndex < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2F<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        // Casts
+
+        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2F{T}"/>.</summary>
+        public static explicit operator Vector2F<T>(System.Numerics.Vector2 v) =>
+            new((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
+
+        /// <summary>Explicitly casts a <see cref="Vector2F{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
+        public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
+            new(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
+
+        // Component Operators
+        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
+            new(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
+            new(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
+            new(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
+            new(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
+            new(left.X % right.X, left.Y % right.Y);
+
+        // Scalar Operators
+        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
+            new(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
+            new(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
+            new(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
+            new(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
+            new(vector.X % scalar, vector.Y % scalar);
+
+        // + operator: returns the vector
+        public static Vector2F<T> operator +(Vector2F<T> vector) => vector;
+
+        // - operator: returns the negated vector
+        public static Vector2F<T> operator -(Vector2F<T> vector) =>
+            new(-vector.X, -vector.Y);
+
+        // Equality Operators
+        public static bool operator ==(Vector2F<T> left, Vector2F<T> right) =>
+            left.X == right.X && left.Y == right.Y;
+
+        public static bool operator !=(Vector2F<T> left, Vector2F<T> right) =>
+            left.X != right.X || left.Y != right.Y;
+
+        // IBinaryFloatingPointIeee754
+        public static Vector2F<T> Sqrt(Vector2F<T> x) =>
+            new(T.Sqrt(x.X), T.Sqrt(x.Y));
+
+        public static Vector2F<T> Acosh(Vector2F<T> x) =>
+            new(T.Acosh(x.X), T.Acosh(x.Y));
+
+        public static Vector2F<T> Asinh(Vector2F<T> x) =>
+            new(T.Asinh(x.X), T.Asinh(x.Y));
+
+        public static Vector2F<T> Atanh(Vector2F<T> x) =>
+            new(T.Atanh(x.X), T.Atanh(x.Y));
+
+        public static Vector2F<T> Cosh(Vector2F<T> x) =>
+            new(T.Cosh(x.X), T.Cosh(x.Y));
+
+        public static Vector2F<T> Sinh(Vector2F<T> x) =>
+            new(T.Sinh(x.X), T.Sinh(x.Y));
+
+        public static Vector2F<T> Tanh(Vector2F<T> x) =>
+            new(T.Tanh(x.X), T.Tanh(x.Y));
+
+        public static Vector2F<T> Acos(Vector2F<T> x) =>
+            new(T.Acos(x.X), T.Acos(x.Y));
+
+        public static Vector2F<T> AcosPi(Vector2F<T> x) =>
+            new(T.AcosPi(x.X), T.AcosPi(x.Y));
+
+        public static Vector2F<T> Asin(Vector2F<T> x) =>
+            new(T.Asin(x.X), T.Asin(x.Y));
+
+        public static Vector2F<T> AsinPi(Vector2F<T> x) =>
+            new(T.AsinPi(x.X), T.AsinPi(x.Y));
+
+        public static Vector2F<T> Atan(Vector2F<T> x) =>
+            new(T.Atan(x.X), T.Atan(x.Y));
+
+        public static Vector2F<T> AtanPi(Vector2F<T> x) =>
+            new(T.AtanPi(x.X), T.AtanPi(x.Y));
+
+        public static Vector2F<T> Cos(Vector2F<T> x) =>
+            new(T.Cos(x.X), T.Cos(x.Y));
+
+        public static Vector2F<T> CosPi(Vector2F<T> x) =>
+            new(T.CosPi(x.X), T.CosPi(x.Y));
+
+        public static Vector2F<T> Sin(Vector2F<T> x) =>
+            new(T.Sin(x.X), T.Sin(x.Y));
+
+        public static Vector2F<T> SinPi(Vector2F<T> x) =>
+            new(T.SinPi(x.X), T.SinPi(x.Y));
+
+        public static Vector2F<T> Tan(Vector2F<T> x) =>
+            new(T.Tan(x.X), T.Tan(x.Y));
+
+        public static Vector2F<T> TanPi(Vector2F<T> x) =>
+            new(T.TanPi(x.X), T.TanPi(x.Y));
+
+        public static Vector2F<T> DegreesToRadians(Vector2F<T> degrees) =>
+            new(T.DegreesToRadians(degrees.X), T.DegreesToRadians(degrees.Y));
+
+        public static Vector2F<T> RadiansToDegrees(Vector2F<T> radians) =>
+            new(T.RadiansToDegrees(radians.X), T.RadiansToDegrees(radians.Y));
+
+        public static (Vector2F<T> Sin, Vector2F<T> Cos) SinCos(Vector2F<T> x) =>
+            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
+
+        public static (Vector2F<T> SinPi, Vector2F<T> CosPi) SinCosPi(Vector2F<T> x) =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
+
+        public static Vector2F<T> Log(Vector2F<T> x) =>
+            new(T.Log(x.X), T.Log(x.Y));
+
+        public static Vector2F<T> Log(Vector2F<T> x, Vector2F<T> newBase) =>
+            new(T.Log(x.X, newBase.X), T.Log(x.Y, newBase.Y));
+
+        public static Vector2F<T> Log(Vector2F<T> x, T newBase) =>
+            new(T.Log(x.X, newBase), T.Log(x.Y, newBase));
+
+        public static Vector2F<T> LogP1(Vector2F<T> x) =>
+            new(T.LogP1(x.X), T.LogP1(x.Y));
+
+        // TODO: Static Log2
+
+        public static Vector2F<T> Log2P1(Vector2F<T> x) =>
+            new(T.Log2P1(x.X), T.Log2P1(x.Y));
+
+        public static Vector2F<T> Log10(Vector2F<T> x) =>
+            new(T.Log10(x.X), T.Log10(x.Y));
+
+        public static Vector2F<T> Log10P1(Vector2F<T> x) =>
+            new(T.Log10P1(x.X), T.Log10P1(x.Y));
+
+        public static Vector2F<T> Exp(Vector2F<T> x) =>
+            new(T.Exp(x.X), T.Exp(x.Y));
+
+        public static Vector2F<T> ExpM1(Vector2F<T> x) =>
+            new(T.ExpM1(x.X), T.ExpM1(x.Y));
+
+        public static Vector2F<T> Exp2(Vector2F<T> x) =>
+            new(T.Exp2(x.X), T.Exp2(x.Y));
+
+        public static Vector2F<T> Exp2M1(Vector2F<T> x) =>
+            new(T.Exp2M1(x.X), T.Exp2M1(x.Y));
+
+        public static Vector2F<T> Exp10(Vector2F<T> x) =>
+            new(T.Exp10(x.X), T.Exp10(x.Y));
+
+        public static Vector2F<T> Exp10M1(Vector2F<T> x) =>
+            new(T.Exp10M1(x.X), T.Exp10M1(x.Y));
+
+        public static Vector2F<T> Pow(Vector2F<T> x, Vector2F<T> y) =>
+            new(T.Pow(x.X, y.X), T.Pow(x.Y, y.Y));
+
+        public static Vector2F<T> Pow(Vector2F<T> x, T y) =>
+            new(T.Pow(x.X, y), T.Pow(x.Y, y));
+
+        public static Vector2F<T> Cbrt(Vector2F<T> x) =>
+            new(T.Cbrt(x.X), T.Cbrt(x.Y));
+
+        public static Vector2F<T> Hypot(Vector2F<T> x, Vector2F<T> y) =>
+            new(T.Hypot(x.X, y.X), T.Hypot(x.Y, y.Y));
+
+        public static Vector2F<T> Hypot(Vector2F<T> x, T y) =>
+            new(T.Hypot(x.X, y), T.Hypot(x.Y, y));
+
+        public static Vector2F<T> RootN(Vector2F<T> x, int n) =>
+            new(T.RootN(x.X, n), T.RootN(x.Y, n));
+
+        public static Vector2F<T> Round(Vector2F<T> x) =>
+            new(T.Round(x.X), T.Round(x.Y));
+
+        public static Vector2F<T> Round(Vector2F<T> x, int digits) =>
+            new(T.Round(x.X, digits), T.Round(x.Y, digits));
+
+        public static Vector2F<T> Round(Vector2F<T> x, MidpointRounding mode) =>
+            new(T.Round(x.X, mode), T.Round(x.Y, mode));
+
+        public static Vector2F<T> Round(Vector2F<T> x, int digits, MidpointRounding mode) =>
+            new(T.Round(x.X, digits, mode), T.Round(x.Y, digits, mode));
+
+        public static Vector2F<T> Truncate(Vector2F<T> x) =>
+            new(T.Truncate(x.X), T.Truncate(x.Y));
+
+        public static Vector2F<T> Atan2(Vector2F<T> y, Vector2F<T> x) =>
+            new(T.Atan2(y.X, x.X), T.Atan2(y.Y, x.Y));
+
+        public static Vector2F<T> Atan2Pi(Vector2F<T> y, Vector2F<T> x) =>
+            new(T.Atan2Pi(y.X, x.X), T.Atan2Pi(y.Y, x.Y));
+
+        public static Vector2F<T> Atan2(Vector2F<T> y, T x) =>
+            new(T.Atan2(y.X, x), T.Atan2(y.Y, x));
+
+        public static Vector2F<T> Atan2Pi(Vector2F<T> y, T x) =>
+            new(T.Atan2Pi(y.X, x), T.Atan2Pi(y.Y, x));
+
+        public static Vector2F<T> BitDecrement(Vector2F<T> x) =>
+            new(T.BitDecrement(x.X), T.BitDecrement(x.Y));
+
+        public static Vector2F<T> BitIncrement(Vector2F<T> x) =>
+            new(T.BitIncrement(x.X), T.BitIncrement(x.Y));
+
+        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, Vector2F<T> right, Vector2F<T> addend) =>
+            new(T.FusedMultiplyAdd(left.X, right.X, addend.X), T.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
+
+        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, Vector2F<T> right, T addend) =>
+            new(T.FusedMultiplyAdd(left.X, right.X, addend), T.FusedMultiplyAdd(left.Y, right.Y, addend));
+
+        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, Vector2F<T> addend) =>
+            new(T.FusedMultiplyAdd(left.X, right, addend.X), T.FusedMultiplyAdd(left.Y, right, addend.Y));
+
+        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, T addend) =>
+            new(T.FusedMultiplyAdd(left.X, right, addend), T.FusedMultiplyAdd(left.Y, right, addend));
+
+        public static Vector2F<T> ReciprocalEstimate(Vector2F<T> x) =>
+            new(T.ReciprocalEstimate(x.X), T.ReciprocalEstimate(x.Y));
+
+        public static Vector2F<T> ReciprocalSqrtEstimate(Vector2F<T> x) =>
+            new(T.ReciprocalSqrtEstimate(x.X), T.ReciprocalSqrtEstimate(x.Y));
+
+        public static Vector2I<int> ILogB(Vector2F<T> x) =>
+            new(T.ILogB(x.X), T.ILogB(x.Y));
+
+        public static Vector2F<T> ScaleB(Vector2F<T> x, Vector2I<int> n) =>
+            new(T.ScaleB(x.X, n.X), T.ScaleB(x.Y, n.Y));
+
+        public static Vector2F<T> ScaleB(Vector2F<T> x, int n) =>
+            new(T.ScaleB(x.X, n), T.ScaleB(x.Y, n));
+    }
+}

From 191de4e7a3ddbdd652190498e1df6b934435d580 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Fri, 30 May 2025 10:13:09 -0700
Subject: [PATCH 15/52] Include generated code.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs | 21 ++++++++++++++
 sources/Maths/Maths/Matrix2x2I.gen.cs | 21 ++++++++++++++
 sources/Maths/Maths/Matrix2x3F.gen.cs | 23 +++++++++++++++
 sources/Maths/Maths/Matrix2x3I.gen.cs | 23 +++++++++++++++
 sources/Maths/Maths/Matrix2x4F.gen.cs | 25 +++++++++++++++++
 sources/Maths/Maths/Matrix2x4I.gen.cs | 25 +++++++++++++++++
 sources/Maths/Maths/Matrix3x2F.gen.cs | 24 ++++++++++++++++
 sources/Maths/Maths/Matrix3x2I.gen.cs | 24 ++++++++++++++++
 sources/Maths/Maths/Matrix3x3F.gen.cs | 27 ++++++++++++++++++
 sources/Maths/Maths/Matrix3x3I.gen.cs | 27 ++++++++++++++++++
 sources/Maths/Maths/Matrix3x4F.gen.cs | 30 ++++++++++++++++++++
 sources/Maths/Maths/Matrix3x4I.gen.cs | 30 ++++++++++++++++++++
 sources/Maths/Maths/Matrix4x2F.gen.cs | 27 ++++++++++++++++++
 sources/Maths/Maths/Matrix4x2I.gen.cs | 27 ++++++++++++++++++
 sources/Maths/Maths/Matrix4x3F.gen.cs | 31 +++++++++++++++++++++
 sources/Maths/Maths/Matrix4x3I.gen.cs | 31 +++++++++++++++++++++
 sources/Maths/Maths/Matrix4x4F.gen.cs | 35 +++++++++++++++++++++++
 sources/Maths/Maths/Matrix4x4I.gen.cs | 35 +++++++++++++++++++++++
 sources/Maths/Maths/Matrix5x4F.gen.cs | 40 +++++++++++++++++++++++++++
 sources/Maths/Maths/Matrix5x4I.gen.cs | 40 +++++++++++++++++++++++++++
 sources/Maths/Maths/Vector2F.cs       |  2 +-
 sources/Maths/Maths/Vector3F.gen.cs   | 18 ++++++++++++
 sources/Maths/Maths/Vector4F.gen.cs   | 19 +++++++++++++
 23 files changed, 604 insertions(+), 1 deletion(-)
 create mode 100644 sources/Maths/Maths/Matrix2x2F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix2x2I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix2x3F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix2x3I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix2x4F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix2x4I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x2F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x2I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x3F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x3I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x4F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix3x4I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x2F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x2I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x3F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x3I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x4F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix4x4I.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix5x4F.gen.cs
 create mode 100644 sources/Maths/Maths/Matrix5x4I.gen.cs
 create mode 100644 sources/Maths/Maths/Vector3F.gen.cs
 create mode 100644 sources/Maths/Maths/Vector4F.gen.cs

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
new file mode 100644
index 0000000000..a4fe3486d6
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -0,0 +1,21 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x2F<T> : IEquatable<Matrix2x2F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector2F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x2F<T> left, Matrix2x2F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x2F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x2F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
new file mode 100644
index 0000000000..abb70ef018
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -0,0 +1,21 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x2I<T> : IEquatable<Matrix2x2I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector2I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x2I<T> left, Matrix2x2I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x2I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x2I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
new file mode 100644
index 0000000000..2d160ff92f
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -0,0 +1,23 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x3F<T> : IEquatable<Matrix2x3F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector3F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x3F<T> left, Matrix2x3F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x3F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x3F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
new file mode 100644
index 0000000000..a08cb80e05
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -0,0 +1,23 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x3I<T> : IEquatable<Matrix2x3I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector3I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x3I<T> left, Matrix2x3I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x3I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x3I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
new file mode 100644
index 0000000000..be4bcd7a7c
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -0,0 +1,25 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x4F<T> : IEquatable<Matrix2x4F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector4F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x4F<T> left, Matrix2x4F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x4F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x4F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
new file mode 100644
index 0000000000..957ed5cd97
--- /dev/null
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -0,0 +1,25 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix2x4I<T> : IEquatable<Matrix2x4I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector4I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator !=(Matrix2x4I<T> left, Matrix2x4I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix2x4I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix2x4I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
new file mode 100644
index 0000000000..a742b8ac7a
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -0,0 +1,24 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x2F<T> : IEquatable<Matrix3x2F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector2F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public Vector2F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x2F<T> left, Matrix3x2F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x2F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x2F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
new file mode 100644
index 0000000000..ea91c2b17c
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -0,0 +1,24 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x2I<T> : IEquatable<Matrix3x2I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector2I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public Vector2I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x2I<T> left, Matrix3x2I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x2I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x2I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
new file mode 100644
index 0000000000..4e99f7eeec
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -0,0 +1,27 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x3F<T> : IEquatable<Matrix3x3F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector3F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public Vector3F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x3F<T> left, Matrix3x3F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x3F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x3F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
new file mode 100644
index 0000000000..f87f11633a
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -0,0 +1,27 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x3I<T> : IEquatable<Matrix3x3I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector3I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public Vector3I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x3I<T> left, Matrix3x3I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x3I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x3I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
new file mode 100644
index 0000000000..7cadcea5e4
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -0,0 +1,30 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x4F<T> : IEquatable<Matrix3x4F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector4F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x4F<T> left, Matrix3x4F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x4F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x4F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
new file mode 100644
index 0000000000..531d3ce4b8
--- /dev/null
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -0,0 +1,30 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix3x4I<T> : IEquatable<Matrix3x4I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector4I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator !=(Matrix3x4I<T> left, Matrix3x4I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix3x4I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix3x4I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
new file mode 100644
index 0000000000..69b77a8983
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -0,0 +1,27 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x2F<T> : IEquatable<Matrix4x2F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector2F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public Vector2F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public Vector2F<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x2F<T> left, Matrix4x2F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x2F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x2F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
new file mode 100644
index 0000000000..009132e9a9
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -0,0 +1,27 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x2I<T> : IEquatable<Matrix4x2I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector2I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public Vector2I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public Vector2I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public Vector2I<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x2I<T> left, Matrix4x2I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x2I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x2I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
new file mode 100644
index 0000000000..45645b08b7
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -0,0 +1,31 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x3F<T> : IEquatable<Matrix4x3F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector3F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public Vector3F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public Vector3F<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x3F<T> left, Matrix4x3F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x3F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x3F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
new file mode 100644
index 0000000000..3dd56f6000
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -0,0 +1,31 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x3I<T> : IEquatable<Matrix4x3I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector3I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public Vector3I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public Vector3I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public Vector3I<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x3I<T> left, Matrix4x3I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x3I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x3I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
new file mode 100644
index 0000000000..83804511cc
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -0,0 +1,35 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x4F<T> : IEquatable<Matrix4x4F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector4F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public Vector4F<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public T M44 => Row4.W;
+        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x4F<T> left, Matrix4x4F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x4F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x4F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
new file mode 100644
index 0000000000..a49923923a
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -0,0 +1,35 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix4x4I<T> : IEquatable<Matrix4x4I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector4I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public Vector4I<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public T M44 => Row4.W;
+        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator !=(Matrix4x4I<T> left, Matrix4x4I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix4x4I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix4x4I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
new file mode 100644
index 0000000000..5b1b50135f
--- /dev/null
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -0,0 +1,40 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix5x4F<T> : IEquatable<Matrix5x4F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public Vector4F<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4F<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4F<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public Vector4F<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public T M44 => Row4.W;
+        public Vector4F<T> Row5;
+        public T M51 => Row5.X;
+        public T M52 => Row5.Y;
+        public T M53 => Row5.Z;
+        public T M54 => Row5.W;
+        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        public static bool operator !=(Matrix5x4F<T> left, Matrix5x4F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix5x4F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix5x4F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
new file mode 100644
index 0000000000..5a072ef187
--- /dev/null
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -0,0 +1,40 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Matrix5x4I<T> : IEquatable<Matrix5x4I<T>> where T : IBinaryInteger<T>
+    {
+        public Vector4I<T> Row1;
+        public T M11 => Row1.X;
+        public T M12 => Row1.Y;
+        public T M13 => Row1.Z;
+        public T M14 => Row1.W;
+        public Vector4I<T> Row2;
+        public T M21 => Row2.X;
+        public T M22 => Row2.Y;
+        public T M23 => Row2.Z;
+        public T M24 => Row2.W;
+        public Vector4I<T> Row3;
+        public T M31 => Row3.X;
+        public T M32 => Row3.Y;
+        public T M33 => Row3.Z;
+        public T M34 => Row3.W;
+        public Vector4I<T> Row4;
+        public T M41 => Row4.X;
+        public T M42 => Row4.Y;
+        public T M43 => Row4.Z;
+        public T M44 => Row4.W;
+        public Vector4I<T> Row5;
+        public T M51 => Row5.X;
+        public T M52 => Row5.Y;
+        public T M53 => Row5.Z;
+        public T M54 => Row5.W;
+        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        public static bool operator !=(Matrix5x4I<T> left, Matrix5x4I<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Matrix5x4I<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Matrix5x4I<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 6f563ced9e..26d8c13047 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -23,7 +23,7 @@ internal struct Vector2F<T> :
         IUtf8SpanParsable<Vector2F<T>>,
         IParsable<Vector2F<T>>,
         IFormattable
-        where T : IBinaryFloatingPointIeee754<T>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
new file mode 100644
index 0000000000..e37480e2c7
--- /dev/null
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -0,0 +1,18 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public T X;
+        public T Y;
+        public T Z;
+        public static bool operator ==(Vector3F<T> left, Vector3F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
+        public static bool operator !=(Vector3F<T> left, Vector3F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Vector3F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Vector3F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+    }
+}
\ No newline at end of file
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
new file mode 100644
index 0000000000..77defbefa4
--- /dev/null
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -0,0 +1,19 @@
+namespace Silk.NET.Maths
+{
+    using System.Numerics;
+
+    partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIeee754<T>
+    {
+        public T X;
+        public T Y;
+        public T Z;
+        public T W;
+        public static bool operator ==(Vector4F<T> left, Vector4F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
+        public static bool operator !=(Vector4F<T> left, Vector4F<T> right) => !(left == right);
+        public override bool Equals(object? obj) => obj is Vector4F<T> other && Equals(other);
+        /// <inheridoc/>
+        public bool Equals(Vector4F<T> other) => this == other;
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+    }
+}
\ No newline at end of file

From 291ec1ed53ac3abe57838cdccb91512c37b8d3fe Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Fri, 30 May 2025 16:43:18 -0700
Subject: [PATCH 16/52] Generated constructors, operators, and indexers.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs | 55 ++++++++++++++-
 sources/Maths/Maths/Matrix2x2I.gen.cs | 55 ++++++++++++++-
 sources/Maths/Maths/Matrix2x3F.gen.cs | 62 ++++++++++++++++-
 sources/Maths/Maths/Matrix2x3I.gen.cs | 62 ++++++++++++++++-
 sources/Maths/Maths/Matrix2x4F.gen.cs | 69 ++++++++++++++++++-
 sources/Maths/Maths/Matrix2x4I.gen.cs | 69 ++++++++++++++++++-
 sources/Maths/Maths/Matrix3x2F.gen.cs | 67 ++++++++++++++++--
 sources/Maths/Maths/Matrix3x2I.gen.cs | 67 ++++++++++++++++--
 sources/Maths/Maths/Matrix3x3F.gen.cs | 75 +++++++++++++++++++--
 sources/Maths/Maths/Matrix3x3I.gen.cs | 75 +++++++++++++++++++--
 sources/Maths/Maths/Matrix3x4F.gen.cs | 83 +++++++++++++++++++++--
 sources/Maths/Maths/Matrix3x4I.gen.cs | 83 +++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x2F.gen.cs | 79 ++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x2I.gen.cs | 79 ++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x3F.gen.cs | 88 ++++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x3I.gen.cs | 88 ++++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x4F.gen.cs | 97 +++++++++++++++++++++++++--
 sources/Maths/Maths/Matrix4x4I.gen.cs | 97 +++++++++++++++++++++++++--
 sources/Maths/Maths/Matrix5x4F.gen.cs | 86 ++++++++++++++++++++++--
 sources/Maths/Maths/Matrix5x4I.gen.cs | 86 ++++++++++++++++++++++--
 20 files changed, 1438 insertions(+), 84 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
index a4fe3486d6..89adcc9f5f 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -1,21 +1,70 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x2F<T> : IEquatable<Matrix2x2F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row2;
+        public Matrix2x2F(Vector2F<T> row1, Vector2F<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x2F<T> left, Matrix2x2F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x2F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x2F<T> left, Matrix2x2F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x2F<T> operator +(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x2F<T> operator -(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2F<T> operator *(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
index abb70ef018..b821cef6e4 100644
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -1,21 +1,70 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x2I<T> : IEquatable<Matrix2x2I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row2;
+        public Matrix2x2I(Vector2I<T> row1, Vector2I<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x2I<T> left, Matrix2x2I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x2I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x2I<T> left, Matrix2x2I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x2I<T> operator +(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x2I<T> operator -(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2I<T> operator *(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
index 2d160ff92f..1e29c07468 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -1,23 +1,79 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x3F<T> : IEquatable<Matrix2x3F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row2;
+        public Matrix2x3F(Vector3F<T> row1, Vector3F<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x3F<T> left, Matrix2x3F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x3F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x3F<T> left, Matrix2x3F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x3F<T> operator +(Matrix2x3F<T> left, Matrix2x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x3F<T> operator -(Matrix2x3F<T> left, Matrix2x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3F<T> operator *(Matrix2x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2F<T> operator *(Matrix2x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
index a08cb80e05..1552290f34 100644
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -1,23 +1,79 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x3I<T> : IEquatable<Matrix2x3I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row2;
+        public Matrix2x3I(Vector3I<T> row1, Vector3I<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x3I<T> left, Matrix2x3I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x3I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x3I<T> left, Matrix2x3I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x3I<T> operator +(Matrix2x3I<T> left, Matrix2x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x3I<T> operator -(Matrix2x3I<T> left, Matrix2x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3I<T> operator *(Matrix2x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2I<T> operator *(Matrix2x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
index be4bcd7a7c..e8ae19335b 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -1,25 +1,88 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x4F<T> : IEquatable<Matrix2x4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row2;
+        public Matrix2x4F(Vector4F<T> row1, Vector4F<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x4F<T> left, Matrix2x4F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x4F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x4F<T> left, Matrix2x4F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x4F<T> operator +(Matrix2x4F<T> left, Matrix2x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x4F<T> operator -(Matrix2x4F<T> left, Matrix2x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4F<T> operator *(Matrix2x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2F<T> operator *(Matrix2x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4F<T> operator *(Matrix3x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
index 957ed5cd97..00d2a60fd7 100644
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -1,25 +1,88 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix2x4I<T> : IEquatable<Matrix2x4I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row2;
+        public Matrix2x4I(Vector4I<T> row1, Vector4I<T> row2) => (Row1, Row2) = (row1, row2);
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
-        public static bool operator !=(Matrix2x4I<T> left, Matrix2x4I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix2x4I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix2x4I<T> left, Matrix2x4I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2x4I<T> operator +(Matrix2x4I<T> left, Matrix2x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2x4I<T> operator -(Matrix2x4I<T> left, Matrix2x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4I<T> operator *(Matrix2x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x2I<T> operator *(Matrix2x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4I<T> operator *(Matrix3x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
index a742b8ac7a..d3b9d23ca9 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -1,24 +1,83 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x2F<T> : IEquatable<Matrix3x2F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row3;
+        public Matrix3x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public Vector2F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
-        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x2F<T> left, Matrix3x2F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x2F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x2F<T> left, Matrix3x2F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x2F<T> operator +(Matrix3x2F<T> left, Matrix3x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x2F<T> operator -(Matrix3x2F<T> left, Matrix3x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2F<T> operator *(Matrix3x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3F<T> operator *(Matrix3x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
index ea91c2b17c..ff42a87479 100644
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -1,24 +1,83 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x2I<T> : IEquatable<Matrix3x2I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row3;
+        public Matrix3x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public Vector2I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
-        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x2I<T> left, Matrix3x2I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x2I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x2I<T> left, Matrix3x2I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x2I<T> operator +(Matrix3x2I<T> left, Matrix3x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x2I<T> operator -(Matrix3x2I<T> left, Matrix3x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2I<T> operator *(Matrix3x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3I<T> operator *(Matrix3x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
index 4e99f7eeec..5e58784ba3 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -1,27 +1,94 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x3F<T> : IEquatable<Matrix3x3F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row3;
+        public Matrix3x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public Vector3F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
-        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x3F<T> left, Matrix3x3F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x3F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x3F<T> left, Matrix3x3F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x3F<T> operator +(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x3F<T> operator -(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3F<T> operator *(Matrix2x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2F<T> operator *(Matrix3x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3F<T> operator *(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
index f87f11633a..51c31bf28f 100644
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -1,27 +1,94 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x3I<T> : IEquatable<Matrix3x3I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row3;
+        public Matrix3x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public Vector3I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
-        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x3I<T> left, Matrix3x3I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x3I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x3I<T> left, Matrix3x3I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x3I<T> operator +(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x3I<T> operator -(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3I<T> operator *(Matrix2x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2I<T> operator *(Matrix3x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3I<T> operator *(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
index 7cadcea5e4..1f0333ebdb 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -1,30 +1,105 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x4F<T> : IEquatable<Matrix3x4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row3;
+        public Matrix3x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x4F<T> left, Matrix3x4F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x4F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x4F<T> left, Matrix3x4F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x4F<T> operator +(Matrix3x4F<T> left, Matrix3x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x4F<T> operator -(Matrix3x4F<T> left, Matrix3x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4F<T> operator *(Matrix2x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4F<T> operator *(Matrix3x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2F<T> operator *(Matrix3x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3F<T> operator *(Matrix3x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
index 531d3ce4b8..e944c9459f 100644
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -1,30 +1,105 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix3x4I<T> : IEquatable<Matrix3x4I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row3;
+        public Matrix3x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
-        public static bool operator !=(Matrix3x4I<T> left, Matrix3x4I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix3x4I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix3x4I<T> left, Matrix3x4I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3x4I<T> operator +(Matrix3x4I<T> left, Matrix3x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3x4I<T> operator -(Matrix3x4I<T> left, Matrix3x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4I<T> operator *(Matrix2x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4I<T> operator *(Matrix3x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x2I<T> operator *(Matrix3x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x3I<T> operator *(Matrix3x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
index 69b77a8983..1a99fc610b 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -1,27 +1,96 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x2F<T> : IEquatable<Matrix4x2F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector2F<T> Row4;
+        public Matrix4x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3, Vector2F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public Vector2F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
-        public Vector2F<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
-        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x2F<T> left, Matrix4x2F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x2F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x2F<T> left, Matrix4x2F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x2F<T> operator +(Matrix4x2F<T> left, Matrix4x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x2F<T> operator -(Matrix4x2F<T> left, Matrix4x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2F<T> operator *(Matrix4x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3F<T> operator *(Matrix4x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4F<T> operator *(Matrix4x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
index 009132e9a9..56dfdfc4c8 100644
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -1,27 +1,96 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x2I<T> : IEquatable<Matrix4x2I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector2I<T> Row4;
+        public Matrix4x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3, Vector2I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
-        public Vector2I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
-        public Vector2I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
-        public Vector2I<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
-        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x2I<T> left, Matrix4x2I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x2I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x2I<T> left, Matrix4x2I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x2I<T> operator +(Matrix4x2I<T> left, Matrix4x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x2I<T> operator -(Matrix4x2I<T> left, Matrix4x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2I<T> operator *(Matrix4x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3I<T> operator *(Matrix4x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4I<T> operator *(Matrix4x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
index 45645b08b7..534d3c9018 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -1,31 +1,109 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x3F<T> : IEquatable<Matrix4x3F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector3F<T> Row4;
+        public Matrix4x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3, Vector3F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public Vector3F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
-        public Vector3F<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
-        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x3F<T> left, Matrix4x3F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x3F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x3F<T> left, Matrix4x3F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x3F<T> operator +(Matrix4x3F<T> left, Matrix4x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x3F<T> operator -(Matrix4x3F<T> left, Matrix4x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3F<T> operator *(Matrix2x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2F<T> operator *(Matrix4x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3F<T> operator *(Matrix4x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4F<T> operator *(Matrix4x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
index 3dd56f6000..90d2a59aec 100644
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -1,31 +1,109 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x3I<T> : IEquatable<Matrix4x3I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector3I<T> Row4;
+        public Matrix4x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3, Vector3I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
-        public Vector3I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
-        public Vector3I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
-        public Vector3I<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
-        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x3I<T> left, Matrix4x3I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x3I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x3I<T> left, Matrix4x3I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x3I<T> operator +(Matrix4x3I<T> left, Matrix4x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x3I<T> operator -(Matrix4x3I<T> left, Matrix4x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x3I<T> operator *(Matrix2x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2I<T> operator *(Matrix4x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3I<T> operator *(Matrix4x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4I<T> operator *(Matrix4x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
index 83804511cc..35b3d492d2 100644
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -1,35 +1,122 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x4F<T> : IEquatable<Matrix4x4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row4;
+        public Matrix4x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public Vector4F<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
-        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x4F<T> left, Matrix4x4F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x4F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x4F<T> left, Matrix4x4F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x4F<T> operator +(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x4F<T> operator -(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4F<T> operator *(Matrix2x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4F<T> operator *(Matrix3x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2F<T> operator *(Matrix4x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3F<T> operator *(Matrix4x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4F<T> operator *(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
index a49923923a..3745130e76 100644
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -1,35 +1,122 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix4x4I<T> : IEquatable<Matrix4x4I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row4;
+        public Matrix4x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public Vector4I<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
-        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
-        public static bool operator !=(Matrix4x4I<T> left, Matrix4x4I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix4x4I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4x4I<T> left, Matrix4x4I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4x4I<T> operator +(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4x4I<T> operator -(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2x4I<T> operator *(Matrix2x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3x4I<T> operator *(Matrix3x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x2I<T> operator *(Matrix4x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x3I<T> operator *(Matrix4x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4x4I<T> operator *(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
index 5b1b50135f..efdcf0a2f8 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -1,40 +1,114 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix5x4F<T> : IEquatable<Matrix5x4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row4;
+        /// <summary>The 5th row of the matrix represented as a vector.</summary>
+        public Vector4F<T> Row5;
+        public Matrix5x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4, Vector4F<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                    case 4:
+                        return ref Row5;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4F<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4F<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public Vector4F<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
-        public Vector4F<T> Row5;
+        /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
         public T M51 => Row5.X;
+        /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
         public T M52 => Row5.Y;
+        /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
         public T M53 => Row5.Z;
+        /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
         public T M54 => Row5.W;
-        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
-        public static bool operator !=(Matrix5x4F<T> left, Matrix5x4F<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4F<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix5x4F<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix5x4F<T> left, Matrix5x4F<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix5x4F<T> operator +(Matrix5x4F<T> left, Matrix5x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4, left.Row5 + right.Row5);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix5x4F<T> operator -(Matrix5x4F<T> left, Matrix5x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4, left.Row5 - right.Row5);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix5x4F<T> operator *(Matrix5x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4, left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
index 5a072ef187..7b794338b0 100644
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -1,40 +1,114 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Matrix5x4I<T> : IEquatable<Matrix5x4I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row2;
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row3;
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row4;
+        /// <summary>The 5th row of the matrix represented as a vector.</summary>
+        public Vector4I<T> Row5;
+        public Matrix5x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4, Vector4I<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                    case 4:
+                        return ref Row5;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(row));
+            }
+        }
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
-        public Vector4I<T> Row2;
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
-        public Vector4I<T> Row3;
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
-        public Vector4I<T> Row4;
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
-        public Vector4I<T> Row5;
+        /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
         public T M51 => Row5.X;
+        /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
         public T M52 => Row5.Y;
+        /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
         public T M53 => Row5.Z;
+        /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
         public T M54 => Row5.W;
-        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
-        public static bool operator !=(Matrix5x4I<T> left, Matrix5x4I<T> right) => !(left == right);
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4I<T> other && Equals(other);
         /// <inheridoc/>
         public bool Equals(Matrix5x4I<T> other) => this == other;
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name = "left">The first matrix to compare.</param>
+        /// <param name = "right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix5x4I<T> left, Matrix5x4I<T> right) => !(left == right);
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix5x4I<T> operator +(Matrix5x4I<T> left, Matrix5x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4, left.Row5 + right.Row5);
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix5x4I<T> operator -(Matrix5x4I<T> left, Matrix5x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4, left.Row5 - right.Row5);
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name = "left">The first source matrix.</param>
+        /// <param name = "right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix5x4I<T> operator *(Matrix5x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4, left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
 }
\ No newline at end of file

From cfee01259a52e81fbc2685c63f9749e2d6a3da8e Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Fri, 30 May 2025 18:25:38 -0700
Subject: [PATCH 17/52] Whitespace and comments.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs |  53 ++++++++----
 sources/Maths/Maths/Matrix2x2I.gen.cs |  53 ++++++++----
 sources/Maths/Maths/Matrix2x3F.gen.cs |  64 ++++++++++----
 sources/Maths/Maths/Matrix2x3I.gen.cs |  64 ++++++++++----
 sources/Maths/Maths/Matrix2x4F.gen.cs |  76 ++++++++++++-----
 sources/Maths/Maths/Matrix2x4I.gen.cs |  76 ++++++++++++-----
 sources/Maths/Maths/Matrix3x2F.gen.cs |  70 ++++++++++++----
 sources/Maths/Maths/Matrix3x2I.gen.cs |  70 ++++++++++++----
 sources/Maths/Maths/Matrix3x3F.gen.cs |  82 +++++++++++++-----
 sources/Maths/Maths/Matrix3x3I.gen.cs |  82 +++++++++++++-----
 sources/Maths/Maths/Matrix3x4F.gen.cs |  95 ++++++++++++++++-----
 sources/Maths/Maths/Matrix3x4I.gen.cs |  95 ++++++++++++++++-----
 sources/Maths/Maths/Matrix4x2F.gen.cs |  89 +++++++++++++++-----
 sources/Maths/Maths/Matrix4x2I.gen.cs |  89 +++++++++++++++-----
 sources/Maths/Maths/Matrix4x3F.gen.cs | 102 +++++++++++++++++-----
 sources/Maths/Maths/Matrix4x3I.gen.cs | 102 +++++++++++++++++-----
 sources/Maths/Maths/Matrix4x4F.gen.cs | 116 ++++++++++++++++++++------
 sources/Maths/Maths/Matrix4x4I.gen.cs | 116 ++++++++++++++++++++------
 sources/Maths/Maths/Matrix5x4F.gen.cs |  84 +++++++++++++++----
 sources/Maths/Maths/Matrix5x4I.gen.cs |  84 +++++++++++++++----
 20 files changed, 1274 insertions(+), 388 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
index 89adcc9f5f..0f08a02fc2 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x2F<T> : IEquatable<Matrix2x2F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x2F{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x2F(Vector2F<T> row1, Vector2F<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector2F<T> this[int row]
         {
@@ -29,42 +35,61 @@ public ref Vector2F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x2F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x2F<T> left, Matrix2x2F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x2F<T> operator +(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x2F<T> operator +(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x2F<T> operator -(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x2F<T> operator -(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x2F<T> operator *(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
index b821cef6e4..ecb2f945a4 100644
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x2I<T> : IEquatable<Matrix2x2I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x2I{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x2I(Vector2I<T> row1, Vector2I<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector2I<T> this[int row]
         {
@@ -29,42 +35,61 @@ public ref Vector2I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x2I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x2I<T> left, Matrix2x2I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x2I<T> operator +(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x2I<T> operator +(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x2I<T> operator -(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x2I<T> operator -(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x2I<T> operator *(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
index 1e29c07468..4d6f920ce9 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x3F<T> : IEquatable<Matrix2x3F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x3F{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x3F(Vector3F<T> row1, Vector3F<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector3F<T> this[int row]
         {
@@ -29,51 +35,75 @@ public ref Vector3F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x3F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x3F<T> left, Matrix2x3F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x3F<T> operator +(Matrix2x3F<T> left, Matrix2x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x3F<T> operator +(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x3F<T> operator -(Matrix2x3F<T> left, Matrix2x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x3F<T> operator -(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x3F<T> operator *(Matrix2x2F<T> left, Matrix2x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x2F<T> operator *(Matrix2x3F<T> left, Matrix3x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
index 1552290f34..83b682d83d 100644
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x3I<T> : IEquatable<Matrix2x3I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x3I{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x3I(Vector3I<T> row1, Vector3I<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector3I<T> this[int row]
         {
@@ -29,51 +35,75 @@ public ref Vector3I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x3I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x3I<T> left, Matrix2x3I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x3I<T> operator +(Matrix2x3I<T> left, Matrix2x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x3I<T> operator +(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x3I<T> operator -(Matrix2x3I<T> left, Matrix2x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x3I<T> operator -(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x3I<T> operator *(Matrix2x2I<T> left, Matrix2x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x2I<T> operator *(Matrix2x3I<T> left, Matrix3x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
index e8ae19335b..a310f3fabb 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x4F<T> : IEquatable<Matrix2x4F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x4F{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x4F(Vector4F<T> row1, Vector4F<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector4F<T> this[int row]
         {
@@ -29,60 +35,90 @@ public ref Vector4F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x4F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x4F<T> left, Matrix2x4F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x4F<T> operator +(Matrix2x4F<T> left, Matrix2x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x4F<T> operator +(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x4F<T> operator -(Matrix2x4F<T> left, Matrix2x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x4F<T> operator -(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x4F<T> operator *(Matrix2x2F<T> left, Matrix2x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x2F<T> operator *(Matrix2x4F<T> left, Matrix4x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x4F<T> operator *(Matrix3x2F<T> left, Matrix2x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
index 00d2a60fd7..a30c911a50 100644
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -7,9 +7,15 @@ partial struct Matrix2x4I<T> : IEquatable<Matrix2x4I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row2;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2x4I{T}"/> from the given rows.
+        /// </summary>
         public Matrix2x4I(Vector4I<T> row1, Vector4I<T> row2) => (Row1, Row2) = (row1, row2);
+
         [UnscopedRef]
         public ref Vector4I<T> this[int row]
         {
@@ -29,60 +35,90 @@ public ref Vector4I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix2x4I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2;
+        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix2x4I<T> left, Matrix2x4I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x4I<T> operator +(Matrix2x4I<T> left, Matrix2x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2);
+        public static Matrix2x4I<T> operator +(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x4I<T> operator -(Matrix2x4I<T> left, Matrix2x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2);
+        public static Matrix2x4I<T> operator -(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2);
+        public static Matrix2x4I<T> operator *(Matrix2x2I<T> left, Matrix2x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x2I<T> operator *(Matrix2x4I<T> left, Matrix4x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x4I<T> operator *(Matrix3x2I<T> left, Matrix2x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
index d3b9d23ca9..42d2c7d49c 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x2F<T> : IEquatable<Matrix3x2F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x2F{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector2F<T> this[int row]
         {
@@ -33,51 +40,80 @@ public ref Vector2F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x2F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x2F<T> left, Matrix3x2F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x2F<T> operator +(Matrix3x2F<T> left, Matrix3x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x2F<T> operator +(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x2F<T> operator -(Matrix3x2F<T> left, Matrix3x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x2F<T> operator -(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x2F<T> operator *(Matrix3x2F<T> left, Matrix2x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x3F<T> operator *(Matrix3x2F<T> left, Matrix2x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
index ff42a87479..84c0054f95 100644
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x2I<T> : IEquatable<Matrix3x2I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x2I{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector2I<T> this[int row]
         {
@@ -33,51 +40,80 @@ public ref Vector2I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x2I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x2I<T> left, Matrix3x2I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x2I<T> operator +(Matrix3x2I<T> left, Matrix3x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x2I<T> operator +(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x2I<T> operator -(Matrix3x2I<T> left, Matrix3x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x2I<T> operator -(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x2I<T> operator *(Matrix3x2I<T> left, Matrix2x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2);
+        public static Matrix3x3I<T> operator *(Matrix3x2I<T> left, Matrix2x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
index 5e58784ba3..35c045ea23 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x3F<T> : IEquatable<Matrix3x3F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x3F{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector3F<T> this[int row]
         {
@@ -33,62 +40,97 @@ public ref Vector3F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x3F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x3F<T> left, Matrix3x3F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x3F<T> operator +(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x3F<T> operator +(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x3F<T> operator -(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x3F<T> operator -(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x3F<T> operator *(Matrix2x3F<T> left, Matrix3x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x2F<T> operator *(Matrix3x3F<T> left, Matrix3x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x3F<T> operator *(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
index 51c31bf28f..b5d63fd42c 100644
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x3I<T> : IEquatable<Matrix3x3I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x3I{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector3I<T> this[int row]
         {
@@ -33,62 +40,97 @@ public ref Vector3I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x3I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x3I<T> left, Matrix3x3I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x3I<T> operator +(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x3I<T> operator +(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x3I<T> operator -(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x3I<T> operator -(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x3I<T> operator *(Matrix2x3I<T> left, Matrix3x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x2I<T> operator *(Matrix3x3I<T> left, Matrix3x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x3I<T> operator *(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
index 1f0333ebdb..124a15c20e 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x4F<T> : IEquatable<Matrix3x4F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x4F{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector4F<T> this[int row]
         {
@@ -33,73 +40,115 @@ public ref Vector4F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x4F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x4F<T> left, Matrix3x4F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x4F<T> operator +(Matrix3x4F<T> left, Matrix3x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x4F<T> operator +(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x4F<T> operator -(Matrix3x4F<T> left, Matrix3x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x4F<T> operator -(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x4F<T> operator *(Matrix2x3F<T> left, Matrix3x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x4F<T> operator *(Matrix3x3F<T> left, Matrix3x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x2F<T> operator *(Matrix3x4F<T> left, Matrix4x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x3F<T> operator *(Matrix3x4F<T> left, Matrix4x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
index e944c9459f..c91be5692a 100644
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -7,11 +7,18 @@ partial struct Matrix3x4I<T> : IEquatable<Matrix3x4I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row3;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3x4I{T}"/> from the given rows.
+        /// </summary>
         public Matrix3x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+
         [UnscopedRef]
         public ref Vector4I<T> this[int row]
         {
@@ -33,73 +40,115 @@ public ref Vector4I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix3x4I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3;
+        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix3x4I<T> left, Matrix3x4I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x4I<T> operator +(Matrix3x4I<T> left, Matrix3x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3);
+        public static Matrix3x4I<T> operator +(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x4I<T> operator -(Matrix3x4I<T> left, Matrix3x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3);
+        public static Matrix3x4I<T> operator -(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        public static Matrix2x4I<T> operator *(Matrix2x3I<T> left, Matrix3x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        public static Matrix3x4I<T> operator *(Matrix3x3I<T> left, Matrix3x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x2I<T> operator *(Matrix3x4I<T> left, Matrix4x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x3I<T> operator *(Matrix3x4I<T> left, Matrix4x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
index 1a99fc610b..227a09e12c 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x2F<T> : IEquatable<Matrix4x2F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x2F{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3, Vector2F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector2F<T> this[int row]
         {
@@ -37,60 +45,101 @@ public ref Vector2F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x2F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x2F<T> left, Matrix4x2F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x2F<T> operator +(Matrix4x2F<T> left, Matrix4x2F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x2F<T> operator +(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x2F<T> operator -(Matrix4x2F<T> left, Matrix4x2F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x2F<T> operator -(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x2F<T> left, Matrix2x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x2F<T> operator *(Matrix4x2F<T> left, Matrix2x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x2F<T> left, Matrix2x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x3F<T> operator *(Matrix4x2F<T> left, Matrix2x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x2F<T> left, Matrix2x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x4F<T> operator *(Matrix4x2F<T> left, Matrix2x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
index 56dfdfc4c8..9d688dc387 100644
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x2I<T> : IEquatable<Matrix4x2I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x2I{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3, Vector2I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector2I<T> this[int row]
         {
@@ -37,60 +45,101 @@ public ref Vector2I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x2I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x2I<T> left, Matrix4x2I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x2I<T> operator +(Matrix4x2I<T> left, Matrix4x2I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x2I<T> operator +(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x2I<T> operator -(Matrix4x2I<T> left, Matrix4x2I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x2I<T> operator -(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x2I<T> left, Matrix2x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x2I<T> operator *(Matrix4x2I<T> left, Matrix2x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x2I<T> left, Matrix2x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x3I<T> operator *(Matrix4x2I<T> left, Matrix2x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x2I<T> left, Matrix2x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2, left.M21 * right.Row1 + left.M22 * right.Row2, left.M31 * right.Row1 + left.M32 * right.Row2, left.M41 * right.Row1 + left.M42 * right.Row2);
+        public static Matrix4x4I<T> operator *(Matrix4x2I<T> left, Matrix2x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2,
+                left.M21 * right.Row1 + left.M22 * right.Row2,
+                left.M31 * right.Row1 + left.M32 * right.Row2,
+                left.M41 * right.Row1 + left.M42 * right.Row2);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
index 534d3c9018..28b958a85c 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x3F<T> : IEquatable<Matrix4x3F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x3F{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3, Vector3F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector3F<T> this[int row]
         {
@@ -37,73 +45,121 @@ public ref Vector3F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x3F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x3F<T> left, Matrix4x3F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x3F<T> operator +(Matrix4x3F<T> left, Matrix4x3F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x3F<T> operator +(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x3F<T> operator -(Matrix4x3F<T> left, Matrix4x3F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x3F<T> operator -(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x3F<T> operator *(Matrix2x4F<T> left, Matrix4x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x3F<T> left, Matrix3x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x2F<T> operator *(Matrix4x3F<T> left, Matrix3x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x3F<T> left, Matrix3x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x3F<T> operator *(Matrix4x3F<T> left, Matrix3x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x3F<T> left, Matrix3x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x4F<T> operator *(Matrix4x3F<T> left, Matrix3x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
index 90d2a59aec..662211575c 100644
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x3I<T> : IEquatable<Matrix4x3I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x3I{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3, Vector3I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector3I<T> this[int row]
         {
@@ -37,73 +45,121 @@ public ref Vector3I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x3I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x3I<T> left, Matrix4x3I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x3I<T> operator +(Matrix4x3I<T> left, Matrix4x3I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x3I<T> operator +(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x3I<T> operator -(Matrix4x3I<T> left, Matrix4x3I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x3I<T> operator -(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x3I<T> operator *(Matrix2x4I<T> left, Matrix4x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x3I<T> left, Matrix3x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x2I<T> operator *(Matrix4x3I<T> left, Matrix3x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x3I<T> left, Matrix3x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x3I<T> operator *(Matrix4x3I<T> left, Matrix3x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x3I<T> left, Matrix3x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        public static Matrix4x4I<T> operator *(Matrix4x3I<T> left, Matrix3x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
index 35b3d492d2..a93bd5a9f9 100644
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x4F<T> : IEquatable<Matrix4x4F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x4F{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector4F<T> this[int row]
         {
@@ -37,86 +45,142 @@ public ref Vector4F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x4F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x4F<T> left, Matrix4x4F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x4F<T> operator +(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x4F<T> operator +(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x4F<T> operator -(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x4F<T> operator -(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x4F<T> operator *(Matrix2x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x4F<T> operator *(Matrix3x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x4F<T> left, Matrix4x2F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x2F<T> operator *(Matrix4x4F<T> left, Matrix4x2F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x4F<T> left, Matrix4x3F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x3F<T> operator *(Matrix4x4F<T> left, Matrix4x3F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x4F<T> operator *(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
index 3745130e76..27db725337 100644
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -7,13 +7,21 @@ partial struct Matrix4x4I<T> : IEquatable<Matrix4x4I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row4;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4x4I{T}"/> from the given rows.
+        /// </summary>
         public Matrix4x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
         [UnscopedRef]
         public ref Vector4I<T> this[int row]
         {
@@ -37,86 +45,142 @@ public ref Vector4I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix4x4I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4;
+        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix4x4I<T> left, Matrix4x4I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x4I<T> operator +(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4);
+        public static Matrix4x4I<T> operator +(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x4I<T> operator -(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4);
+        public static Matrix4x4I<T> operator -(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+        public static Matrix2x4I<T> operator *(Matrix2x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        public static Matrix3x4I<T> operator *(Matrix3x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x4I<T> left, Matrix4x2I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x2I<T> operator *(Matrix4x4I<T> left, Matrix4x2I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x4I<T> left, Matrix4x3I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x3I<T> operator *(Matrix4x4I<T> left, Matrix4x3I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        public static Matrix4x4I<T> operator *(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
index efdcf0a2f8..353f89cd9d 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -7,15 +7,24 @@ partial struct Matrix5x4F<T> : IEquatable<Matrix5x4F<T>> where T : IFloatingPoin
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row4;
+
         /// <summary>The 5th row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row5;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix5x4F{T}"/> from the given rows.
+        /// </summary>
         public Matrix5x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4, Vector4F<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+
         [UnscopedRef]
         public ref Vector4F<T> this[int row]
         {
@@ -41,74 +50,121 @@ public ref Vector4F<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
+
         /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
         public T M51 => Row5.X;
+
         /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
         public T M52 => Row5.Y;
+
         /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
         public T M53 => Row5.Z;
+
         /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
         public T M54 => Row5.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix5x4F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4 &&
+            left.Row5 == right.Row5;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix5x4F<T> left, Matrix5x4F<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix5x4F<T> operator +(Matrix5x4F<T> left, Matrix5x4F<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4, left.Row5 + right.Row5);
+        public static Matrix5x4F<T> operator +(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4,
+                left.Row5 + right.Row5);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix5x4F<T> operator -(Matrix5x4F<T> left, Matrix5x4F<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4, left.Row5 - right.Row5);
+        public static Matrix5x4F<T> operator -(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4,
+                left.Row5 - right.Row5);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix5x4F<T> operator *(Matrix5x4F<T> left, Matrix4x4F<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4, left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
+        public static Matrix5x4F<T> operator *(Matrix5x4F<T> left, Matrix4x4F<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
+                left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
 }
\ No newline at end of file
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
index 7b794338b0..34c888afcf 100644
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -7,15 +7,24 @@ partial struct Matrix5x4I<T> : IEquatable<Matrix5x4I<T>> where T : IBinaryIntege
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
+
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row2;
+
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row3;
+
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row4;
+
         /// <summary>The 5th row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row5;
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix5x4I{T}"/> from the given rows.
+        /// </summary>
         public Matrix5x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4, Vector4I<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+
         [UnscopedRef]
         public ref Vector4I<T> this[int row]
         {
@@ -41,74 +50,121 @@ public ref Vector4I<T> this[int row]
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         public T M11 => Row1.X;
+
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
         public T M12 => Row1.Y;
+
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
         public T M13 => Row1.Z;
+
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
         public T M14 => Row1.W;
+
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
         public T M21 => Row2.X;
+
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
         public T M22 => Row2.Y;
+
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
         public T M23 => Row2.Z;
+
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
         public T M24 => Row2.W;
+
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
         public T M31 => Row3.X;
+
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
         public T M32 => Row3.Y;
+
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
         public T M33 => Row3.Z;
+
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
         public T M34 => Row3.W;
+
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
         public T M41 => Row4.X;
+
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
         public T M42 => Row4.Y;
+
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
         public T M43 => Row4.Z;
+
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
         public T M44 => Row4.W;
+
         /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
         public T M51 => Row5.X;
+
         /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
         public T M52 => Row5.Y;
+
         /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
         public T M53 => Row5.Z;
+
         /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
         public T M54 => Row5.W;
+
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4I<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Matrix5x4I<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) => left.Row1 == right.Row1 && left.Row2 == right.Row2 && left.Row3 == right.Row3 && left.Row4 == right.Row4 && left.Row5 == right.Row5;
+        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4 &&
+            left.Row5 == right.Row5;
+
         /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name = "left">The first matrix to compare.</param>
-        /// <param name = "right">The second matrix to compare.</param>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Matrix5x4I<T> left, Matrix5x4I<T> right) => !(left == right);
+
         /// <summary>Adds two matrices together.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix5x4I<T> operator +(Matrix5x4I<T> left, Matrix5x4I<T> right) => new(left.Row1 + right.Row1, left.Row2 + right.Row2, left.Row3 + right.Row3, left.Row4 + right.Row4, left.Row5 + right.Row5);
+        public static Matrix5x4I<T> operator +(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4,
+                left.Row5 + right.Row5);
+
         /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix5x4I<T> operator -(Matrix5x4I<T> left, Matrix5x4I<T> right) => new(left.Row1 - right.Row1, left.Row2 - right.Row2, left.Row3 - right.Row3, left.Row4 - right.Row4, left.Row5 - right.Row5);
+        public static Matrix5x4I<T> operator -(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4,
+                left.Row5 - right.Row5);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name = "left">The first source matrix.</param>
-        /// <param name = "right">The second source matrix.</param>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix5x4I<T> operator *(Matrix5x4I<T> left, Matrix4x4I<T> right) => new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4, left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4, left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4, left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4, left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
+        public static Matrix5x4I<T> operator *(Matrix5x4I<T> left, Matrix4x4I<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
+                left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
 }
\ No newline at end of file

From 91c79827a1464740349810296e3fd4b5d22e3ca9 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Fri, 30 May 2025 19:10:52 -0700
Subject: [PATCH 18/52] Added transpose, negate, and identity.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs | 34 ++++++++++--
 sources/Maths/Maths/Matrix2x2I.gen.cs | 34 ++++++++++--
 sources/Maths/Maths/Matrix2x3F.gen.cs | 36 ++++++++++---
 sources/Maths/Maths/Matrix2x3I.gen.cs | 36 ++++++++++---
 sources/Maths/Maths/Matrix2x4F.gen.cs | 43 +++++++++++----
 sources/Maths/Maths/Matrix2x4I.gen.cs | 43 +++++++++++----
 sources/Maths/Maths/Matrix3x2F.gen.cs | 36 ++++++++++---
 sources/Maths/Maths/Matrix3x2I.gen.cs | 36 ++++++++++---
 sources/Maths/Maths/Matrix3x3F.gen.cs | 52 ++++++++++++++----
 sources/Maths/Maths/Matrix3x3I.gen.cs | 52 ++++++++++++++----
 sources/Maths/Maths/Matrix3x4F.gen.cs | 56 +++++++++++++++-----
 sources/Maths/Maths/Matrix3x4I.gen.cs | 56 +++++++++++++++-----
 sources/Maths/Maths/Matrix4x2F.gen.cs | 43 +++++++++++----
 sources/Maths/Maths/Matrix4x2I.gen.cs | 43 +++++++++++----
 sources/Maths/Maths/Matrix4x3F.gen.cs | 56 +++++++++++++++-----
 sources/Maths/Maths/Matrix4x3I.gen.cs | 56 +++++++++++++++-----
 sources/Maths/Maths/Matrix4x4F.gen.cs | 76 +++++++++++++++++++++------
 sources/Maths/Maths/Matrix4x4I.gen.cs | 76 +++++++++++++++++++++------
 sources/Maths/Maths/Matrix5x4F.gen.cs | 75 ++++++++++++++++++--------
 sources/Maths/Maths/Matrix5x4I.gen.cs | 75 ++++++++++++++++++--------
 20 files changed, 792 insertions(+), 222 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
index 0f08a02fc2..8580bd92a7 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -5,6 +5,11 @@ namespace Silk.NET.Maths
 
     partial struct Matrix2x2F<T> : IEquatable<Matrix2x2F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The multiplicative identity matrix of size 2x2.</summary>
+        public static readonly Matrix2x2F<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
 
@@ -33,17 +38,24 @@ public ref Vector2F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2F<T> other && Equals(other);
@@ -54,6 +66,11 @@ public ref Vector2F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x2F<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -84,6 +101,13 @@ public ref Vector2F<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x2F<T> operator -(Matrix2x2F<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -92,4 +116,4 @@ public ref Vector2F<T> this[int row]
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
index ecb2f945a4..7b0fa16268 100644
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -5,6 +5,11 @@ namespace Silk.NET.Maths
 
     partial struct Matrix2x2I<T> : IEquatable<Matrix2x2I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The multiplicative identity matrix of size 2x2.</summary>
+        public static readonly Matrix2x2I<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
 
@@ -33,17 +38,24 @@ public ref Vector2I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x2I<T> other && Equals(other);
@@ -54,6 +66,11 @@ public ref Vector2I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x2I<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -84,6 +101,13 @@ public ref Vector2I<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x2I<T> operator -(Matrix2x2I<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -92,4 +116,4 @@ public ref Vector2I<T> this[int row]
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
index 4d6f920ce9..24cc8473f7 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -33,23 +33,32 @@ public ref Vector3F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3F<T> other && Equals(other);
@@ -60,6 +69,12 @@ public ref Vector3F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x2F<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22),
+                new(M13, M23))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -90,6 +105,13 @@ public ref Vector3F<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x3F<T> operator -(Matrix2x3F<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -106,4 +128,4 @@ public ref Vector3F<T> this[int row]
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
index 83b682d83d..a231700d91 100644
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -33,23 +33,32 @@ public ref Vector3I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x3I<T> other && Equals(other);
@@ -60,6 +69,12 @@ public ref Vector3I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x2I<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22),
+                new(M13, M23))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -90,6 +105,13 @@ public ref Vector3I<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x3I<T> operator -(Matrix2x3I<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -106,4 +128,4 @@ public ref Vector3I<T> this[int row]
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
index a310f3fabb..924c3e890b 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -33,29 +33,40 @@ public ref Vector4F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4F<T> other && Equals(other);
@@ -66,6 +77,13 @@ public ref Vector4F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x2F<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22),
+                new(M13, M23),
+                new(M14, M24))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -96,6 +114,13 @@ public ref Vector4F<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x4F<T> operator -(Matrix2x4F<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -121,4 +146,4 @@ public ref Vector4F<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
index a30c911a50..c73c789245 100644
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -33,29 +33,40 @@ public ref Vector4I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix2x4I<T> other && Equals(other);
@@ -66,6 +77,13 @@ public ref Vector4I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x2I<T> Transpose() =>
+            new(new(M11, M21),
+                new(M12, M22),
+                new(M13, M23),
+                new(M14, M24))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -96,6 +114,13 @@ public ref Vector4I<T> this[int row]
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2x4I<T> operator -(Matrix2x4I<T> value) =>
+            new(-value.Row1,
+                -value.Row2);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -121,4 +146,4 @@ public ref Vector4I<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
index 42d2c7d49c..71024879d9 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -38,23 +38,32 @@ public ref Vector2F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2F<T> other && Equals(other);
@@ -65,6 +74,11 @@ public ref Vector2F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x3F<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -98,6 +112,14 @@ public ref Vector2F<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x2F<T> operator -(Matrix3x2F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -116,4 +138,4 @@ public ref Vector2F<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
index 84c0054f95..51e0e01299 100644
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -38,23 +38,32 @@ public ref Vector2I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x2I<T> other && Equals(other);
@@ -65,6 +74,11 @@ public ref Vector2I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x3I<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -98,6 +112,14 @@ public ref Vector2I<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x2I<T> operator -(Matrix3x2I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -116,4 +138,4 @@ public ref Vector2I<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
index 35c045ea23..7be68e7e10 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -5,6 +5,12 @@ namespace Silk.NET.Maths
 
     partial struct Matrix3x3F<T> : IEquatable<Matrix3x3F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The multiplicative identity matrix of size 3x3.</summary>
+        public static readonly Matrix3x3F<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
 
@@ -38,32 +44,44 @@ public ref Vector3F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3F<T> other && Equals(other);
@@ -74,6 +92,12 @@ public ref Vector3F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x3F<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32),
+                new(M13, M23, M33))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -107,6 +131,14 @@ public ref Vector3F<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x3F<T> operator -(Matrix3x3F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -133,4 +165,4 @@ public ref Vector3F<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
index b5d63fd42c..55412a04c0 100644
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -5,6 +5,12 @@ namespace Silk.NET.Maths
 
     partial struct Matrix3x3I<T> : IEquatable<Matrix3x3I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The multiplicative identity matrix of size 3x3.</summary>
+        public static readonly Matrix3x3I<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
 
@@ -38,32 +44,44 @@ public ref Vector3I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x3I<T> other && Equals(other);
@@ -74,6 +92,12 @@ public ref Vector3I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x3I<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32),
+                new(M13, M23, M33))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -107,6 +131,14 @@ public ref Vector3I<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x3I<T> operator -(Matrix3x3I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -133,4 +165,4 @@ public ref Vector3I<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
index 124a15c20e..902cfa787f 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -38,41 +38,56 @@ public ref Vector4F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4F<T> other && Equals(other);
@@ -83,6 +98,13 @@ public ref Vector4F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x3F<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32),
+                new(M13, M23, M33),
+                new(M14, M24, M34))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -116,6 +138,14 @@ public ref Vector4F<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x4F<T> operator -(Matrix3x4F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -151,4 +181,4 @@ public ref Vector4F<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
index c91be5692a..b79567801c 100644
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -38,41 +38,56 @@ public ref Vector4I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix3x4I<T> other && Equals(other);
@@ -83,6 +98,13 @@ public ref Vector4I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x3I<T> Transpose() =>
+            new(new(M11, M21, M31),
+                new(M12, M22, M32),
+                new(M13, M23, M33),
+                new(M14, M24, M34))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -116,6 +138,14 @@ public ref Vector4I<T> this[int row]
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3x4I<T> operator -(Matrix3x4I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -151,4 +181,4 @@ public ref Vector4I<T> this[int row]
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
index 227a09e12c..eda549ff75 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -43,29 +43,40 @@ public ref Vector2F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2F<T> other && Equals(other);
@@ -76,6 +87,11 @@ public ref Vector2F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x4F<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -112,6 +128,15 @@ public ref Vector2F<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x2F<T> operator -(Matrix4x2F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -142,4 +167,4 @@ public ref Vector2F<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
index 9d688dc387..9650f89dd0 100644
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -43,29 +43,40 @@ public ref Vector2I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x2I<T> other && Equals(other);
@@ -76,6 +87,11 @@ public ref Vector2I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix2x4I<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -112,6 +128,15 @@ public ref Vector2I<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x2I<T> operator -(Matrix4x2I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -142,4 +167,4 @@ public ref Vector2I<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
index 28b958a85c..9ca4684385 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -43,41 +43,56 @@ public ref Vector3F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3F<T> other && Equals(other);
@@ -88,6 +103,12 @@ public ref Vector3F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x4F<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42),
+                new(M13, M23, M33, M43))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -124,6 +145,15 @@ public ref Vector3F<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x3F<T> operator -(Matrix4x3F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -162,4 +192,4 @@ public ref Vector3F<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
index 662211575c..f6bb070cd6 100644
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -43,41 +43,56 @@ public ref Vector3I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x3I<T> other && Equals(other);
@@ -88,6 +103,12 @@ public ref Vector3I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix3x4I<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42),
+                new(M13, M23, M33, M43))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -124,6 +145,15 @@ public ref Vector3I<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x3I<T> operator -(Matrix4x3I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -162,4 +192,4 @@ public ref Vector3I<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
index a93bd5a9f9..57beae3c7c 100644
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -5,6 +5,13 @@ namespace Silk.NET.Maths
 
     partial struct Matrix4x4F<T> : IEquatable<Matrix4x4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The multiplicative identity matrix of size 4x4.</summary>
+        public static readonly Matrix4x4F<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero, T.Zero, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity, T.Zero, T.Zero),
+            new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
 
@@ -43,53 +50,72 @@ public ref Vector4F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        public T M44 => Row4.W;
+        [UnscopedRef]
+        public ref T M44 => ref Row4.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4F<T> other && Equals(other);
@@ -100,6 +126,13 @@ public ref Vector4F<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x4F<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42),
+                new(M13, M23, M33, M43),
+                new(M14, M24, M34, M44))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -136,6 +169,15 @@ public ref Vector4F<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x4F<T> operator -(Matrix4x4F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -183,4 +225,4 @@ public ref Vector4F<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
index 27db725337..bcb214be32 100644
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -5,6 +5,13 @@ namespace Silk.NET.Maths
 
     partial struct Matrix4x4I<T> : IEquatable<Matrix4x4I<T>> where T : IBinaryInteger<T>
     {
+        /// <summary>The multiplicative identity matrix of size 4x4.</summary>
+        public static readonly Matrix4x4I<T> Identity = new(
+            new(T.MultiplicativeIdentity, T.Zero, T.Zero, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity, T.Zero, T.Zero),
+            new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
 
@@ -43,53 +50,72 @@ public ref Vector4I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        public T M44 => Row4.W;
+        [UnscopedRef]
+        public ref T M44 => ref Row4.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix4x4I<T> other && Equals(other);
@@ -100,6 +126,13 @@ public ref Vector4I<T> this[int row]
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4x4I<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42),
+                new(M13, M23, M33, M43),
+                new(M14, M24, M34, M44))
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -136,6 +169,15 @@ public ref Vector4I<T> this[int row]
                 left.Row3 - right.Row3,
                 left.Row4 - right.Row4);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4x4I<T> operator -(Matrix4x4I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -183,4 +225,4 @@ public ref Vector4I<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
index 353f89cd9d..21d92e2e86 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -48,65 +48,88 @@ public ref Vector4F<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        public T M44 => Row4.W;
+        [UnscopedRef]
+        public ref T M44 => ref Row4.W;
 
         /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
-        public T M51 => Row5.X;
+        [UnscopedRef]
+        public ref T M51 => ref Row5.X;
 
         /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
-        public T M52 => Row5.Y;
+        [UnscopedRef]
+        public ref T M52 => ref Row5.Y;
 
         /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
-        public T M53 => Row5.Z;
+        [UnscopedRef]
+        public ref T M53 => ref Row5.Z;
 
         /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
-        public T M54 => Row5.W;
+        [UnscopedRef]
+        public ref T M54 => ref Row5.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4F<T> other && Equals(other);
@@ -156,6 +179,16 @@ public ref Vector4F<T> this[int row]
                 left.Row4 - right.Row4,
                 left.Row5 - right.Row5);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix5x4F<T> operator -(Matrix5x4F<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4,
+                -value.Row5);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -167,4 +200,4 @@ public ref Vector4F<T> this[int row]
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
index 34c888afcf..3a6b10fc9a 100644
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -48,65 +48,88 @@ public ref Vector4I<T> this[int row]
             }
         }
 
+        [UnscopedRef]
+        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        public T M11 => Row1.X;
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        public T M12 => Row1.Y;
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        public T M13 => Row1.Z;
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        public T M14 => Row1.W;
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        public T M21 => Row2.X;
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        public T M22 => Row2.Y;
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        public T M23 => Row2.Z;
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        public T M24 => Row2.W;
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        public T M31 => Row3.X;
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        public T M32 => Row3.Y;
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        public T M33 => Row3.Z;
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        public T M34 => Row3.W;
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        public T M41 => Row4.X;
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        public T M42 => Row4.Y;
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        public T M43 => Row4.Z;
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
 
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        public T M44 => Row4.W;
+        [UnscopedRef]
+        public ref T M44 => ref Row4.W;
 
         /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
-        public T M51 => Row5.X;
+        [UnscopedRef]
+        public ref T M51 => ref Row5.X;
 
         /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
-        public T M52 => Row5.Y;
+        [UnscopedRef]
+        public ref T M52 => ref Row5.Y;
 
         /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
-        public T M53 => Row5.Z;
+        [UnscopedRef]
+        public ref T M53 => ref Row5.Z;
 
         /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
-        public T M54 => Row5.W;
+        [UnscopedRef]
+        public ref T M54 => ref Row5.W;
 
         /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Matrix5x4I<T> other && Equals(other);
@@ -156,6 +179,16 @@ public ref Vector4I<T> this[int row]
                 left.Row4 - right.Row4,
                 left.Row5 - right.Row5);
 
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix5x4I<T> operator -(Matrix5x4I<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4,
+                -value.Row5);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -167,4 +200,4 @@ public ref Vector4I<T> this[int row]
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
-}
\ No newline at end of file
+}

From 650f30b9602af33915b0c7d25b84eaca9f608991 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Fri, 30 May 2025 19:53:13 -0700
Subject: [PATCH 19/52] Added some necessary vector bits for testing.

---
 sources/Maths/Maths/Vector3F.gen.cs | 67 +++++++++++++++++++++++++++-
 sources/Maths/Maths/Vector4F.gen.cs | 68 ++++++++++++++++++++++++++++-
 2 files changed, 133 insertions(+), 2 deletions(-)

diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index e37480e2c7..91200da492 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -5,14 +5,79 @@ namespace Silk.NET.Maths
     partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIeee754<T>
     {
         public T X;
+
         public T Y;
+
         public T Z;
+
+        public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
+
         public static bool operator ==(Vector3F<T> left, Vector3F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
+
         public static bool operator !=(Vector3F<T> left, Vector3F<T> right) => !(left == right);
+
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Vector3F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Vector3F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
     }
-}
\ No newline at end of file
+
+    static partial class Vector3F
+    {
+        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
+
+        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> newBase)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z));
+
+        public static Vector3F<TSelf> LogP1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z));
+
+        public static Vector3F<TSelf> Log2<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z));
+
+        public static Vector3F<TSelf> Log2P1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z));
+
+        public static Vector3F<TSelf> Log10<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z));
+
+        public static Vector3F<TSelf> Log10P1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z));
+
+        public static Vector3F<TSelf> Exp<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z));
+
+        public static Vector3F<TSelf> ExpM1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z));
+
+        public static Vector3F<TSelf> Exp2<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z));
+
+        public static Vector3F<TSelf> Exp2M1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z));
+
+        public static Vector3F<TSelf> Exp10<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z));
+
+        public static Vector3F<TSelf> Exp10M1<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z));
+    }
+}
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index 77defbefa4..71382c9d43 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -5,15 +5,81 @@ namespace Silk.NET.Maths
     partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIeee754<T>
     {
         public T X;
+
         public T Y;
+
         public T Z;
+
         public T W;
+
+        public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
+
         public static bool operator ==(Vector4F<T> left, Vector4F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
+
         public static bool operator !=(Vector4F<T> left, Vector4F<T> right) => !(left == right);
+
+        /// <inheridoc/>
         public override bool Equals(object? obj) => obj is Vector4F<T> other && Equals(other);
+
         /// <inheridoc/>
         public bool Equals(Vector4F<T> other) => this == other;
+
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
     }
-}
\ No newline at end of file
+
+    static partial class Vector4F
+    {
+        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
+
+        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> newBase)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z), TSelf.Log(x.W, newBase.W));
+
+        public static Vector4F<TSelf> LogP1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z), TSelf.LogP1(x.W));
+
+        public static Vector4F<TSelf> Log2<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z), TSelf.Log2(x.W));
+
+        public static Vector4F<TSelf> Log2P1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z), TSelf.Log2P1(x.W));
+
+        public static Vector4F<TSelf> Log10<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z), TSelf.Log10(x.W));
+
+        public static Vector4F<TSelf> Log10P1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z), TSelf.Log10P1(x.W));
+
+        public static Vector4F<TSelf> Exp<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z), TSelf.Exp(x.W));
+
+        public static Vector4F<TSelf> ExpM1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z), TSelf.ExpM1(x.W));
+
+        public static Vector4F<TSelf> Exp2<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z), TSelf.Exp2(x.W));
+
+        public static Vector4F<TSelf> Exp2M1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z), TSelf.Exp2M1(x.W));
+
+        public static Vector4F<TSelf> Exp10<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z), TSelf.Exp10(x.W));
+
+        public static Vector4F<TSelf> Exp10M1<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z), TSelf.Exp10M1(x.W));
+    }
+}

From 9bd27fea999dc5bf8f5e46a7662a5684a4b3b1c8 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 00:27:34 -0700
Subject: [PATCH 20/52] Add Lerp and a couple of bugfixes.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs | 12 ++++++++++--
 sources/Maths/Maths/Matrix2x2I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix2x3F.gen.cs | 12 ++++++++++--
 sources/Maths/Maths/Matrix2x3I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix2x4F.gen.cs | 12 ++++++++++--
 sources/Maths/Maths/Matrix2x4I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix3x2F.gen.cs | 13 +++++++++++--
 sources/Maths/Maths/Matrix3x2I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix3x3F.gen.cs | 13 +++++++++++--
 sources/Maths/Maths/Matrix3x3I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix3x4F.gen.cs | 13 +++++++++++--
 sources/Maths/Maths/Matrix3x4I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix4x2F.gen.cs | 14 ++++++++++++--
 sources/Maths/Maths/Matrix4x2I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix4x3F.gen.cs | 14 ++++++++++++--
 sources/Maths/Maths/Matrix4x3I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix4x4F.gen.cs | 14 ++++++++++++--
 sources/Maths/Maths/Matrix4x4I.gen.cs |  5 +++--
 sources/Maths/Maths/Matrix5x4F.gen.cs | 13 ++++++++++++-
 sources/Maths/Maths/Matrix5x4I.gen.cs |  3 ++-
 sources/Maths/Maths/Vector3F.gen.cs   | 19 +++++++++++++++++++
 sources/Maths/Maths/Vector4F.gen.cs   | 21 +++++++++++++++++++++
 22 files changed, 180 insertions(+), 38 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
index 8580bd92a7..c62683fff5 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -39,7 +39,7 @@ public ref Vector2F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -69,7 +69,7 @@ public ref Vector2F<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x2F<T> Transpose() =>
             new(new(M11, M21),
-                new(M12, M22))
+                new(M12, M22));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -116,4 +116,12 @@ public Matrix2x2F<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
     }
+
+    static partial class Matrix2x2F
+    {
+        public static Matrix2x2F<T> Lerp<T>(Matrix2x2F<T> value1, Matrix2x2F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
index 7b0fa16268..16c8a107ec 100644
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -39,7 +39,7 @@ public ref Vector2I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -69,7 +69,7 @@ public ref Vector2I<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x2I<T> Transpose() =>
             new(new(M11, M21),
-                new(M12, M22))
+                new(M12, M22));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -116,4 +116,5 @@ public Matrix2x2I<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
index 24cc8473f7..cac16010eb 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -34,7 +34,7 @@ public ref Vector3F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -73,7 +73,7 @@ public ref Vector3F<T> this[int row]
         public Matrix3x2F<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
-                new(M13, M23))
+                new(M13, M23));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -128,4 +128,12 @@ public Matrix3x2F<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
+
+    static partial class Matrix2x3F
+    {
+        public static Matrix2x3F<T> Lerp<T>(Matrix2x3F<T> value1, Matrix2x3F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
index a231700d91..6c6850f7d3 100644
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -34,7 +34,7 @@ public ref Vector3I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -73,7 +73,7 @@ public ref Vector3I<T> this[int row]
         public Matrix3x2I<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
-                new(M13, M23))
+                new(M13, M23));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -128,4 +128,5 @@ public Matrix3x2I<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
index 924c3e890b..39f678fdbf 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -34,7 +34,7 @@ public ref Vector4F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -82,7 +82,7 @@ public Matrix4x2F<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
                 new(M13, M23),
-                new(M14, M24))
+                new(M14, M24));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -146,4 +146,12 @@ public Matrix4x2F<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
+
+    static partial class Matrix2x4F
+    {
+        public static Matrix2x4F<T> Lerp<T>(Matrix2x4F<T> value1, Matrix2x4F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
index c73c789245..83ccbf2915 100644
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -34,7 +34,7 @@ public ref Vector4I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -82,7 +82,7 @@ public Matrix4x2I<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
                 new(M13, M23),
-                new(M14, M24))
+                new(M14, M24));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -146,4 +146,5 @@ public Matrix4x2I<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
index 71024879d9..5466041d8e 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -39,7 +39,7 @@ public ref Vector2F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -77,7 +77,7 @@ public ref Vector2F<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x3F<T> Transpose() =>
             new(new(M11, M21, M31),
-                new(M12, M22, M32))
+                new(M12, M22, M32));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -138,4 +138,13 @@ public Matrix2x3F<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
+
+    static partial class Matrix3x2F
+    {
+        public static Matrix3x2F<T> Lerp<T>(Matrix3x2F<T> value1, Matrix3x2F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
index 51e0e01299..dd4b7655c5 100644
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -39,7 +39,7 @@ public ref Vector2I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -77,7 +77,7 @@ public ref Vector2I<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x3I<T> Transpose() =>
             new(new(M11, M21, M31),
-                new(M12, M22, M32))
+                new(M12, M22, M32));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -138,4 +138,5 @@ public Matrix2x3I<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
index 7be68e7e10..c3415735dd 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -45,7 +45,7 @@ public ref Vector3F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -96,7 +96,7 @@ public ref Vector3F<T> this[int row]
         public Matrix3x3F<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
-                new(M13, M23, M33))
+                new(M13, M23, M33));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -165,4 +165,13 @@ public Matrix3x3F<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
+
+    static partial class Matrix3x3F
+    {
+        public static Matrix3x3F<T> Lerp<T>(Matrix3x3F<T> value1, Matrix3x3F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
index 55412a04c0..13c28c90e0 100644
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -45,7 +45,7 @@ public ref Vector3I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -96,7 +96,7 @@ public ref Vector3I<T> this[int row]
         public Matrix3x3I<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
-                new(M13, M23, M33))
+                new(M13, M23, M33));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -165,4 +165,5 @@ public Matrix3x3I<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
index 902cfa787f..43533089d8 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -39,7 +39,7 @@ public ref Vector4F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -103,7 +103,7 @@ public Matrix4x3F<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
                 new(M13, M23, M33),
-                new(M14, M24, M34))
+                new(M14, M24, M34));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -181,4 +181,13 @@ public Matrix4x3F<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
+
+    static partial class Matrix3x4F
+    {
+        public static Matrix3x4F<T> Lerp<T>(Matrix3x4F<T> value1, Matrix3x4F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
index b79567801c..b67f9c975c 100644
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -39,7 +39,7 @@ public ref Vector4I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -103,7 +103,7 @@ public Matrix4x3I<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
                 new(M13, M23, M33),
-                new(M14, M24, M34))
+                new(M14, M24, M34));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -181,4 +181,5 @@ public Matrix4x3I<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
index eda549ff75..b0857a7e97 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -44,7 +44,7 @@ public ref Vector2F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -90,7 +90,7 @@ public ref Vector2F<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x4F<T> Transpose() =>
             new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42))
+                new(M12, M22, M32, M42));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -167,4 +167,14 @@ public Matrix2x4F<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
     }
+
+    static partial class Matrix4x2F
+    {
+        public static Matrix4x2F<T> Lerp<T>(Matrix4x2F<T> value1, Matrix4x2F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount)),
+                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
index 9650f89dd0..c1a69252e8 100644
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -44,7 +44,7 @@ public ref Vector2I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector2I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -90,7 +90,7 @@ public ref Vector2I<T> this[int row]
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2x4I<T> Transpose() =>
             new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42))
+                new(M12, M22, M32, M42));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -167,4 +167,5 @@ public Matrix2x4I<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
index 9ca4684385..0c9b09f564 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -44,7 +44,7 @@ public ref Vector3F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -107,7 +107,7 @@ public ref Vector3F<T> this[int row]
         public Matrix3x4F<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42),
-                new(M13, M23, M33, M43))
+                new(M13, M23, M33, M43));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -192,4 +192,14 @@ public Matrix3x4F<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
+
+    static partial class Matrix4x3F
+    {
+        public static Matrix4x3F<T> Lerp<T>(Matrix4x3F<T> value1, Matrix4x3F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount)),
+                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
index f6bb070cd6..61a169be3c 100644
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -44,7 +44,7 @@ public ref Vector3I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector3I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -107,7 +107,7 @@ public ref Vector3I<T> this[int row]
         public Matrix3x4I<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42),
-                new(M13, M23, M33, M43))
+                new(M13, M23, M33, M43));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -192,4 +192,5 @@ public Matrix3x4I<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
index 57beae3c7c..0a0ebcd076 100644
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -51,7 +51,7 @@ public ref Vector4F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -131,7 +131,7 @@ public Matrix4x4F<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42),
                 new(M13, M23, M33, M43),
-                new(M14, M24, M34, M44))
+                new(M14, M24, M34, M44));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -225,4 +225,14 @@ public Matrix4x4F<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
+
+    static partial class Matrix4x4F
+    {
+        public static Matrix4x4F<T> Lerp<T>(Matrix4x4F<T> value1, Matrix4x4F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)),
+                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount), T.Lerp(value1.M44, value2.M44, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
index bcb214be32..c0104e5347 100644
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -51,7 +51,7 @@ public ref Vector4I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -131,7 +131,7 @@ public Matrix4x4I<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42),
                 new(M13, M23, M33, M43),
-                new(M14, M24, M34, M44))
+                new(M14, M24, M34, M44));
 
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
@@ -225,4 +225,5 @@ public Matrix4x4I<T> Transpose() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
     }
+
 }
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
index 21d92e2e86..24eeb8e2e8 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -49,7 +49,7 @@ public ref Vector4F<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -200,4 +200,15 @@ public ref Vector4F<T> this[int row]
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
+
+    static partial class Matrix5x4F
+    {
+        public static Matrix5x4F<T> Lerp<T>(Matrix5x4F<T> value1, Matrix5x4F<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
+                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
+                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)),
+                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount), T.Lerp(value1.M44, value2.M44, amount)),
+                new(T.Lerp(value1.M51, value2.M51, amount), T.Lerp(value1.M52, value2.M52, amount), T.Lerp(value1.M53, value2.M53, amount), T.Lerp(value1.M54, value2.M54, amount)));
+    }
 }
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
index 3a6b10fc9a..0b9a7bbf08 100644
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -49,7 +49,7 @@ public ref Vector4I<T> this[int row]
         }
 
         [UnscopedRef]
-        public ref Vector4I<T> this[int row, int column] => ref this[row][column];
+        public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
         [UnscopedRef]
@@ -200,4 +200,5 @@ public ref Vector4I<T> this[int row]
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
+
 }
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 91200da492..5403e5fa56 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -12,6 +12,25 @@ partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIee
 
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
         public static bool operator ==(Vector3F<T> left, Vector3F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
 
         public static bool operator !=(Vector3F<T> left, Vector3F<T> right) => !(left == right);
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index 71382c9d43..7b3050ed5a 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -14,6 +14,27 @@ partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIee
 
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                    case 3:
+                        return ref W;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
         public static bool operator ==(Vector4F<T> left, Vector4F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
 
         public static bool operator !=(Vector4F<T> left, Vector4F<T> right) => !(left == right);

From a617eb865bedcb80ce6fdb27e5fab1cb45822999 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Sat, 31 May 2025 17:42:25 +1000
Subject: [PATCH 21/52] Remove `IBinaryFloatingPointIeee754` reference.

---
 sources/Maths/Maths/Vector2F.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 26d8c13047..f5a807d4ec 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -477,7 +477,7 @@ public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
         public static bool operator !=(Vector2F<T> left, Vector2F<T> right) =>
             left.X != right.X || left.Y != right.Y;
 
-        // IBinaryFloatingPointIeee754
+        // IFloatingPointIeee754
         public static Vector2F<T> Sqrt(Vector2F<T> x) =>
             new(T.Sqrt(x.X), T.Sqrt(x.Y));
 

From d57f94d0433b710ed59412a42196223631bf6f18 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Sat, 31 May 2025 17:58:00 +1000
Subject: [PATCH 22/52] Make `VectorNI` Vectors use a `ref` indexer.

---
 sources/Maths/Maths/Vector2I.cs | 30 +++++++++++++++++++++++-------
 sources/Maths/Maths/Vector3I.cs | 29 ++++++++++++++++++++++-------
 sources/Maths/Maths/Vector4I.cs | 31 +++++++++++++++++++++++--------
 3 files changed, 68 insertions(+), 22 deletions(-)

diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 2fde654cb2..1b5f7e9d31 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -5,6 +5,7 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
@@ -65,13 +66,27 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>The number of elements in the vector.</summary>
         public int Count => 2;
 
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
-        };
+
+        /// <summary>Gets or sets the component at the specified index: 0 = X, 1 = Y.</summary>
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                }
+            }
+        }
+
+        /// <summary>Gets the component at the specified index (<see cref="IReadOnlyList{T}"/>).</summary>
+        T IReadOnlyList<T>.this[int index] => this[index];
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2I{T}"/> instance.</summary>
         public override bool Equals(object? obj) => obj is Vector2I<T> other && Equals(other);
@@ -238,6 +253,7 @@ public void CopyTo(Span<T> span, int startIndex)
         {
             if (startIndex < 0 || startIndex + 2 > span.Length)
                 throw new ArgumentOutOfRangeException(nameof(startIndex));
+
             span[startIndex] = X;
             span[startIndex + 1] = Y;
         }
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 9aa815c588..f8dc86aac0 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -5,6 +5,7 @@
 using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using System.Text;
 
@@ -77,13 +78,27 @@ public Vector3I(ReadOnlySpan<T> values)
         public int Count => 3;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            2 => Z,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, or 2.")
-        };
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                }
+            }
+        }
+
+        /// <summary>Gets the component at the specified index (<see cref="IReadOnlyList{T}"/>).</summary>
+        T IReadOnlyList<T>.this[int index] => this[index];
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector3I{T}"/> instance.</summary>
         public override bool Equals(object? obj) => obj is Vector3I<T> other && Equals(other);
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 038c4be24b..28c04301f8 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -87,14 +87,29 @@ public Vector4I(ReadOnlySpan<T> values)
         public int Count => 4;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            2 => Z,
-            3 => W,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, 2, or 3.")
-        };
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                    case 3:
+                        return ref W;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                }
+            }
+        }
+
+        /// <summary>Gets the component at the specified index (<see cref="IReadOnlyList{T}"/>).</summary>
+        T IReadOnlyList<T>.this[int index] => this[index];
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector4I{T}"/> instance.</summary>
         public override bool Equals(object? obj) => obj is Vector4I<T> other && Equals(other);

From d5a8b540b1e5dea0b1a5609b840c28c1be827527 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 00:59:32 -0700
Subject: [PATCH 23/52] Use partial implementations from code gen.

---
 sources/Maths/Maths/Vector2F.cs     |  34 +-------
 sources/Maths/Maths/Vector2F.gen.cs | 116 +++++++++++++++++++++++++
 sources/Maths/Maths/Vector2I.cs     |  35 +-------
 sources/Maths/Maths/Vector2I.gen.cs | 116 +++++++++++++++++++++++++
 sources/Maths/Maths/Vector3F.gen.cs |  21 ++++-
 sources/Maths/Maths/Vector3I.cs     |  39 +--------
 sources/Maths/Maths/Vector3I.gen.cs | 122 ++++++++++++++++++++++++++
 sources/Maths/Maths/Vector4F.gen.cs |  23 ++++-
 sources/Maths/Maths/Vector4I.cs     |  49 +----------
 sources/Maths/Maths/Vector4I.gen.cs | 128 ++++++++++++++++++++++++++++
 10 files changed, 526 insertions(+), 157 deletions(-)
 create mode 100644 sources/Maths/Maths/Vector2F.gen.cs
 create mode 100644 sources/Maths/Maths/Vector2I.gen.cs
 create mode 100644 sources/Maths/Maths/Vector3I.gen.cs
 create mode 100644 sources/Maths/Maths/Vector4I.gen.cs

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 26d8c13047..ab01de7af5 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -14,7 +14,7 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D floating-point vector.</summary>
-    internal struct Vector2F<T> :
+    internal partial struct Vector2F<T> :
         IEquatable<Vector2F<T>>,
         IReadOnlyList<T>,
         ISpanFormattable,
@@ -25,18 +25,9 @@ internal struct Vector2F<T> :
         IFormattable
         where T : IFloatingPointIeee754<T>
     {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
         /// <summary>Initializes both components to the same value.</summary>
         public Vector2F(T value) => (X, Y) = (value, value);
 
-        /// <summary>Initializes the vector with individual values for X and Y.</summary>
-        public Vector2F(T x, T y) => (X, Y) = (x, y);
-
         /// <summary>Initializes the vector from a span of two values.</summary>
         public Vector2F(ReadOnlySpan<T> values)
         {
@@ -71,22 +62,6 @@ public Vector2F(ReadOnlySpan<T> values)
         /// <summary>The number of elements in the vector.</summary>
         public int Count => 2;
 
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
-        };
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2F{T}"/> instance.</summary>
-        public override bool Equals(object? obj) => obj is Vector2F<T> other && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the given Vector2F is equal to this <see cref="Vector2F{T}"/> instance.</summary>
-        public bool Equals(Vector2F<T> other) => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => HashCode.Combine(X, Y);
-
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
         {
@@ -470,13 +445,6 @@ public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
         public static Vector2F<T> operator -(Vector2F<T> vector) =>
             new(-vector.X, -vector.Y);
 
-        // Equality Operators
-        public static bool operator ==(Vector2F<T> left, Vector2F<T> right) =>
-            left.X == right.X && left.Y == right.Y;
-
-        public static bool operator !=(Vector2F<T> left, Vector2F<T> right) =>
-            left.X != right.X || left.Y != right.Y;
-
         // IBinaryFloatingPointIeee754
         public static Vector2F<T> Sqrt(Vector2F<T> x) =>
             new(T.Sqrt(x.X), T.Sqrt(x.Y));
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
new file mode 100644
index 0000000000..0598251141
--- /dev/null
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -0,0 +1,116 @@
+namespace Silk.NET.Maths
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Numerics;
+
+    partial struct Vector2F<T> : IEquatable<Vector2F<T>> where T : IFloatingPointIeee754<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>Initializes the vector with individual component values.</summary>
+        public Vector2F(T x, T y) => (X, Y) = (x, y);
+
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector2F<T> left, Vector2F<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Vector2F<T> left, Vector2F<T> right) => !(left == right);
+
+        /// <inheridoc/>
+        public override bool Equals(object? obj) => obj is Vector2F<T> other && Equals(other);
+
+        /// <inheridoc/>
+        public bool Equals(Vector2F<T> other) => this == other;
+
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y);
+    }
+
+    static partial class Vector2F
+    {
+        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y));
+
+        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> newBase)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y));
+
+        public static Vector2F<TSelf> LogP1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y));
+
+        public static Vector2F<TSelf> Log2<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y));
+
+        public static Vector2F<TSelf> Log2P1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y));
+
+        public static Vector2F<TSelf> Log10<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y));
+
+        public static Vector2F<TSelf> Log10P1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y));
+
+        public static Vector2F<TSelf> Exp<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y));
+
+        public static Vector2F<TSelf> ExpM1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y));
+
+        public static Vector2F<TSelf> Exp2<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y));
+
+        public static Vector2F<TSelf> Exp2M1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y));
+
+        public static Vector2F<TSelf> Exp10<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y));
+
+        public static Vector2F<TSelf> Exp10M1<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y));
+    }
+}
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 2fde654cb2..7defbc1030 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -11,7 +11,7 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
-    internal struct Vector2I<T> :
+    internal partial struct Vector2I<T> :
         IEquatable<Vector2I<T>>,
         IReadOnlyList<T>,
         ISpanFormattable,
@@ -22,18 +22,9 @@ internal struct Vector2I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
         /// <summary>Initializes both components to the same value.</summary>
         public Vector2I(T value) => (X, Y) = (value, value);
 
-        /// <summary>Initializes the vector with individual values for X and Y.</summary>
-        public Vector2I(T x, T y) => (X, Y) = (x, y);
-
         /// <summary>Initializes the vector from a span of two values.</summary>
         public Vector2I(ReadOnlySpan<T> values)
         {
@@ -65,23 +56,6 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>The number of elements in the vector.</summary>
         public int Count => 2;
 
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
-        };
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2I{T}"/> instance.</summary>
-        public override bool Equals(object? obj) => obj is Vector2I<T> other && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the given Vector2I is equal to this <see cref="Vector2I{T}"/> instance.</summary>
-        public bool Equals(Vector2I<T> other) => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => HashCode.Combine(X, Y);
-
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
         {
@@ -457,13 +431,6 @@ public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
         public static Vector2I<T> operator ~(Vector2I<T> vector) =>
             new Vector2I<T>(~vector.X, ~vector.Y);
 
-        // Equality Operators
-        public static bool operator ==(Vector2I<T> left, Vector2I<T> right) =>
-            left.X == right.X && left.Y == right.Y;
-
-        public static bool operator !=(Vector2I<T> left, Vector2I<T> right) =>
-            left.X != right.X || left.Y != right.Y;
-
         // IBinaryInteger
         // TODO: Verify these are actually correct
 
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
new file mode 100644
index 0000000000..4d4cb76295
--- /dev/null
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -0,0 +1,116 @@
+namespace Silk.NET.Maths
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Numerics;
+
+    partial struct Vector2I<T> : IEquatable<Vector2I<T>> where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>Initializes the vector with individual component values.</summary>
+        public Vector2I(T x, T y) => (X, Y) = (x, y);
+
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector2I<T> left, Vector2I<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Vector2I<T> left, Vector2I<T> right) => !(left == right);
+
+        /// <inheridoc/>
+        public override bool Equals(object? obj) => obj is Vector2I<T> other && Equals(other);
+
+        /// <inheridoc/>
+        public bool Equals(Vector2I<T> other) => this == other;
+
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y);
+    }
+
+    static partial class Vector2I
+    {
+        public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y));
+
+        public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> newBase)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y));
+
+        public static Vector2I<TSelf> LogP1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y));
+
+        public static Vector2I<TSelf> Log2<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y));
+
+        public static Vector2I<TSelf> Log2P1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y));
+
+        public static Vector2I<TSelf> Log10<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y));
+
+        public static Vector2I<TSelf> Log10P1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y));
+
+        public static Vector2I<TSelf> Exp<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y));
+
+        public static Vector2I<TSelf> ExpM1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y));
+
+        public static Vector2I<TSelf> Exp2<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y));
+
+        public static Vector2I<TSelf> Exp2M1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y));
+
+        public static Vector2I<TSelf> Exp10<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y));
+
+        public static Vector2I<TSelf> Exp10M1<TSelf>(this Vector2I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y));
+    }
+}
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 5403e5fa56..89631e8d92 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -1,17 +1,23 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The X component of the vector.</summary>
         public T X;
 
+        /// <summary>The Y component of the vector.</summary>
         public T Y;
 
+        /// <summary>The Z component of the vector.</summary>
         public T Z;
 
+        /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
         [UnscopedRef]
         public ref T this[int index]
         {
@@ -31,8 +37,19 @@ public ref T this[int index]
             }
         }
 
-        public static bool operator ==(Vector3F<T> left, Vector3F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z;
-
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector3F<T> left, Vector3F<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y &&
+            left.Z == right.Z;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Vector3F<T> left, Vector3F<T> right) => !(left == right);
 
         /// <inheridoc/>
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 9aa815c588..7417b9cf4a 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -11,7 +11,7 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
-    internal struct Vector3I<T> :
+    internal partial struct Vector3I<T> :
         IEquatable<Vector3I<T>>,
         IReadOnlyList<T>,
         ISpanFormattable,
@@ -22,21 +22,9 @@ internal struct Vector3I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        public T Z;
-
         /// <summary>Initializes all components to the same value.</summary>
         public Vector3I(T value) => (X, Y, Z) = (value, value, value);
 
-        /// <summary>Initializes the vector with individual values for X, Y and Z.</summary>
-        public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
-
         /// <summary>Initializes the vector from a span of three values.</summary>
         public Vector3I(ReadOnlySpan<T> values)
         {
@@ -76,24 +64,6 @@ public Vector3I(ReadOnlySpan<T> values)
         /// <summary>The number of elements in the vector.</summary>
         public int Count => 3;
 
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            2 => Z,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, or 2.")
-        };
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector3I{T}"/> instance.</summary>
-        public override bool Equals(object? obj) => obj is Vector3I<T> other && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the given Vector3I is equal to this <see cref="Vector3I{T}"/> instance.</summary>
-        public bool Equals(Vector3I<T> other) => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => HashCode.Combine(X, Y, Z);
-
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
         {
@@ -523,13 +493,6 @@ public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
         public static Vector3I<T> operator ~(Vector3I<T> vector) =>
             new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
 
-        // Equality Operators
-        public static bool operator ==(Vector3I<T> left, Vector3I<T> right) =>
-            left.X == right.X && left.Y == right.Y && left.Z == right.Z;
-
-        public static bool operator !=(Vector3I<T> left, Vector3I<T> right) =>
-            left.X != right.X || left.Y != right.Y || left.Z != right.Z;
-
         // IBinaryInteger
         public static Vector3I<T> Log2(Vector3I<T> x) =>
             new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
new file mode 100644
index 0000000000..6eccdb4014
--- /dev/null
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -0,0 +1,122 @@
+namespace Silk.NET.Maths
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Numerics;
+
+    partial struct Vector3I<T> : IEquatable<Vector3I<T>> where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>The Z component of the vector.</summary>
+        public T Z;
+
+        /// <summary>Initializes the vector with individual component values.</summary>
+        public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
+
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector3I<T> left, Vector3I<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y &&
+            left.Z == right.Z;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Vector3I<T> left, Vector3I<T> right) => !(left == right);
+
+        /// <inheridoc/>
+        public override bool Equals(object? obj) => obj is Vector3I<T> other && Equals(other);
+
+        /// <inheridoc/>
+        public bool Equals(Vector3I<T> other) => this == other;
+
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+    }
+
+    static partial class Vector3I
+    {
+        public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
+
+        public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> newBase)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z));
+
+        public static Vector3I<TSelf> LogP1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z));
+
+        public static Vector3I<TSelf> Log2<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z));
+
+        public static Vector3I<TSelf> Log2P1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z));
+
+        public static Vector3I<TSelf> Log10<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z));
+
+        public static Vector3I<TSelf> Log10P1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z));
+
+        public static Vector3I<TSelf> Exp<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z));
+
+        public static Vector3I<TSelf> ExpM1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z));
+
+        public static Vector3I<TSelf> Exp2<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z));
+
+        public static Vector3I<TSelf> Exp2M1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z));
+
+        public static Vector3I<TSelf> Exp10<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z));
+
+        public static Vector3I<TSelf> Exp10M1<TSelf>(this Vector3I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z));
+    }
+}
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index 7b3050ed5a..ca9b99b9f5 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -1,19 +1,26 @@
 namespace Silk.NET.Maths
 {
+    using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
     partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIeee754<T>
     {
+        /// <summary>The X component of the vector.</summary>
         public T X;
 
+        /// <summary>The Y component of the vector.</summary>
         public T Y;
 
+        /// <summary>The Z component of the vector.</summary>
         public T Z;
 
+        /// <summary>The W component of the vector.</summary>
         public T W;
 
+        /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
         [UnscopedRef]
         public ref T this[int index]
         {
@@ -35,8 +42,20 @@ public ref T this[int index]
             }
         }
 
-        public static bool operator ==(Vector4F<T> left, Vector4F<T> right) => left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
-
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector4F<T> left, Vector4F<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y &&
+            left.Z == right.Z &&
+            left.W == right.W;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
         public static bool operator !=(Vector4F<T> left, Vector4F<T> right) => !(left == right);
 
         /// <inheridoc/>
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 038c4be24b..78ba2afc49 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -11,7 +11,7 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
-    internal struct Vector4I<T> :
+    internal partial struct Vector4I<T> :
         IEquatable<Vector4I<T>>,
         IReadOnlyList<T>,
         ISpanFormattable,
@@ -22,24 +22,9 @@ internal struct Vector4I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        public T Z;
-
-        /// <summary>The W component of the vector.</summary>
-        public T W;
-
         /// <summary>Initializes all components to the same value.</summary>
         public Vector4I(T value) => (X, Y, Z, W) = (value, value, value, value);
 
-        /// <summary>Initializes the vector with individual values for X, Y, Z and W.</summary>
-        public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
-
         /// <summary>Initializes the vector from a span of four values.</summary>
         public Vector4I(ReadOnlySpan<T> values)
         {
@@ -86,25 +71,6 @@ public Vector4I(ReadOnlySpan<T> values)
         /// <summary>The number of elements in the vector.</summary>
         public int Count => 4;
 
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
-        // TODO: Make this a ref
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            2 => Z,
-            3 => W,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, 2, or 3.")
-        };
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector4I{T}"/> instance.</summary>
-        public override bool Equals(object? obj) => obj is Vector4I<T> other && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the given Vector4I is equal to this <see cref="Vector4I{T}"/> instance.</summary>
-        public bool Equals(Vector4I<T> other) => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
-
         /// <summary> Returns an enumerator that iterates through the vector components.</summary>
         public IEnumerator<T> GetEnumerator()
         {
@@ -541,19 +507,6 @@ public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
         public static Vector4I<T> operator ~(Vector4I<T> vector) =>
             new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
 
-        // Equality Operators
-        public static bool operator ==(Vector4I<T> left, Vector4I<T> right) =>
-            left.X == right.X &&
-            left.Y == right.Y &&
-            left.Z == right.Z &&
-            left.W == right.W;
-
-        public static bool operator !=(Vector4I<T> left, Vector4I<T> right) =>
-            left.X != right.X ||
-            left.Y != right.Y ||
-            left.Z != right.Z ||
-            left.W != right.W;
-
         // IBinaryInteger
         public static Vector4I<T> Log2(Vector4I<T> x) =>
             new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
new file mode 100644
index 0000000000..e433fd0f7b
--- /dev/null
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -0,0 +1,128 @@
+namespace Silk.NET.Maths
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Numerics;
+
+    partial struct Vector4I<T> : IEquatable<Vector4I<T>> where T : IBinaryInteger<T>
+    {
+        /// <summary>The X component of the vector.</summary>
+        public T X;
+
+        /// <summary>The Y component of the vector.</summary>
+        public T Y;
+
+        /// <summary>The Z component of the vector.</summary>
+        public T Z;
+
+        /// <summary>The W component of the vector.</summary>
+        public T W;
+
+        /// <summary>Initializes the vector with individual component values.</summary>
+        public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
+
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
+        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    case 2:
+                        return ref Z;
+                    case 3:
+                        return ref W;
+                }
+
+                throw new ArgumentOutOfRangeException(nameof(index));
+            }
+        }
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Vector4I<T> left, Vector4I<T> right) =>
+            left.X == right.X &&
+            left.Y == right.Y &&
+            left.Z == right.Z &&
+            left.W == right.W;
+
+        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
+        /// <param name="left">The first vector to compare.</param>
+        /// <param name="right">The second vector to compare.</param>
+        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Vector4I<T> left, Vector4I<T> right) => !(left == right);
+
+        /// <inheridoc/>
+        public override bool Equals(object? obj) => obj is Vector4I<T> other && Equals(other);
+
+        /// <inheridoc/>
+        public bool Equals(Vector4I<T> other) => this == other;
+
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+    }
+
+    static partial class Vector4I
+    {
+        public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
+
+        public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> newBase)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z), TSelf.Log(x.W, newBase.W));
+
+        public static Vector4I<TSelf> LogP1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z), TSelf.LogP1(x.W));
+
+        public static Vector4I<TSelf> Log2<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z), TSelf.Log2(x.W));
+
+        public static Vector4I<TSelf> Log2P1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z), TSelf.Log2P1(x.W));
+
+        public static Vector4I<TSelf> Log10<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z), TSelf.Log10(x.W));
+
+        public static Vector4I<TSelf> Log10P1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
+            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z), TSelf.Log10P1(x.W));
+
+        public static Vector4I<TSelf> Exp<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z), TSelf.Exp(x.W));
+
+        public static Vector4I<TSelf> ExpM1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z), TSelf.ExpM1(x.W));
+
+        public static Vector4I<TSelf> Exp2<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z), TSelf.Exp2(x.W));
+
+        public static Vector4I<TSelf> Exp2M1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z), TSelf.Exp2M1(x.W));
+
+        public static Vector4I<TSelf> Exp10<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z), TSelf.Exp10(x.W));
+
+        public static Vector4I<TSelf> Exp10M1<TSelf>(this Vector4I<TSelf> x)
+            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
+            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z), TSelf.Exp10M1(x.W));
+    }
+}

From 3c538bd8b77fd6296415300716d8582d3e8f685b Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Sat, 31 May 2025 18:02:15 +1000
Subject: [PATCH 24/52] Make `Vector2F` Vector use a `ref` indexer.

---
 sources/Maths/Maths/Vector2F.cs | 24 +++++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index f5a807d4ec..7085246bae 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -72,11 +72,25 @@ public Vector2F(ReadOnlySpan<T> values)
         public int Count => 2;
 
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
-        public T this[int index] => index switch {
-            0 => X,
-            1 => Y,
-            _ => throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.")
-        };
+        [UnscopedRef]
+        public ref T this[int index]
+        {
+            get
+            {
+                switch (index)
+                {
+                    case 0:
+                        return ref X;
+                    case 1:
+                        return ref Y;
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                }
+            }
+        }
+
+        /// <summary>Gets the component at the specified index (<see cref="IReadOnlyList{T}"/>).</summary>
+        T IReadOnlyList<T>.this[int index] => this[index];
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2F{T}"/> instance.</summary>
         public override bool Equals(object? obj) => obj is Vector2F<T> other && Equals(other);

From 4f74ab3d7c9f52d23b9f0424f7240c28a9ac28f1 Mon Sep 17 00:00:00 2001
From: Tweety-lab <108560864+Tweety-lab@users.noreply.github.com>
Date: Sat, 31 May 2025 18:05:07 +1000
Subject: [PATCH 25/52] Fix vector `ref` indexer exception messages.

---
 sources/Maths/Maths/Vector3I.cs | 2 +-
 sources/Maths/Maths/Vector4I.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index f8dc86aac0..5f1da1af1b 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -92,7 +92,7 @@ public ref T this[int index]
                     case 2:
                         return ref Z;
                     default:
-                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1 or 2.");
                 }
             }
         }
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 28c04301f8..24253f044b 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -103,7 +103,7 @@ public ref T this[int index]
                     case 3:
                         return ref W;
                     default:
-                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0 or 1.");
+                        throw new ArgumentOutOfRangeException(nameof(index), "Index must be 0, 1, 2 or 3.");
                 }
             }
         }

From a4b8a6cfb1e110166d0bd26654c5443af3ba57db Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 01:15:12 -0700
Subject: [PATCH 26/52] Move constructors & existing interfaces.

---
 sources/Maths/Maths/Matrix2x2F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix2x2I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix2x3F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix2x3I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix2x4F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix2x4I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x2F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x2I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x3F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x3I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x4F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix3x4I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x2F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x2I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x3F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x3I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x4F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix4x4I.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix5x4F.gen.cs |  4 +++-
 sources/Maths/Maths/Matrix5x4I.gen.cs |  4 +++-
 sources/Maths/Maths/Vector2F.cs       |  5 -----
 sources/Maths/Maths/Vector2F.gen.cs   |  8 +++++++-
 sources/Maths/Maths/Vector2I.cs       |  5 -----
 sources/Maths/Maths/Vector2I.gen.cs   |  8 +++++++-
 sources/Maths/Maths/Vector3F.gen.cs   | 11 ++++++++++-
 sources/Maths/Maths/Vector3I.cs       |  5 -----
 sources/Maths/Maths/Vector3I.gen.cs   |  8 +++++++-
 sources/Maths/Maths/Vector4F.gen.cs   | 11 ++++++++++-
 sources/Maths/Maths/Vector4I.cs       |  5 -----
 sources/Maths/Maths/Vector4I.gen.cs   |  8 +++++++-
 30 files changed, 108 insertions(+), 46 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2x2F.gen.cs
index c62683fff5..0d43a43ed1 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x2F<T> : IEquatable<Matrix2x2F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix2x2F<T> :
+        IEquatable<Matrix2x2F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The multiplicative identity matrix of size 2x2.</summary>
         public static readonly Matrix2x2F<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
index 16c8a107ec..662608b49d 100644
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x2I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x2I<T> : IEquatable<Matrix2x2I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix2x2I<T> :
+        IEquatable<Matrix2x2I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The multiplicative identity matrix of size 2x2.</summary>
         public static readonly Matrix2x2I<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2x3F.gen.cs
index cac16010eb..9c946035c6 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x3F<T> : IEquatable<Matrix2x3F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix2x3F<T> :
+        IEquatable<Matrix2x3F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
index 6c6850f7d3..03431eaac6 100644
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x3I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x3I<T> : IEquatable<Matrix2x3I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix2x3I<T> :
+        IEquatable<Matrix2x3I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2x4F.gen.cs
index 39f678fdbf..b4d4f8c6f0 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x4F<T> : IEquatable<Matrix2x4F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix2x4F<T> :
+        IEquatable<Matrix2x4F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
index 83ccbf2915..e116d0b528 100644
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix2x4I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x4I<T> : IEquatable<Matrix2x4I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix2x4I<T> :
+        IEquatable<Matrix2x4I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3x2F.gen.cs
index 5466041d8e..fa7209a596 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x2F<T> : IEquatable<Matrix3x2F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix3x2F<T> :
+        IEquatable<Matrix3x2F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
index dd4b7655c5..868cfc9584 100644
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x2I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x2I<T> : IEquatable<Matrix3x2I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix3x2I<T> :
+        IEquatable<Matrix3x2I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3x3F.gen.cs
index c3415735dd..2c94325eb2 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x3F<T> : IEquatable<Matrix3x3F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix3x3F<T> :
+        IEquatable<Matrix3x3F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The multiplicative identity matrix of size 3x3.</summary>
         public static readonly Matrix3x3F<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
index 13c28c90e0..3cee1adfaf 100644
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x3I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x3I<T> : IEquatable<Matrix3x3I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix3x3I<T> :
+        IEquatable<Matrix3x3I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The multiplicative identity matrix of size 3x3.</summary>
         public static readonly Matrix3x3I<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3x4F.gen.cs
index 43533089d8..45de27a659 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x4F<T> : IEquatable<Matrix3x4F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix3x4F<T> :
+        IEquatable<Matrix3x4F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
index b67f9c975c..83fba2ab2f 100644
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix3x4I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x4I<T> : IEquatable<Matrix3x4I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix3x4I<T> :
+        IEquatable<Matrix3x4I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4x2F.gen.cs
index b0857a7e97..b5d608a7e0 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x2F<T> : IEquatable<Matrix4x2F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix4x2F<T> :
+        IEquatable<Matrix4x2F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
index c1a69252e8..a1d468858e 100644
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x2I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x2I<T> : IEquatable<Matrix4x2I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix4x2I<T> :
+        IEquatable<Matrix4x2I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector2I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4x3F.gen.cs
index 0c9b09f564..5600ad456c 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x3F<T> : IEquatable<Matrix4x3F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix4x3F<T> :
+        IEquatable<Matrix4x3F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
index 61a169be3c..49b3576f0a 100644
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x3I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x3I<T> : IEquatable<Matrix4x3I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix4x3I<T> :
+        IEquatable<Matrix4x3I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector3I<T> Row1;
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
index 0a0ebcd076..9c2acdddf3 100644
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x4F<T> : IEquatable<Matrix4x4F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix4x4F<T> :
+        IEquatable<Matrix4x4F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The multiplicative identity matrix of size 4x4.</summary>
         public static readonly Matrix4x4F<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
index c0104e5347..ebae4c3681 100644
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix4x4I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x4I<T> : IEquatable<Matrix4x4I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix4x4I<T> :
+        IEquatable<Matrix4x4I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The multiplicative identity matrix of size 4x4.</summary>
         public static readonly Matrix4x4I<T> Identity = new(
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5x4F.gen.cs
index 24eeb8e2e8..0c299fd514 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4F.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix5x4F<T> : IEquatable<Matrix5x4F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Matrix5x4F<T> :
+        IEquatable<Matrix5x4F<T>>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4F<T> Row1;
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
index 0b9a7bbf08..a57e492891 100644
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ b/sources/Maths/Maths/Matrix5x4I.gen.cs
@@ -3,7 +3,9 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix5x4I<T> : IEquatable<Matrix5x4I<T>> where T : IBinaryInteger<T>
+    partial struct Matrix5x4I<T> :
+        IEquatable<Matrix5x4I<T>>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         public Vector4I<T> Row1;
diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 7b32f7533b..21506767f7 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -15,8 +15,6 @@ namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D floating-point vector.</summary>
     internal partial struct Vector2F<T> :
-        IEquatable<Vector2F<T>>,
-        IReadOnlyList<T>,
         ISpanFormattable,
         ISpanParsable<Vector2F<T>>,
         IUtf8SpanFormattable,
@@ -25,9 +23,6 @@ internal partial struct Vector2F<T> :
         IFormattable
         where T : IFloatingPointIeee754<T>
     {
-        /// <summary>Initializes both components to the same value.</summary>
-        public Vector2F(T value) => (X, Y) = (value, value);
-
         /// <summary>Initializes the vector from a span of two values.</summary>
         public Vector2F(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index 0598251141..fa98f7d834 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector2F<T> : IEquatable<Vector2F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Vector2F<T> :
+        IEquatable<Vector2F<T>>,
+        IReadOnlyList<T>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -11,6 +14,9 @@ partial struct Vector2F<T> : IEquatable<Vector2F<T>> where T : IFloatingPointIee
         /// <summary>The Y component of the vector.</summary>
         public T Y;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector2F(T value) => (X, Y) = (value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2F(T x, T y) => (X, Y) = (x, y);
 
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index fe3c8316c8..b8865ad065 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -13,8 +13,6 @@ namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
     internal partial struct Vector2I<T> :
-        IEquatable<Vector2I<T>>,
-        IReadOnlyList<T>,
         ISpanFormattable,
         ISpanParsable<Vector2I<T>>,
         IUtf8SpanFormattable,
@@ -23,9 +21,6 @@ internal partial struct Vector2I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>Initializes both components to the same value.</summary>
-        public Vector2I(T value) => (X, Y) = (value, value);
-
         /// <summary>Initializes the vector from a span of two values.</summary>
         public Vector2I(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index 4d4cb76295..92bb8715a1 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector2I<T> : IEquatable<Vector2I<T>> where T : IBinaryInteger<T>
+    partial struct Vector2I<T> :
+        IEquatable<Vector2I<T>>,
+        IReadOnlyList<T>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -11,6 +14,9 @@ partial struct Vector2I<T> : IEquatable<Vector2I<T>> where T : IBinaryInteger<T>
         /// <summary>The Y component of the vector.</summary>
         public T Y;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector2I(T value) => (X, Y) = (value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2I(T x, T y) => (X, Y) = (x, y);
 
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 89631e8d92..00b3a4cc63 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Vector3F<T> :
+        IEquatable<Vector3F<T>>,
+        IReadOnlyList<T>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -14,9 +17,15 @@ partial struct Vector3F<T> : IEquatable<Vector3F<T>> where T : IFloatingPointIee
         /// <summary>The Z component of the vector.</summary>
         public T Z;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector3F(T value) => (X, Y, Z) = (value, value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
         [UnscopedRef]
         public ref T this[int index]
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 58c4bc0169..77c5e07e18 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -13,8 +13,6 @@ namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
     internal partial struct Vector3I<T> :
-        IEquatable<Vector3I<T>>,
-        IReadOnlyList<T>,
         ISpanFormattable,
         ISpanParsable<Vector3I<T>>,
         IUtf8SpanFormattable,
@@ -23,9 +21,6 @@ internal partial struct Vector3I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>Initializes all components to the same value.</summary>
-        public Vector3I(T value) => (X, Y, Z) = (value, value, value);
-
         /// <summary>Initializes the vector from a span of three values.</summary>
         public Vector3I(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index 6eccdb4014..e159c50087 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector3I<T> : IEquatable<Vector3I<T>> where T : IBinaryInteger<T>
+    partial struct Vector3I<T> :
+        IEquatable<Vector3I<T>>,
+        IReadOnlyList<T>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -14,6 +17,9 @@ partial struct Vector3I<T> : IEquatable<Vector3I<T>> where T : IBinaryInteger<T>
         /// <summary>The Z component of the vector.</summary>
         public T Z;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector3I(T value) => (X, Y, Z) = (value, value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index ca9b99b9f5..d1004c6a31 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIeee754<T>
+    partial struct Vector4F<T> :
+        IEquatable<Vector4F<T>>,
+        IReadOnlyList<T>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -17,9 +20,15 @@ partial struct Vector4F<T> : IEquatable<Vector4F<T>> where T : IFloatingPointIee
         /// <summary>The W component of the vector.</summary>
         public T W;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector4F(T value) => (X, Y, Z, W) = (value, value, value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <inheritdoc/>
+        T IReadOnlyList<T>.this[int index] => this[index];
+
         ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
         [UnscopedRef]
         public ref T this[int index]
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 78ba2afc49..9abf6fb972 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -12,8 +12,6 @@ namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
     internal partial struct Vector4I<T> :
-        IEquatable<Vector4I<T>>,
-        IReadOnlyList<T>,
         ISpanFormattable,
         ISpanParsable<Vector4I<T>>,
         IUtf8SpanFormattable,
@@ -22,9 +20,6 @@ internal partial struct Vector4I<T> :
         IFormattable
         where T : IBinaryInteger<T>
     {
-        /// <summary>Initializes all components to the same value.</summary>
-        public Vector4I(T value) => (X, Y, Z, W) = (value, value, value, value);
-
         /// <summary>Initializes the vector from a span of four values.</summary>
         public Vector4I(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index e433fd0f7b..88e6dce282 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -3,7 +3,10 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Vector4I<T> : IEquatable<Vector4I<T>> where T : IBinaryInteger<T>
+    partial struct Vector4I<T> :
+        IEquatable<Vector4I<T>>,
+        IReadOnlyList<T>
+        where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -17,6 +20,9 @@ partial struct Vector4I<T> : IEquatable<Vector4I<T>> where T : IBinaryInteger<T>
         /// <summary>The W component of the vector.</summary>
         public T W;
 
+        /// <summary>Initializes all components of the vector to the same value.</summary>
+        public Vector4I(T value) => (X, Y, Z, W) = (value, value, value, value);
+
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 

From 5a82141a4663aa2f66e760bb5ffc0a9fcd0b688d Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 01:25:48 -0700
Subject: [PATCH 27/52] IReadOnlyList<T> code gen.

---
 sources/Maths/Maths/Vector2F.cs     | 13 -------------
 sources/Maths/Maths/Vector2F.gen.cs | 14 ++++++++++++++
 sources/Maths/Maths/Vector2I.cs     | 13 -------------
 sources/Maths/Maths/Vector2I.gen.cs | 14 ++++++++++++++
 sources/Maths/Maths/Vector3F.gen.cs | 15 +++++++++++++++
 sources/Maths/Maths/Vector3I.cs     | 14 --------------
 sources/Maths/Maths/Vector3I.gen.cs | 15 +++++++++++++++
 sources/Maths/Maths/Vector4F.gen.cs | 16 ++++++++++++++++
 sources/Maths/Maths/Vector4I.cs     | 15 ---------------
 sources/Maths/Maths/Vector4I.gen.cs | 16 ++++++++++++++++
 10 files changed, 90 insertions(+), 55 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 21506767f7..10c855434b 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -54,16 +54,6 @@ public Vector2F(ReadOnlySpan<T> values)
         /// <summary>Gets the length of the vector.</summary>
         public T Length => T.Sqrt(LengthSquared);
 
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 2;
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-        }
-
         /// <summary> Computes the dot product of this vector with another vector. </summary>
         public T Dot(Vector2F<T> other) => (X * other.X) + (Y * other.Y);
 
@@ -335,9 +325,6 @@ static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatPro
         static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
         /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
         public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
         {
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index fa98f7d834..34d27f31f1 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -41,6 +42,19 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 2;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index b8865ad065..2a49a846b5 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -49,16 +49,6 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y);
 
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 2;
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-        }
-
         /// <summary> Computes the dot product of this vector with another vector. </summary>
         public T Dot(Vector2I<T> other) => (X * other.X) + (Y * other.Y);
 
@@ -288,9 +278,6 @@ static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatPro
         static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
         /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
         public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
         {
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index 92bb8715a1..c8631934e7 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -41,6 +42,19 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 2;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 00b3a4cc63..93b997b6e1 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -46,6 +47,20 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 3;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 77c5e07e18..ac7a810b7d 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -57,17 +57,6 @@ public Vector3I(ReadOnlySpan<T> values)
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
 
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 3;
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-            yield return Z;
-        }
-
         /// <summary> Computes the dot product of this vector with another vector. </summary>
         public T Dot(Vector3I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z);
 
@@ -345,9 +334,6 @@ static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatPro
         static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
         /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
         public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
         {
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index e159c50087..45ee97e364 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -46,6 +47,20 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 3;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index d1004c6a31..871162afc5 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -51,6 +52,21 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 4;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+            yield return W;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 9abf6fb972..2386d7c797 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -63,18 +63,6 @@ public Vector4I(ReadOnlySpan<T> values)
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
 
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 4;
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-            yield return Z;
-            yield return W;
-        }
-
         /// <summary> Computes the dot product of this vector with another vector. </summary>
         public T Dot(Vector4I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z) + (W * other.W);
 
@@ -353,9 +341,6 @@ static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatPro
         static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
         /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
         public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
         {
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index 88e6dce282..ef2d344376 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -1,5 +1,6 @@
 namespace Silk.NET.Maths
 {
+    using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
@@ -51,6 +52,21 @@ public ref T this[int index]
             }
         }
 
+        /// <summary>The number of elements in the vector.</summary>
+        public int Count => 4;
+
+        /// <inheritdoc/>
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            yield return X;
+            yield return Y;
+            yield return Z;
+            yield return W;
+        }
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>

From 16e68e2b432d3f118ee8720b7bf32071bf1f1ec0 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 01:31:24 -0700
Subject: [PATCH 28/52] Fix errors with Quaternion accessibility.

---
 sources/Maths/Maths/Quaternion.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/sources/Maths/Maths/Quaternion.cs b/sources/Maths/Maths/Quaternion.cs
index 4df87b736a..cbc9253039 100644
--- a/sources/Maths/Maths/Quaternion.cs
+++ b/sources/Maths/Maths/Quaternion.cs
@@ -13,9 +13,9 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Represents a four-dimensional vector used to encode 3D rotations.
     /// </summary>
-    internal struct Quaternion<T> :
+    public struct Quaternion<T> :
         IEquatable<Quaternion<T>>
-        where T : IBinaryFloatingPointIeee754<T>
+        where T : IFloatingPointIeee754<T>
     {
         /// <summary>Specifies the X-value of the vector component of the Quaternion.</summary>
         public T X;

From 0cb1569788dadca8dc3cabbc2b93036f3c152e69 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 11:41:17 -0700
Subject: [PATCH 29/52] Move common operators and interfaces into templates.

---
 sources/Maths/Maths/Vector2F.cs     | 257 +-------------------
 sources/Maths/Maths/Vector2F.gen.cs | 263 ++++++++++++++++++++-
 sources/Maths/Maths/Vector2I.cs     | 300 +-----------------------
 sources/Maths/Maths/Vector2I.gen.cs | 295 ++++++++++++++++++++++-
 sources/Maths/Maths/Vector3F.gen.cs | 290 ++++++++++++++++++++++-
 sources/Maths/Maths/Vector3I.cs     | 329 +-------------------------
 sources/Maths/Maths/Vector3I.gen.cs | 322 ++++++++++++++++++++++++-
 sources/Maths/Maths/Vector4F.gen.cs | 317 ++++++++++++++++++++++++-
 sources/Maths/Maths/Vector4I.cs     | 351 +---------------------------
 sources/Maths/Maths/Vector4I.gen.cs | 349 ++++++++++++++++++++++++++-
 10 files changed, 1834 insertions(+), 1239 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 10c855434b..651c2abbef 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -14,37 +14,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D floating-point vector.</summary>
-    internal partial struct Vector2F<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector2F<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2F<T>>,
-        IParsable<Vector2F<T>>,
-        IFormattable
-        where T : IFloatingPointIeee754<T>
+    internal partial struct Vector2F<T>
     {
-        /// <summary>Initializes the vector from a span of two values.</summary>
-        public Vector2F(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 2)
-                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-        }
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2F<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2F<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
-
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector2F<T> AllBitsSet => new(T.AllBitsSet, T.AllBitsSet);
 
@@ -66,9 +37,6 @@ public Vector2F(ReadOnlySpan<T> values)
         /// <summary> Computes the cross product of two vectors. </summary>
         public static T Cross(Vector2F<T> left, Vector2F<T> right) => (left.X * right.Y) - (left.Y * right.X);
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
-
         /// <summary>Normalizes this vector.</summary>
         public Vector2F<T> Normalize()
         {
@@ -171,86 +139,6 @@ public static Vector2F<T> Reflect(Vector2F<T> vector, Vector2F<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int requiredLength = 1 + xChars + 2 + yChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2F.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 2 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 2 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector2F<T> Sign() => new(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
 
@@ -274,110 +162,6 @@ public Vector2F<T> CopySign(T signScalar) =>
         public static Vector2F<T> CopySign(Vector2F<T> value, T signScalar) =>
             new(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaIndex = s.IndexOf(',');
-            if (commaIndex < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y))
-            {
-                result = new Vector2F<T>(x, y);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2F{T}"/>.</summary>
@@ -388,45 +172,6 @@ public static explicit operator Vector2F<T>(System.Numerics.Vector2 v) =>
         public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
             new(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
-        // Component Operators
-        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X + right.X, left.Y + right.Y);
-
-        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X - right.X, left.Y - right.Y);
-
-        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X * right.X, left.Y * right.Y);
-
-        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X / right.X, left.Y / right.Y);
-
-        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X % right.X, left.Y % right.Y);
-
-        // Scalar Operators
-        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
-            new(vector.X + scalar, vector.Y + scalar);
-
-        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
-            new(vector.X - scalar, vector.Y - scalar);
-
-        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
-            new(vector.X * scalar, vector.Y * scalar);
-
-        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
-            new(vector.X / scalar, vector.Y / scalar);
-
-        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar);
-
-        // + operator: returns the vector
-        public static Vector2F<T> operator +(Vector2F<T> vector) => vector;
-
-        // - operator: returns the negated vector
-        public static Vector2F<T> operator -(Vector2F<T> vector) =>
-            new(-vector.X, -vector.Y);
-
         // IFloatingPointIeee754
         public static Vector2F<T> Sqrt(Vector2F<T> x) =>
             new(T.Sqrt(x.X), T.Sqrt(x.Y));
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index 34d27f31f1..c78c0ae7a7 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector2F<T> :
         IEquatable<Vector2F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector2F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector2F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -21,6 +29,28 @@ partial struct Vector2F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2F(T x, T y) => (X, Y) = (x, y);
 
+        /// <summary>Initializes the vector from a span of 2 values.</summary>
+        public Vector2F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -55,6 +85,197 @@ public IEnumerator<T> GetEnumerator()
             yield return Y;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 4 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2F<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
+        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -77,6 +298,46 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> vector) =>
+            vector;
+
+        public static Vector2F<T> operator -(Vector2F<T> vector) =>
+            new Vector2F<T>(-vector.X, -vector.Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
+            new Vector2F<T>(left.X % right.X, left.Y % right.Y);
+
+        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2F<T> operator *(T scalar, Vector2F<T> vector) =>
+            new Vector2F<T>(scalar * vector.X, scalar * vector.Y);
+
+        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
+            new Vector2F<T>(vector.X % scalar, vector.Y % scalar);
+
     }
 
     static partial class Vector2F
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index 2a49a846b5..d4e06c943e 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -12,40 +12,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
-    internal partial struct Vector2I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector2I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2I<T>>,
-        IParsable<Vector2I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector2I<T>
     {
-        /// <summary>Initializes the vector from a span of two values.</summary>
-        public Vector2I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 2)
-                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-        }
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y);
 
@@ -61,9 +29,6 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary> Computes the cross product of two vectors. </summary>
         public static T Cross(Vector2I<T> left, Vector2I<T> right) => (left.X * right.Y) - (left.Y * right.X);
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector2I<T> Max(Vector2I<T> other) =>
             new Vector2I<T>(T.Max(X, other.X), T.Max(Y, other.Y));
@@ -119,90 +84,6 @@ public static Vector2I<T> Clamp(Vector2I<T> vector, T min, T max) =>
         public static Vector2I<T> Abs(Vector2I<T> vector) =>
             new Vector2I<T>(T.Abs(vector.X), T.Abs(vector.Y));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) => $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            // Not too sure about this implementation
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + >
-            int requiredLength = 1 + xChars + 2 + yChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 2 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 2 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector2I<T> Sign() => new Vector2I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
 
@@ -226,114 +107,6 @@ public Vector2I<T> CopySign(T signScalar) =>
         public static Vector2I<T> CopySign(Vector2I<T> value, T signScalar) =>
             new Vector2I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 5 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaIndex = s.IndexOf(',');
-            if (commaIndex < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..commaIndex].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaIndex + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y))
-            {
-                result = new Vector2I<T>(x, y);
-                return true;
-            }
-
-            return false;
-        }
-
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            // Not too sure about this implementation
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2I{T}"/>.</summary>
@@ -344,77 +117,6 @@ public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
         public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
             new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
-        // Component Operators
-        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
-
-        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
-
-        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
-
-        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
-
-        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
-
-        // Scalar Operators
-        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
-
-        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
-
-        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
-
-        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
-
-        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector2I<T> operator +(Vector2I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector2I<T> operator -(Vector2I<T> vector) =>
-            new Vector2I<T>(-vector.X, -vector.Y);
-
-        // Bitwise Operators
-        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
-
-        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
-
-        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
-
-        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
-
-        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
-
-        // NOT operator
-        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
-            new Vector2I<T>(~vector.X, ~vector.Y);
-
         // IBinaryInteger
         // TODO: Verify these are actually correct
 
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index c8631934e7..60df7f4e0c 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector2I<T> :
         IEquatable<Vector2I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector2I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector2I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector2I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -21,6 +29,31 @@ partial struct Vector2I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector2I(T x, T y) => (X, Y) = (x, y);
 
+        /// <summary>Initializes the vector from a span of 2 values.</summary>
+        public Vector2I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 2)
+                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+        }
+
+        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
+        public static Vector2I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
+        public static Vector2I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0).</summary>
+        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1).</summary>
+        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -55,6 +88,197 @@ public IEnumerator<T> GetEnumerator()
             yield return Y;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 2 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 2 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector2I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 4 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y))
+            {
+                result = new Vector2I<T>(x, y);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
+        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -77,6 +301,75 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> vector) =>
+            vector;
+
+        public static Vector2I<T> operator -(Vector2I<T> vector) =>
+            new Vector2I<T>(-vector.X, -vector.Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
+
+        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
+
+        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
+
+        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
+
+        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
+
+        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
+
+        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
+
+        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
+
+        public static Vector2I<T> operator *(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar * vector.X, scalar * vector.Y);
+
+        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
+
+        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
+
+        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
+            new Vector2I<T>(~vector.X, ~vector.Y);
+
+        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
+            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
+
+        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
+
+        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
+
+        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
+
+        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
+
+        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
+            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
+
+        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
+            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
     }
 
     static partial class Vector2I
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 93b997b6e1..c339e7248b 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector3F<T> :
         IEquatable<Vector3F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector3F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector3F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector3F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -24,6 +32,32 @@ partial struct Vector3F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary>Initializes the vector from a span of 3 values.</summary>
+        public Vector3F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 3)
+                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+        }
+
+        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
+        public static Vector3F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
+        public static Vector3F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0).</summary>
+        public static Vector3F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0).</summary>
+        public static Vector3F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1).</summary>
+        public static Vector3F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -61,6 +95,220 @@ public IEnumerator<T> GetEnumerator()
             yield return Z;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 3 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 3 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector3F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 6 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z))
+            {
+                result = new Vector3F<T>(x, y, z);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static Vector3F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        static Vector3F<T> ISpanParsable<Vector3F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        static Vector3F<T> IParsable<Vector3F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector3F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
+        static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -84,6 +332,46 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> vector) =>
+            vector;
+
+        public static Vector3F<T> operator -(Vector3F<T> vector) =>
+            new Vector3F<T>(-vector.X, -vector.Y, -vector.Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+        public static Vector3F<T> operator -(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+
+        public static Vector3F<T> operator *(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+
+        public static Vector3F<T> operator /(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+
+        public static Vector3F<T> operator %(Vector3F<T> left, Vector3F<T> right) =>
+            new Vector3F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+
+        public static Vector3F<T> operator +(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+
+        public static Vector3F<T> operator -(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+
+        public static Vector3F<T> operator *(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+
+        public static Vector3F<T> operator *(T scalar, Vector3F<T> vector) =>
+            new Vector3F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+
+        public static Vector3F<T> operator /(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        public static Vector3F<T> operator %(Vector3F<T> vector, T scalar) =>
+            new Vector3F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+
     }
 
     static partial class Vector3F
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index ac7a810b7d..8df9e4e06a 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -12,48 +12,12 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
-    internal partial struct Vector3I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector3I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector3I<T>>,
-        IParsable<Vector3I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector3I<T>
     {
-        /// <summary>Initializes the vector from a span of three values.</summary>
-        public Vector3I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 3)
-                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-        }
-
         /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z. </summary>
         // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
         public Vector3I(Vector2I<T> xy, T z) => (X, Y, Z) = (xy.X, xy.Y, z);
 
-        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
-        public static Vector3I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
 
@@ -79,9 +43,6 @@ public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
                 (left.X * right.Y) - (left.Y * right.X)
             );
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector3I<T> Max(Vector3I<T> other) =>
             new Vector3I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z));
@@ -153,99 +114,6 @@ public static Vector3I<T> Clamp(Vector3I<T> vector, T min, T max) =>
         public static Vector3I<T> Abs(Vector3I<T> vector) =>
             new Vector3I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}, {Z}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + ", " + z + >
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector3I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 3 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 3 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector3I<T> Sign() =>
             new Vector3I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)));
@@ -270,130 +138,6 @@ public Vector3I<T> CopySign(T signScalar) =>
         public static Vector3I<T> CopySign(Vector3I<T> value, T signScalar) =>
             new Vector3I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar));
 
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 7 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int firstComma = s.IndexOf(',');
-            if (firstComma < 0)
-                return false;
-
-            // Kind of hacky, but it works
-            // TODO: See if there's a better way
-            ReadOnlySpan<char> remainder = s.Slice(firstComma + 1);
-            int secondCommaRelative = remainder.IndexOf(',');
-            if (secondCommaRelative < 0)
-                return false;
-
-            int secondComma = firstComma + 1 + secondCommaRelative;
-            if (secondComma < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
-            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
-            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z))
-            {
-                result = new Vector3I<T>(x, y, z);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                               Encoding.UTF8.GetByteCount("<, , >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3I{T}"/>.</summary>
@@ -404,77 +148,6 @@ public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
         public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
             new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
 
-        // Component Operators
-        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
-
-        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
-
-        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
-
-        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
-
-        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
-
-        // Scalar Operators
-        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
-
-        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
-
-        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
-
-        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
-
-        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector3I<T> operator +(Vector3I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector3I<T> operator -(Vector3I<T> vector) =>
-            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
-
-        // Bitwise Operators
-        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
-
-        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
-
-        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
-
-        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
-
-        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
-
-        // NOT operator
-        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
-            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
-
         // IBinaryInteger
         public static Vector3I<T> Log2(Vector3I<T> x) =>
             new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index 45ee97e364..181ba38d8c 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector3I<T> :
         IEquatable<Vector3I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector3I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector3I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector3I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -24,6 +32,35 @@ partial struct Vector3I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary>Initializes the vector from a span of 3 values.</summary>
+        public Vector3I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 3)
+                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+        }
+
+        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
+        public static Vector3I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
+        public static Vector3I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0).</summary>
+        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0).</summary>
+        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1).</summary>
+        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -61,6 +98,220 @@ public IEnumerator<T> GetEnumerator()
             yield return Z;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 3 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 3 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector3I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 6 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z))
+            {
+                result = new Vector3I<T>(x, y, z);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
+        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -84,6 +335,75 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> vector) =>
+            vector;
+
+        public static Vector3I<T> operator -(Vector3I<T> vector) =>
+            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+
+        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+
+        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+
+        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+
+        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+
+        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+
+        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+
+        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+
+        public static Vector3I<T> operator *(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+
+        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+
+        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
+            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
+
+        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
+            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
+
+        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
+
+        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
+
+        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
+
+        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
+
+        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
+            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
+
+        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
+            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
     }
 
     static partial class Vector3I
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index 871162afc5..b97dbf436f 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector4F<T> :
         IEquatable<Vector4F<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector4F<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector4F<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector4F<T>>
         where T : IFloatingPointIeee754<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -27,6 +35,36 @@ partial struct Vector4F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary>Initializes the vector from a span of 4 values.</summary>
+        public Vector4F(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 4)
+                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+            W = values[3];
+        }
+
+        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
+        public static Vector4F<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
+        public static Vector4F<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
+        public static Vector4F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
+        public static Vector4F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
+        public static Vector4F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
+        public static Vector4F<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -67,6 +105,243 @@ public IEnumerator<T> GetEnumerator()
             yield return W;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 4 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+            array[startIndex + 3] = W;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 4 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+            span[startIndex + 3] = W;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}, {W}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector4F.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider)||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            wBuffer[..wChars].CopyTo(destination[pos..]);
+            pos += wChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 8 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> remainder2 = s.Slice(commaY + 1);
+            int commaZRelative = remainder2.IndexOf(',');
+            if (commaZRelative < 0)
+                return false;
+            int commaZ = commaY + 1 + commaZRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..commaZ].Trim();
+            ReadOnlySpan<char> wSpan = s[(commaZ + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z) &&
+                T.TryParse(wSpan, provider, out var w))
+            {
+                result = new Vector4F<T>(x, y, z, w);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static Vector4F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        static Vector4F<T> ISpanParsable<Vector4F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        static Vector4F<T> IParsable<Vector4F<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector4F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
+        static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -91,6 +366,46 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+
+        public static Vector4F<T> operator +(Vector4F<T> vector) =>
+            vector;
+
+        public static Vector4F<T> operator -(Vector4F<T> vector) =>
+            new Vector4F<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+
+        public static Vector4F<T> operator +(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+
+        public static Vector4F<T> operator -(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+
+        public static Vector4F<T> operator *(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+
+        public static Vector4F<T> operator /(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+
+        public static Vector4F<T> operator %(Vector4F<T> left, Vector4F<T> right) =>
+            new Vector4F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+
+        public static Vector4F<T> operator +(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+
+        public static Vector4F<T> operator -(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+
+        public static Vector4F<T> operator *(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+
+        public static Vector4F<T> operator *(T scalar, Vector4F<T> vector) =>
+            new Vector4F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+
+        public static Vector4F<T> operator /(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        public static Vector4F<T> operator %(Vector4F<T> vector, T scalar) =>
+            new Vector4F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+
     }
 
     static partial class Vector4F
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 2386d7c797..9952e08574 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -11,27 +11,8 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
-    internal partial struct Vector4I<T> :
-        ISpanFormattable,
-        ISpanParsable<Vector4I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector4I<T>>,
-        IParsable<Vector4I<T>>,
-        IFormattable
-        where T : IBinaryInteger<T>
+    internal partial struct Vector4I<T>
     {
-        /// <summary>Initializes the vector from a span of four values.</summary>
-        public Vector4I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 4)
-                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-            W = values[3];
-        }
-
         /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z and W. </summary>
         // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
         public Vector4I(Vector2I<T> xy, T z, T w) => (X, Y, Z, W) = (xy.X, xy.Y, z, w);
@@ -39,27 +20,6 @@ public Vector4I(ReadOnlySpan<T> values)
         /// <summary> Initializes the vector using a Vector3I for X, Y and Z, and a separate value for W. </summary>
         public Vector4I(Vector3I<T> xyz, T w) => (X, Y, Z, W) = (xyz.X, xyz.Y, xyz.Z, w);
 
-        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4I<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
-        public static Vector4I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
 
@@ -69,9 +29,6 @@ public Vector4I(ReadOnlySpan<T> values)
         /// <summary> Computes the dot product of two vectors. </summary>
         public static T Dot(Vector4I<T> left, Vector4I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z) + (left.W * right.W);
 
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector4I<T> Max(Vector4I<T> other) =>
             new Vector4I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z), T.Max(W, other.W));
@@ -147,109 +104,6 @@ public static Vector4I<T> Clamp(Vector4I<T> vector, T min, T max) =>
         public static Vector4I<T> Abs(Vector4I<T> vector) =>
             new Vector4I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z), T.Abs(vector.W));
 
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() => $"<{X}, {Y}, {Z}, {W}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            // Calculate total required length: < + x + ", " + y + ", " + z + ", " + w + >
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            wBuffer[..wChars].CopyTo(destination[pos..]);
-            pos += wChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Parses a span to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector4I.");
-
-            return result;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 4 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-            array[startIndex + 3] = W;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 4 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-            span[startIndex + 3] = W;
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector4I<T> Sign() =>
             new Vector4I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)), T.CreateChecked(T.Sign(W)));
@@ -274,138 +128,6 @@ public Vector4I<T> CopySign(T signScalar) =>
         public static Vector4I<T> CopySign(Vector4I<T> value, T signScalar) =>
             new Vector4I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar), T.CopySign(value.W, signScalar));
 
-        /// <summary>Parses a string to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 9 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int firstComma = s.IndexOf(',');
-            if (firstComma < 0)
-                return false;
-
-            ReadOnlySpan<char> remainder1 = s.Slice(firstComma + 1);
-            int secondCommaRelative = remainder1.IndexOf(',');
-            if (secondCommaRelative < 0)
-                return false;
-            int secondComma = firstComma + 1 + secondCommaRelative;
-
-            ReadOnlySpan<char> remainder2 = s.Slice(secondComma + 1);
-            int thirdCommaRelative = remainder2.IndexOf(',');
-            if (thirdCommaRelative < 0)
-                return false;
-            int thirdComma = secondComma + 1 + thirdCommaRelative;
-
-            ReadOnlySpan<char> xSpan = s[..firstComma].Trim();
-            ReadOnlySpan<char> ySpan = s[(firstComma + 1)..secondComma].Trim();
-            ReadOnlySpan<char> zSpan = s[(secondComma + 1)..thirdComma].Trim();
-            ReadOnlySpan<char> wSpan = s[(thirdComma + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z) &&
-                T.TryParse(wSpan, provider, out var w))
-            {
-                result = new Vector4I<T>(x, y, z, w);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a Vector4I instance.</summary>
-        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a Vector4I instance.</summary>
-        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a Vector4I instance.</summary>
-        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a Vector4I instance.</summary>
-        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            // Format components individually into temporary buffers
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            // Estimate total required UTF-8 bytes
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                               Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                               Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                               Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
-                               Encoding.UTF8.GetByteCount("<, , , >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Parses a UTF-8 span to a Vector4I instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a Vector4I instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
         // Casts
 
         /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4I.</summary>
@@ -416,77 +138,6 @@ public static explicit operator Vector4I<T>(System.Numerics.Vector4 v) =>
         public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
             new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
 
-        // Component Operators
-        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
-
-        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
-
-        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
-
-        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
-
-        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
-
-        // Scalar Operators
-        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
-
-        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
-
-        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
-
-        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
-
-        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
-
-        // + operator: returns the vector (?)
-        public static Vector4I<T> operator +(Vector4I<T> vector) => vector;
-
-        //  - operator: returns the negated vector
-        public static Vector4I<T> operator -(Vector4I<T> vector) =>
-            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
-
-        // Bitwise Operators
-        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
-
-        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
-
-        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
-
-        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
-
-        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
-
-        // NOT operator
-        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
-            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
-
         // IBinaryInteger
         public static Vector4I<T> Log2(Vector4I<T> x) =>
             new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index ef2d344376..37bab5858b 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -3,10 +3,18 @@ namespace Silk.NET.Maths
     using System.Collections;
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.InteropServices;
+    using System.Text;
 
     partial struct Vector4I<T> :
         IEquatable<Vector4I<T>>,
-        IReadOnlyList<T>
+        IReadOnlyList<T>,
+        IFormattable,
+        IParsable<Vector4I<T>>,
+        ISpanFormattable,
+        ISpanParsable<Vector4I<T>>,
+        IUtf8SpanFormattable,
+        IUtf8SpanParsable<Vector4I<T>>
         where T : IBinaryInteger<T>
     {
         /// <summary>The X component of the vector.</summary>
@@ -27,6 +35,39 @@ partial struct Vector4I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary>Initializes the vector from a span of 4 values.</summary>
+        public Vector4I(ReadOnlySpan<T> values)
+        {
+            if (values.Length != 4)
+                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
+
+            X = values[0];
+            Y = values[1];
+            Z = values[2];
+            W = values[3];
+        }
+
+        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
+        public static Vector4I<T> One => new(Scalar<T>.One);
+
+        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
+        public static Vector4I<T> Zero => default;
+
+        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
+        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
+        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
+        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+
+        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
+        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+
+        /// <summary>Gets a vector with all bits set for each component.</summary>
+        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -67,6 +108,243 @@ public IEnumerator<T> GetEnumerator()
             yield return W;
         }
 
+        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
+        public void CopyTo(T[] array) => CopyTo(array, 0);
+
+        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
+        public void CopyTo(T[] array, int startIndex)
+        {
+            if (array == null)
+                throw new ArgumentNullException(nameof(array));
+            if (startIndex < 0 || startIndex + 4 > array.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            array[startIndex] = X;
+            array[startIndex + 1] = Y;
+            array[startIndex + 2] = Z;
+            array[startIndex + 3] = W;
+        }
+
+        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
+        public void CopyTo(Span<T> span) => CopyTo(span, 0);
+
+        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
+        public void CopyTo(Span<T> span, int startIndex)
+        {
+            if (startIndex < 0 || startIndex + 4 > span.Length)
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+
+            span[startIndex] = X;
+            span[startIndex + 1] = Y;
+            span[startIndex + 2] = Z;
+            span[startIndex + 3] = W;
+        }
+
+        /// <summary>Returns a span over the vector components.</summary>
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
+
+        /// <summary>Formats the vector as a string.</summary>
+        public override string ToString() =>
+            $"<{X}, {Y}, {Z}, {W}>";
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public string ToString(string? format, IFormatProvider? formatProvider) =>
+            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
+
+        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+
+        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        {
+            if (!TryParse(s, provider, out var result))
+                throw new FormatException("Invalid format for Vector4I.");
+
+            return result;
+        }
+
+        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider)||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
+                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
+                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
+                                Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
+                                Encoding.UTF8.GetByteCount("<, >");
+
+            if (utf8Destination.Length < estimatedSize)
+            {
+                bytesWritten = 0;
+                return false;
+            }
+
+            int totalBytes = 0;
+
+            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
+            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
+
+            bytesWritten = totalBytes;
+            return true;
+        }
+
+        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
+        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
+        {
+            Span<char> xBuffer = stackalloc char[64];
+            Span<char> yBuffer = stackalloc char[64];
+            Span<char> zBuffer = stackalloc char[64];
+            Span<char> wBuffer = stackalloc char[64];
+
+            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
+                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
+                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
+                !W.TryFormat(wBuffer, out int wChars, format, provider))
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
+
+            if (destination.Length < requiredLength)
+            {
+                charsWritten = 0;
+                return false;
+            }
+
+            int pos = 0;
+            destination[pos++] = '<';
+
+            xBuffer[..xChars].CopyTo(destination[pos..]);
+            pos += xChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            yBuffer[..yChars].CopyTo(destination[pos..]);
+            pos += yChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            zBuffer[..zChars].CopyTo(destination[pos..]);
+            pos += zChars;
+
+            destination[pos++] = ',';
+            destination[pos++] = ' ';
+
+            wBuffer[..wChars].CopyTo(destination[pos..]);
+            pos += wChars;
+
+            destination[pos++] = '>';
+
+            charsWritten = pos;
+            return true;
+        }
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            result = default;
+
+            s = s.Trim();
+            if (s.Length < 8 || s[0] != '<' || s[^1] != '>')
+                return false;
+
+            s = s[1..^1]; // Remove < and >
+
+            int commaX = s.IndexOf(',');
+            if (commaX < 0)
+                return false;
+
+            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
+            int commaYRelative = remainder1.IndexOf(',');
+            if (commaYRelative < 0)
+                return false;
+            int commaY = commaX + 1 + commaYRelative;
+
+            ReadOnlySpan<char> remainder2 = s.Slice(commaY + 1);
+            int commaZRelative = remainder2.IndexOf(',');
+            if (commaZRelative < 0)
+                return false;
+            int commaZ = commaY + 1 + commaZRelative;
+
+            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
+            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
+            ReadOnlySpan<char> zSpan = s[(commaY + 1)..commaZ].Trim();
+            ReadOnlySpan<char> wSpan = s[(commaZ + 1)..].Trim();
+
+            if (T.TryParse(xSpan, provider, out var x) &&
+                T.TryParse(ySpan, provider, out var y) &&
+                T.TryParse(zSpan, provider, out var z) &&
+                T.TryParse(wSpan, provider, out var w))
+            {
+                result = new Vector4I<T>(x, y, z, w);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return Parse(charBuffer, provider);
+        }
+
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
+        {
+            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
+            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
+            Encoding.UTF8.GetChars(utf8Text, charBuffer);
+            return TryParse(charBuffer, provider, out result);
+        }
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s.AsSpan(), provider, out result);
+
+        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
+            Parse(s, provider);
+
+        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
+        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
+        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
+            TryParse(s, provider, out result);
+
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
@@ -91,6 +369,75 @@ public IEnumerator<T> GetEnumerator()
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
+
+        public static Vector4I<T> operator +(Vector4I<T> vector) =>
+            vector;
+
+        public static Vector4I<T> operator -(Vector4I<T> vector) =>
+            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+
+        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+
+        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+
+        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+
+        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+
+        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+
+        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+
+        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+
+        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+
+        public static Vector4I<T> operator *(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+
+        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+
+        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
+            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
+
+        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
+            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
+
+        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
+
+        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
+
+        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
+
+        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
+
+        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
+            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
+
+        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
+            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
     }
 
     static partial class Vector4I

From c9ce628a5b5ba6cb98fa451417f895de107c2d8f Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 12:03:19 -0700
Subject: [PATCH 30/52] Use Legacy namespace qualifications for lecacy
 Quaternion.

---
 sources/Maths/Maths/Legacy/Vector2D.Ops.cs |  4 ++--
 sources/Maths/Maths/Legacy/Vector3D.Ops.cs |  4 ++--
 sources/Maths/Maths/Legacy/Vector4D.Ops.cs |  8 ++++----
 sources/Maths/Maths/Matrix2X3.Ops.cs       |  8 ++++----
 sources/Maths/Maths/Matrix3X3.Ops.cs       | 14 +++++++-------
 sources/Maths/Maths/Matrix4X4.Ops.cs       | 14 +++++++-------
 sources/Maths/Maths/Plane.Ops.cs           |  4 ++--
 7 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
index 3c556c26d3..df68ebed3b 100644
--- a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
@@ -213,7 +213,7 @@ public static Vector2D<T> TransformNormal<T>(Vector2D<T> normal, Matrix4X4<T> ma
         /// <param name="value">The source vector to be rotated.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> Transform<T>(Vector2D<T> value, Quaternion<T> rotation)
+        public static Vector2D<T> Transform<T>(Vector2D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -285,4 +285,4 @@ public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
             => value1 * value2;
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
index ec06f40112..618c53b805 100644
--- a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
@@ -254,7 +254,7 @@ public static Vector3D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Transform<T>(Vector3D<T> value, Quaternion<T> rotation)
+        public static Vector3D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -296,4 +296,4 @@ public static Vector3D<T> TransformNormal<T>(Vector3D<T> normal, Matrix4X4<T> ma
             );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
index 16caebd93b..b86726fc19 100644
--- a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
+++ b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
@@ -237,7 +237,7 @@ public static Vector4D<T> Transform<T>(Vector2D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector2D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector2D<T> value, Silk.NET.Maths.Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -283,7 +283,7 @@ public static Vector4D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector3D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -329,7 +329,7 @@ public static Vector4D<T> Transform<T>(Vector4D<T> vector, Matrix4X4<T> matrix)
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed vector.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector4D<T> value, Quaternion<T> rotation)
+        public static Vector4D<T> Transform<T>(Vector4D<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -354,4 +354,4 @@ public static Vector4D<T> Transform<T>(Vector4D<T> value, Quaternion<T> rotation
             );
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index 242912de0b..6ebb6124ca 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -104,7 +104,7 @@ public static Matrix2X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix2X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix2X3<T> result = Matrix2X3<T>.Identity;
@@ -140,7 +140,7 @@ public static Matrix2X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -223,7 +223,7 @@ public static unsafe Matrix2X3<T> Lerp<T>(Matrix2X3<T> matrix1, Matrix2X3<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Quaternion<T> rotation)
+        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -260,4 +260,4 @@ public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Quaternion<T> rotati
             return new(value.M11 * q1 + value.M12 * q2 + value.M13 * q3, value.M21 * q1 + value.M22 * q2 + value.M23 * q3);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index 2b11c28756..aa3905c23a 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -127,7 +127,7 @@ public static Matrix3X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix3X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
@@ -167,7 +167,7 @@ public static Matrix3X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix3X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -373,7 +373,7 @@ public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <param name="scale">The scaling component of the transformation matrix.</param>
         /// <param name="rotation">The rotation component of the transformation matrix.</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
-        public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out Quaternion<T> rotation)
+        public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             bool result = true;
@@ -546,13 +546,13 @@ public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out
                     if (!Scalar.GreaterThanOrEqual(Scalar.As<float, T>(DecomposeEpsilon), det))
                     {
                         // Non-SRT matrix encountered
-                        rotation = Quaternion<T>.Identity;
+                        rotation = Legacy.Quaternion<T>.Identity;
                         result = false;
                     }
                     else
                     {
                         // generate the quaternion from the matrix
-                        rotation = Quaternion<T>.CreateFromRotationMatrix(matTemp);
+                        rotation = Legacy.Quaternion<T>.CreateFromRotationMatrix(matTemp);
                     }
                 }
             }
@@ -579,7 +579,7 @@ public static unsafe Matrix3X3<T> Lerp<T>(Matrix3X3<T> matrix1, Matrix3X3<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Quaternion<T> rotation)
+        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -625,4 +625,4 @@ public static unsafe Matrix3X3<T> Transpose<T>(Matrix3X3<T> matrix)
             return new(matrix.Column1, matrix.Column2, matrix.Column3);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index d27a6128ae..fb74c4345a 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -197,7 +197,7 @@ public static Matrix4X4<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix4X4<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+        public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
@@ -237,7 +237,7 @@ public static Matrix4X4<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
         public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
-            Quaternion<T> q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -1276,7 +1276,7 @@ private static Vector128<T> Permute(Vector128<T> value, byte control)
         /// <param name="rotation">The rotation component of the transformation matrix.</param>
         /// <param name="translation">The translation component of the transformation matrix</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
-        public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out Quaternion<T> rotation, out Vector3D<T> translation)
+        public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation, out Vector3D<T> translation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             bool result = true;
@@ -1454,13 +1454,13 @@ public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out
                     if (!Scalar.GreaterThanOrEqual(Scalar.As<float, T>(DecomposeEpsilon), det))
                     {
                         // Non-SRT matrix encountered
-                        rotation = Quaternion<T>.Identity;
+                        rotation = Legacy.Quaternion<T>.Identity;
                         result = false;
                     }
                     else
                     {
                         // generate the quaternion from the matrix
-                        rotation = Quaternion<T>.CreateFromRotationMatrix(matTemp);
+                        rotation = Legacy.Quaternion<T>.CreateFromRotationMatrix(matTemp);
                     }
                 }
             }
@@ -1488,7 +1488,7 @@ public static unsafe Matrix4X4<T> Lerp<T>(Matrix4X4<T> matrix1, Matrix4X4<T> mat
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Quaternion<T> rotation)
+        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -1539,4 +1539,4 @@ public static unsafe Matrix4X4<T> Transpose<T>(Matrix4X4<T> matrix)
             return new(matrix.Column1, matrix.Column2, matrix.Column3, matrix.Column4);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Plane.Ops.cs b/sources/Maths/Maths/Plane.Ops.cs
index ec15e8de18..24879072fb 100644
--- a/sources/Maths/Maths/Plane.Ops.cs
+++ b/sources/Maths/Maths/Plane.Ops.cs
@@ -181,7 +181,7 @@ public static Plane<T> Transform<T>(Plane<T> plane, Matrix4X4<T> matrix)
         /// <param name="rotation">The Quaternion rotation to apply to the Plane.</param>
         /// <returns>A new Plane that results from applying the rotation.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Plane<T> Transform<T>(Plane<T> plane, Quaternion<T> rotation)
+        public static Plane<T> Transform<T>(Plane<T> plane, Legacy.Quaternion<T> rotation)
             where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
         {
             // Compute rotation matrix.
@@ -220,4 +220,4 @@ public static Plane<T> Transform<T>(Plane<T> plane, Quaternion<T> rotation)
                 plane.Distance);
         }
     }
-}
\ No newline at end of file
+}

From aac298a454bf7e3439839767d86a86781340edbf Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 12:39:24 -0700
Subject: [PATCH 31/52] Generate constructors to extend smaller vectors.

---
 sources/Maths/Maths/Vector3F.gen.cs | 3 +++
 sources/Maths/Maths/Vector3I.cs     | 4 ----
 sources/Maths/Maths/Vector3I.gen.cs | 3 +++
 sources/Maths/Maths/Vector4F.gen.cs | 6 ++++++
 sources/Maths/Maths/Vector4I.cs     | 7 -------
 sources/Maths/Maths/Vector4I.gen.cs | 6 ++++++
 6 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index c339e7248b..ce3072ea61 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -32,6 +32,9 @@ partial struct Vector3F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector3F(Vector2F<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
+
         /// <summary>Initializes the vector from a span of 3 values.</summary>
         public Vector3F(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 8df9e4e06a..69ebab924f 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -14,10 +14,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 3D integer vector.</summary>
     internal partial struct Vector3I<T>
     {
-        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z. </summary>
-        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
-        public Vector3I(Vector2I<T> xy, T z) => (X, Y, Z) = (xy.X, xy.Y, z);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
 
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index 181ba38d8c..ac9bef4904 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -32,6 +32,9 @@ partial struct Vector3I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector3I(Vector2I<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
+
         /// <summary>Initializes the vector from a span of 3 values.</summary>
         public Vector3I(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index b97dbf436f..a617c6fc42 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -35,6 +35,12 @@ partial struct Vector4F<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified components for the remainder. </summary>
+        public Vector4F(Vector2F<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
+
+        /// <summary> Initializes the vector using a <see cref="Vector3F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector4F(Vector3F<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
+
         /// <summary>Initializes the vector from a span of 4 values.</summary>
         public Vector4F(ReadOnlySpan<T> values)
         {
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 9952e08574..07d4b25c17 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -13,13 +13,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 4D integer vector.</summary>
     internal partial struct Vector4I<T>
     {
-        /// <summary> Initializes the vector using a Vector2I for X and Y, and a separate value for Z and W. </summary>
-        // TODO: Make sure lower dimensional constructors arent meant to zero-out the higher dimensions
-        public Vector4I(Vector2I<T> xy, T z, T w) => (X, Y, Z, W) = (xy.X, xy.Y, z, w);
-
-        /// <summary> Initializes the vector using a Vector3I for X, Y and Z, and a separate value for W. </summary>
-        public Vector4I(Vector3I<T> xyz, T w) => (X, Y, Z, W) = (xyz.X, xyz.Y, xyz.Z, w);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
 
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index 37bab5858b..44059dcff8 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -35,6 +35,12 @@ partial struct Vector4I<T> :
         /// <summary>Initializes the vector with individual component values.</summary>
         public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
+        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified components for the remainder. </summary>
+        public Vector4I(Vector2I<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
+
+        /// <summary> Initializes the vector using a <see cref="Vector3I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector4I(Vector3I<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
+
         /// <summary>Initializes the vector from a span of 4 values.</summary>
         public Vector4I(ReadOnlySpan<T> values)
         {

From 25f69945b8cb9330d1675431521604867c165948 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 12:40:00 -0700
Subject: [PATCH 32/52] Removed AllBitsSet from Vector2F.

---
 sources/Maths/Maths/Vector2F.cs | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 651c2abbef..7cc5666095 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -16,9 +16,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 2D floating-point vector.</summary>
     internal partial struct Vector2F<T>
     {
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector2F<T> AllBitsSet => new(T.AllBitsSet, T.AllBitsSet);
-
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => (X * X) + (Y * Y);
 

From 41aa58d5f0ffc6d411f5f023584715db99d38355 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Sat, 31 May 2025 16:33:34 -0700
Subject: [PATCH 33/52] Generate vector specific methods in templates.

---
 sources/Maths/Maths/Vector2F.cs     | 53 ++++-------------------------
 sources/Maths/Maths/Vector2F.gen.cs | 29 ++++++++++++++++
 sources/Maths/Maths/Vector2I.cs     |  9 -----
 sources/Maths/Maths/Vector2I.gen.cs | 16 +++++++++
 sources/Maths/Maths/Vector3F.gen.cs | 29 ++++++++++++++++
 sources/Maths/Maths/Vector3I.cs     |  9 -----
 sources/Maths/Maths/Vector3I.gen.cs | 16 +++++++++
 sources/Maths/Maths/Vector4F.gen.cs | 29 ++++++++++++++++
 sources/Maths/Maths/Vector4I.cs     |  9 -----
 sources/Maths/Maths/Vector4I.gen.cs | 16 +++++++++
 10 files changed, 142 insertions(+), 73 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 7cc5666095..843f180af2 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -16,38 +16,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 2D floating-point vector.</summary>
     internal partial struct Vector2F<T>
     {
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y);
-
-        /// <summary>Gets the length of the vector.</summary>
-        public T Length => T.Sqrt(LengthSquared);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector2F<T> other) => (X * other.X) + (Y * other.Y);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector2F<T> left, Vector2F<T> right) => (left.X * right.X) + (left.Y * right.Y);
-
-        /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public T Cross(Vector2F<T> other) => (X * other.Y) - (Y * other.X);
-
-        /// <summary> Computes the cross product of two vectors. </summary>
-        public static T Cross(Vector2F<T> left, Vector2F<T> right) => (left.X * right.Y) - (left.Y * right.X);
-
-        /// <summary>Normalizes this vector.</summary>
-        public Vector2F<T> Normalize()
-        {
-            T length = Length;
-            return length != T.Zero ? this / length : Zero;
-        }
-
-        /// <summary>Normalizes a vector.</summary>
-        public static Vector2F<T> Normalize(Vector2F<T> vector)
-        {
-            T length = vector.Length;
-            return length != T.Zero ? vector / length : Zero;
-        }
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector2F<T> Max(Vector2F<T> other) =>
             new(T.Max(X, other.X), T.Max(Y, other.Y));
@@ -122,20 +90,6 @@ public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T>
                 a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
             );
 
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public Vector2F<T> Reflect(Vector2F<T> normal)
-        {
-            T dot = Dot(normal);
-            return this - (normal * (dot + dot));
-        }
-
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector2F<T> Reflect(Vector2F<T> vector, Vector2F<T> normal)
-        {
-            T dot = Dot(vector, normal);
-            return vector - (normal * (dot + dot));
-        }
-
         /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
         public Vector2F<T> Sign() => new(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
 
@@ -358,4 +312,11 @@ public static Vector2F<T> ScaleB(Vector2F<T> x, Vector2I<int> n) =>
         public static Vector2F<T> ScaleB(Vector2F<T> x, int n) =>
             new(T.ScaleB(x.X, n), T.ScaleB(x.Y, n));
     }
+
+    static partial class Vector2F
+    {
+        /// <summary> Computes the cross product of two vectors.</summary>
+        public static T Cross<T>(this Vector2F<T> left, Vector2F<T> right)
+            where T : IFloatingPointIeee754<T> => (left.X * right.Y) - (left.Y * right.X);
+    }
 }
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index c78c0ae7a7..b7c5cfc47f 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -51,6 +51,9 @@ public Vector2F(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 1).</summary>
         public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector2F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -342,6 +345,32 @@ static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector2F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector2F<T> left, Vector2F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector2F<T> Reflect<T>(Vector2F<T> vector, Vector2F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector2F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector2F<T> Normalize<T>(this Vector2F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector2F<T>.Zero;
+        }
+
         public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index d4e06c943e..fceb7b5b44 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -14,15 +14,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 2D integer vector.</summary>
     internal partial struct Vector2I<T>
     {
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector2I<T> other) => (X * other.X) + (Y * other.Y);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector2I<T> left, Vector2I<T> right) => (left.X * right.X) + (left.Y * right.Y);
-
         /// <summary> Computes the cross product of this vector with another vector. </summary>
         public T Cross(Vector2I<T> other) => (X * other.Y) - (Y * other.X);
 
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index 60df7f4e0c..afe221d779 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -54,6 +54,9 @@ public Vector2I(ReadOnlySpan<T> values)
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector2I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -374,6 +377,19 @@ static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector2I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector2I<T> left, Vector2I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector2I<T> Reflect<T>(Vector2I<T> vector, Vector2I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index ce3072ea61..6c9a8a9f67 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -61,6 +61,9 @@ public Vector3F(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 0, 1).</summary>
         public static Vector3F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector3F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -379,6 +382,32 @@ static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector3F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector3F<T> left, Vector3F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector3F<T> Reflect<T>(Vector3F<T> vector, Vector3F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector3F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector3F<T> Normalize<T>(this Vector3F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector3F<T>.Zero;
+        }
+
         public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 69ebab924f..167273b467 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -14,15 +14,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 3D integer vector.</summary>
     internal partial struct Vector3I<T>
     {
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector3I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector3I<T> left, Vector3I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z);
-
         /// <summary> Computes the cross product of this vector with another vector. </summary>
         public Vector3I<T> Cross(Vector3I<T> other) =>
             new Vector3I<T>(
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index ac9bef4904..05bb368e10 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -64,6 +64,9 @@ public Vector3I(ReadOnlySpan<T> values)
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector3I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -411,6 +414,19 @@ static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector3I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector3I<T> left, Vector3I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector3I<T> Reflect<T>(Vector3I<T> vector, Vector3I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index a617c6fc42..be1a8e23ed 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -71,6 +71,9 @@ public Vector4F(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 0, 0, 1).</summary>
         public static Vector4F<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector4F.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -416,6 +419,32 @@ static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector4F
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector4F<T> left, Vector4F<T> right)
+            where T : IFloatingPointIeee754<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector4F<T> Reflect<T>(Vector4F<T> vector, Vector4F<T> normal)
+            where T : IFloatingPointIeee754<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
+        /// <summary>Computes the length of the vector.</summary>
+        public static T GetLength<T>(this Vector4F<T> vector)
+            where T : IFloatingPointIeee754<T> =>
+            T.Sqrt(vector.LengthSquared);
+
+        /// <summary>Normalizes a vector.</summary>
+        public static Vector4F<T> Normalize<T>(this Vector4F<T> vector)
+            where T : IFloatingPointIeee754<T>
+        {
+            T length = vector.GetLength();
+            return length != T.Zero ? vector / length : Vector4F<T>.Zero;
+        }
+
         public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 07d4b25c17..16c3e21720 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -13,15 +13,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 4D integer vector.</summary>
     internal partial struct Vector4I<T>
     {
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => (X * X) + (Y * Y) + (Z * Z) + (W * W);
-
-        /// <summary> Computes the dot product of this vector with another vector. </summary>
-        public T Dot(Vector4I<T> other) => (X * other.X) + (Y * other.Y) + (Z * other.Z) + (W * other.W);
-
-        /// <summary> Computes the dot product of two vectors. </summary>
-        public static T Dot(Vector4I<T> left, Vector4I<T> right) => (left.X * right.X) + (left.Y * right.Y) + (left.Z * right.Z) + (left.W * right.W);
-
         /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
         public Vector4I<T> Max(Vector4I<T> other) =>
             new Vector4I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z), T.Max(W, other.W));
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index 44059dcff8..04eb7ca61c 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -74,6 +74,9 @@ public Vector4I(ReadOnlySpan<T> values)
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
 
+        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
+        public T LengthSquared => Vector4I.Dot(this, this);
+
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
 
@@ -448,6 +451,19 @@ static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
 
     static partial class Vector4I
     {
+        /// <summary>Computes the dot product of two vectors.</summary>
+        public static T Dot<T>(this Vector4I<T> left, Vector4I<T> right)
+            where T : IBinaryInteger<T> =>
+            left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
+
+        /// <summary>Reflects a vector over a normal vector.</summary>
+        public static Vector4I<T> Reflect<T>(Vector4I<T> vector, Vector4I<T> normal)
+            where T : IBinaryInteger<T>
+        {
+            T dot = vector.Dot(normal);
+            return vector - (normal * (dot + dot));
+        }
+
         public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x)
             where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));

From 09e674c61db686760b8ac4fd661fcd0b53d6f2c2 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Mon, 30 Jun 2025 16:19:44 -0700
Subject: [PATCH 34/52] Snapshot.

---
 sources/Maths/Maths/Vector2F.cs     | 257 +-------------
 sources/Maths/Maths/Vector2F.gen.cs | 525 +++++++++++++++++++++++++--
 sources/Maths/Maths/Vector2I.cs     |  87 -----
 sources/Maths/Maths/Vector2I.gen.cs | 229 ++++++++----
 sources/Maths/Maths/Vector3F.gen.cs | 529 +++++++++++++++++++++++++--
 sources/Maths/Maths/Vector3I.cs     | 102 ------
 sources/Maths/Maths/Vector3I.gen.cs | 233 ++++++++----
 sources/Maths/Maths/Vector4F.gen.cs | 533 ++++++++++++++++++++++++++--
 sources/Maths/Maths/Vector4I.cs     | 106 ------
 sources/Maths/Maths/Vector4I.gen.cs | 237 +++++++++----
 10 files changed, 1993 insertions(+), 845 deletions(-)

diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
index 843f180af2..70db4099f6 100644
--- a/sources/Maths/Maths/Vector2F.cs
+++ b/sources/Maths/Maths/Vector2F.cs
@@ -16,72 +16,9 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 2D floating-point vector.</summary>
     internal partial struct Vector2F<T>
     {
-        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
-        public Vector2F<T> Max(Vector2F<T> other) =>
-            new(T.Max(X, other.X), T.Max(Y, other.Y));
-
-        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
-        public static Vector2F<T> Max(Vector2F<T> left, Vector2F<T> right) =>
-            new(T.Max(left.X, right.X), T.Max(left.Y, right.Y));
-
-        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
-        public Vector2F<T> Max(T scalar) =>
-            new(T.Max(X, scalar), T.Max(Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
-        public static Vector2F<T> Max(Vector2F<T> vector, T scalar) =>
-            new(T.Max(vector.X, scalar), T.Max(vector.Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
-        public Vector2F<T> Min(Vector2F<T> other) =>
-            new(T.Min(X, other.X), T.Min(Y, other.Y));
-
-        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
-        public static Vector2F<T> Min(Vector2F<T> left, Vector2F<T> right) =>
-            new(T.Min(left.X, right.X), T.Min(left.Y, right.Y));
-
-        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
-        public Vector2F<T> Min(T scalar) =>
-            new(T.Min(X, scalar), T.Min(Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
-        public static Vector2F<T> Min(Vector2F<T> vector, T scalar) =>
-            new(T.Min(vector.X, scalar), T.Min(vector.Y, scalar));
-
-        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
-        public Vector2F<T> Clamp(Vector2F<T> min, Vector2F<T> max) =>
-            new(T.Clamp(X, min.X, max.X), T.Clamp(Y, min.Y, max.Y));
-
-        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
-        public static Vector2F<T> Clamp(Vector2F<T> vector, Vector2F<T> min, Vector2F<T> max) =>
-            new(T.Clamp(vector.X, min.X, max.X), T.Clamp(vector.Y, min.Y, max.Y));
-
-        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
-        public Vector2F<T> Clamp(T min, T max) =>
-            new(T.Clamp(X, min, max), T.Clamp(Y, min, max));
-
-        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
-        public static Vector2F<T> Clamp(Vector2F<T> vector, T min, T max) =>
-            new(T.Clamp(vector.X, min, max), T.Clamp(vector.Y, min, max));
-
-        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
-        public Vector2F<T> Abs() => new(T.Abs(X), T.Abs(Y));
-
-        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
-        public static Vector2F<T> Abs(Vector2F<T> vector) =>
-            new(T.Abs(vector.X), T.Abs(vector.Y));
-
-        /// <summary>Linearly interpolates between two vectors using a scalar t-value.</summary>
-        public static Vector2F<T> Lerp(Vector2F<T> a, Vector2F<T> b, T t) =>
-            new(a.X + (b.X - a.X) * t, a.Y + (b.Y - a.Y) * t);
-
-        /// <summary>Linearly interpolates between two vectors using a vector t-value.</summary>
-        public static Vector2F<T> Lerp(Vector2F<T> a, Vector2F<T> b, Vector2F<T> t) =>
-            new(a.X + (b.X - a.X) * t.X, a.Y + (b.Y - a.Y) * t.Y);
-
         /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
         public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, T t) =>
-            Lerp(a, b, T.Clamp(t, T.Zero, T.One));
+            Vector2F.Lerp(a, b, T.Clamp(t, T.Zero, T.One));
 
         /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
         public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T> t) =>
@@ -90,29 +27,6 @@ public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T>
                 a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
             );
 
-        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
-        public Vector2F<T> Sign() => new(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
-
-        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
-        public static Vector2F<T> Sign(Vector2F<T> vector) =>
-            new(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)));
-
-        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
-        public Vector2F<T> CopySign(Vector2F<T> signSource) =>
-            new(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y));
-
-        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
-        public static Vector2F<T> CopySign(Vector2F<T> value, Vector2F<T> signSource) =>
-            new(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y));
-
-        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
-        public Vector2F<T> CopySign(T signScalar) =>
-            new(T.CopySign(X, signScalar), T.CopySign(Y, signScalar));
-
-        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
-        public static Vector2F<T> CopySign(Vector2F<T> value, T signScalar) =>
-            new(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2F{T}"/>.</summary>
@@ -124,68 +38,6 @@ public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
             new(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
         // IFloatingPointIeee754
-        public static Vector2F<T> Sqrt(Vector2F<T> x) =>
-            new(T.Sqrt(x.X), T.Sqrt(x.Y));
-
-        public static Vector2F<T> Acosh(Vector2F<T> x) =>
-            new(T.Acosh(x.X), T.Acosh(x.Y));
-
-        public static Vector2F<T> Asinh(Vector2F<T> x) =>
-            new(T.Asinh(x.X), T.Asinh(x.Y));
-
-        public static Vector2F<T> Atanh(Vector2F<T> x) =>
-            new(T.Atanh(x.X), T.Atanh(x.Y));
-
-        public static Vector2F<T> Cosh(Vector2F<T> x) =>
-            new(T.Cosh(x.X), T.Cosh(x.Y));
-
-        public static Vector2F<T> Sinh(Vector2F<T> x) =>
-            new(T.Sinh(x.X), T.Sinh(x.Y));
-
-        public static Vector2F<T> Tanh(Vector2F<T> x) =>
-            new(T.Tanh(x.X), T.Tanh(x.Y));
-
-        public static Vector2F<T> Acos(Vector2F<T> x) =>
-            new(T.Acos(x.X), T.Acos(x.Y));
-
-        public static Vector2F<T> AcosPi(Vector2F<T> x) =>
-            new(T.AcosPi(x.X), T.AcosPi(x.Y));
-
-        public static Vector2F<T> Asin(Vector2F<T> x) =>
-            new(T.Asin(x.X), T.Asin(x.Y));
-
-        public static Vector2F<T> AsinPi(Vector2F<T> x) =>
-            new(T.AsinPi(x.X), T.AsinPi(x.Y));
-
-        public static Vector2F<T> Atan(Vector2F<T> x) =>
-            new(T.Atan(x.X), T.Atan(x.Y));
-
-        public static Vector2F<T> AtanPi(Vector2F<T> x) =>
-            new(T.AtanPi(x.X), T.AtanPi(x.Y));
-
-        public static Vector2F<T> Cos(Vector2F<T> x) =>
-            new(T.Cos(x.X), T.Cos(x.Y));
-
-        public static Vector2F<T> CosPi(Vector2F<T> x) =>
-            new(T.CosPi(x.X), T.CosPi(x.Y));
-
-        public static Vector2F<T> Sin(Vector2F<T> x) =>
-            new(T.Sin(x.X), T.Sin(x.Y));
-
-        public static Vector2F<T> SinPi(Vector2F<T> x) =>
-            new(T.SinPi(x.X), T.SinPi(x.Y));
-
-        public static Vector2F<T> Tan(Vector2F<T> x) =>
-            new(T.Tan(x.X), T.Tan(x.Y));
-
-        public static Vector2F<T> TanPi(Vector2F<T> x) =>
-            new(T.TanPi(x.X), T.TanPi(x.Y));
-
-        public static Vector2F<T> DegreesToRadians(Vector2F<T> degrees) =>
-            new(T.DegreesToRadians(degrees.X), T.DegreesToRadians(degrees.Y));
-
-        public static Vector2F<T> RadiansToDegrees(Vector2F<T> radians) =>
-            new(T.RadiansToDegrees(radians.X), T.RadiansToDegrees(radians.Y));
 
         public static (Vector2F<T> Sin, Vector2F<T> Cos) SinCos(Vector2F<T> x) =>
             (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
@@ -193,98 +45,6 @@ public static (Vector2F<T> Sin, Vector2F<T> Cos) SinCos(Vector2F<T> x) =>
         public static (Vector2F<T> SinPi, Vector2F<T> CosPi) SinCosPi(Vector2F<T> x) =>
             (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
 
-        public static Vector2F<T> Log(Vector2F<T> x) =>
-            new(T.Log(x.X), T.Log(x.Y));
-
-        public static Vector2F<T> Log(Vector2F<T> x, Vector2F<T> newBase) =>
-            new(T.Log(x.X, newBase.X), T.Log(x.Y, newBase.Y));
-
-        public static Vector2F<T> Log(Vector2F<T> x, T newBase) =>
-            new(T.Log(x.X, newBase), T.Log(x.Y, newBase));
-
-        public static Vector2F<T> LogP1(Vector2F<T> x) =>
-            new(T.LogP1(x.X), T.LogP1(x.Y));
-
-        // TODO: Static Log2
-
-        public static Vector2F<T> Log2P1(Vector2F<T> x) =>
-            new(T.Log2P1(x.X), T.Log2P1(x.Y));
-
-        public static Vector2F<T> Log10(Vector2F<T> x) =>
-            new(T.Log10(x.X), T.Log10(x.Y));
-
-        public static Vector2F<T> Log10P1(Vector2F<T> x) =>
-            new(T.Log10P1(x.X), T.Log10P1(x.Y));
-
-        public static Vector2F<T> Exp(Vector2F<T> x) =>
-            new(T.Exp(x.X), T.Exp(x.Y));
-
-        public static Vector2F<T> ExpM1(Vector2F<T> x) =>
-            new(T.ExpM1(x.X), T.ExpM1(x.Y));
-
-        public static Vector2F<T> Exp2(Vector2F<T> x) =>
-            new(T.Exp2(x.X), T.Exp2(x.Y));
-
-        public static Vector2F<T> Exp2M1(Vector2F<T> x) =>
-            new(T.Exp2M1(x.X), T.Exp2M1(x.Y));
-
-        public static Vector2F<T> Exp10(Vector2F<T> x) =>
-            new(T.Exp10(x.X), T.Exp10(x.Y));
-
-        public static Vector2F<T> Exp10M1(Vector2F<T> x) =>
-            new(T.Exp10M1(x.X), T.Exp10M1(x.Y));
-
-        public static Vector2F<T> Pow(Vector2F<T> x, Vector2F<T> y) =>
-            new(T.Pow(x.X, y.X), T.Pow(x.Y, y.Y));
-
-        public static Vector2F<T> Pow(Vector2F<T> x, T y) =>
-            new(T.Pow(x.X, y), T.Pow(x.Y, y));
-
-        public static Vector2F<T> Cbrt(Vector2F<T> x) =>
-            new(T.Cbrt(x.X), T.Cbrt(x.Y));
-
-        public static Vector2F<T> Hypot(Vector2F<T> x, Vector2F<T> y) =>
-            new(T.Hypot(x.X, y.X), T.Hypot(x.Y, y.Y));
-
-        public static Vector2F<T> Hypot(Vector2F<T> x, T y) =>
-            new(T.Hypot(x.X, y), T.Hypot(x.Y, y));
-
-        public static Vector2F<T> RootN(Vector2F<T> x, int n) =>
-            new(T.RootN(x.X, n), T.RootN(x.Y, n));
-
-        public static Vector2F<T> Round(Vector2F<T> x) =>
-            new(T.Round(x.X), T.Round(x.Y));
-
-        public static Vector2F<T> Round(Vector2F<T> x, int digits) =>
-            new(T.Round(x.X, digits), T.Round(x.Y, digits));
-
-        public static Vector2F<T> Round(Vector2F<T> x, MidpointRounding mode) =>
-            new(T.Round(x.X, mode), T.Round(x.Y, mode));
-
-        public static Vector2F<T> Round(Vector2F<T> x, int digits, MidpointRounding mode) =>
-            new(T.Round(x.X, digits, mode), T.Round(x.Y, digits, mode));
-
-        public static Vector2F<T> Truncate(Vector2F<T> x) =>
-            new(T.Truncate(x.X), T.Truncate(x.Y));
-
-        public static Vector2F<T> Atan2(Vector2F<T> y, Vector2F<T> x) =>
-            new(T.Atan2(y.X, x.X), T.Atan2(y.Y, x.Y));
-
-        public static Vector2F<T> Atan2Pi(Vector2F<T> y, Vector2F<T> x) =>
-            new(T.Atan2Pi(y.X, x.X), T.Atan2Pi(y.Y, x.Y));
-
-        public static Vector2F<T> Atan2(Vector2F<T> y, T x) =>
-            new(T.Atan2(y.X, x), T.Atan2(y.Y, x));
-
-        public static Vector2F<T> Atan2Pi(Vector2F<T> y, T x) =>
-            new(T.Atan2Pi(y.X, x), T.Atan2Pi(y.Y, x));
-
-        public static Vector2F<T> BitDecrement(Vector2F<T> x) =>
-            new(T.BitDecrement(x.X), T.BitDecrement(x.Y));
-
-        public static Vector2F<T> BitIncrement(Vector2F<T> x) =>
-            new(T.BitIncrement(x.X), T.BitIncrement(x.Y));
-
         public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, Vector2F<T> right, Vector2F<T> addend) =>
             new(T.FusedMultiplyAdd(left.X, right.X, addend.X), T.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
 
@@ -296,21 +56,6 @@ public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, Vector2F<T
 
         public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, T addend) =>
             new(T.FusedMultiplyAdd(left.X, right, addend), T.FusedMultiplyAdd(left.Y, right, addend));
-
-        public static Vector2F<T> ReciprocalEstimate(Vector2F<T> x) =>
-            new(T.ReciprocalEstimate(x.X), T.ReciprocalEstimate(x.Y));
-
-        public static Vector2F<T> ReciprocalSqrtEstimate(Vector2F<T> x) =>
-            new(T.ReciprocalSqrtEstimate(x.X), T.ReciprocalSqrtEstimate(x.Y));
-
-        public static Vector2I<int> ILogB(Vector2F<T> x) =>
-            new(T.ILogB(x.X), T.ILogB(x.Y));
-
-        public static Vector2F<T> ScaleB(Vector2F<T> x, Vector2I<int> n) =>
-            new(T.ScaleB(x.X, n.X), T.ScaleB(x.Y, n.Y));
-
-        public static Vector2F<T> ScaleB(Vector2F<T> x, int n) =>
-            new(T.ScaleB(x.X, n), T.ScaleB(x.Y, n));
     }
 
     static partial class Vector2F
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2F.gen.cs
index b7c5cfc47f..66d80f2855 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2F.gen.cs
@@ -40,16 +40,16 @@ public Vector2F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2F<T> One => new(Scalar<T>.One);
+        public static Vector2F<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
         public static Vector2F<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector2F<T> UnitX => new(T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector2F<T> UnitY => new(T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => Vector2F.Dot(this, this);
@@ -302,44 +302,61 @@ static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        public void Deconstruct(out T x, out T y)
+        {
+            x = X;
+            y = Y;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2F{T}"/>.</summary>
+        public static implicit operator Vector2F<T>((T X, T Y) v) =>
+            new(v.X, v.Y);
+
+        /// <summary>Implicitly casts a <see cref="Vector2F{T}"/> to a <see cref="ValueTuple{T, T}"/>.</summary>
+        public static implicit operator (T X, T Y)(Vector2F<T> v) =>
+            (v.X, v.Y);
+
         public static Vector2F<T> operator +(Vector2F<T> vector) =>
             vector;
 
         public static Vector2F<T> operator -(Vector2F<T> vector) =>
-            new Vector2F<T>(-vector.X, -vector.Y);
+            new(-vector.X, -vector.Y);
 
         public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
-            new Vector2F<T>(left.X + right.X, left.Y + right.Y);
+            new(left.X + right.X, left.Y + right.Y);
 
         public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
-            new Vector2F<T>(left.X - right.X, left.Y - right.Y);
+            new(left.X - right.X, left.Y - right.Y);
 
         public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
-            new Vector2F<T>(left.X * right.X, left.Y * right.Y);
+            new(left.X * right.X, left.Y * right.Y);
 
         public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
-            new Vector2F<T>(left.X / right.X, left.Y / right.Y);
+            new(left.X / right.X, left.Y / right.Y);
 
         public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
-            new Vector2F<T>(left.X % right.X, left.Y % right.Y);
+            new(left.X % right.X, left.Y % right.Y);
 
         public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
-            new Vector2F<T>(vector.X + scalar, vector.Y + scalar);
+            new(vector.X + scalar, vector.Y + scalar);
 
         public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
-            new Vector2F<T>(vector.X - scalar, vector.Y - scalar);
+            new(vector.X - scalar, vector.Y - scalar);
 
         public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
-            new Vector2F<T>(vector.X * scalar, vector.Y * scalar);
+            new(vector.X * scalar, vector.Y * scalar);
 
         public static Vector2F<T> operator *(T scalar, Vector2F<T> vector) =>
-            new Vector2F<T>(scalar * vector.X, scalar * vector.Y);
+            new(scalar * vector.X, scalar * vector.Y);
 
         public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
-            new Vector2F<T>(vector.X / scalar, vector.Y / scalar);
+            new(vector.X / scalar, vector.Y / scalar);
 
         public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
-            new Vector2F<T>(vector.X % scalar, vector.Y % scalar);
+            new(vector.X % scalar, vector.Y % scalar);
 
     }
 
@@ -371,56 +388,504 @@ public static Vector2F<T> Normalize<T>(this Vector2F<T> vector)
             return length != T.Zero ? vector / length : Vector2F<T>.Zero;
         }
 
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2I<int> Sign<TSelf>(this Vector2F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Max<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Max<TSelf>(this Vector2F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MaxNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MaxNumber<TSelf>(this Vector2F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Min<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Min<TSelf>(this Vector2F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MinNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MinNumber<TSelf>(this Vector2F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector2F<TSelf> Clamp<TSelf>(this Vector2F<TSelf> value, Vector2F<TSelf> min, Vector2F<TSelf> max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector2F<TSelf> Clamp<TSelf>(this Vector2F<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector2F<TSelf> CopySign<TSelf>(this Vector2F<TSelf> value, Vector2F<TSelf> sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector2F<TSelf> CopySign<TSelf>(this Vector2F<TSelf> value, TSelf sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2F<TSelf> Abs<TSelf>(this Vector2F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MaxMagnitude<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MinMagnitude<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> MinMagnitudeNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Ceiling<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Floor<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Floor(x.X), TSelf.Floor(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Round<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X), TSelf.Round(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
+        /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
+        public static Vector2F<TSelf> Round<TSelf>(this Vector2F<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Truncate<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Atan2<TSelf>(this Vector2F<TSelf> y, Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Atan2Pi<TSelf>(this Vector2F<TSelf> y, Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Lerp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
+        /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
+        /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
+        public static Vector2F<TSelf> Lerp<TSelf>(this Vector2F<TSelf> value1, Vector2F<TSelf> value2, TSelf amount)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> BitDecrement<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> BitIncrement<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
+        public static Vector2F<TSelf> FusedMultiplyAdd<TSelf>(this Vector2F<TSelf> left, Vector2F<TSelf> right, Vector2F<TSelf> addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
+        public static Vector2F<TSelf> FusedMultiplyAdd<TSelf>(this Vector2F<TSelf> left, TSelf right, TSelf addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        public static Vector2F<TSelf> Ieee754Remainder<TSelf>(this Vector2F<TSelf> left, Vector2F<TSelf> right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        public static Vector2F<TSelf> Ieee754Remainder<TSelf>(this Vector2F<TSelf> left, TSelf right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2I<int> ILogB<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> ReciprocalEstimate<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector2F<TSelf> ScaleB<TSelf>(this Vector2F<TSelf> x, Vector2I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector2F<TSelf> ScaleB<TSelf>(this Vector2F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Pow<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Pow<TSelf>(this Vector2F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Cbrt<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Sqrt<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector2F<TSelf> RootN<TSelf>(this Vector2F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector2F<TSelf> RootN<TSelf>(this Vector2F<TSelf> x, Vector2I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2F<TSelf> Hypot<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
 
-        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> newBase)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y));
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
+        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x, TSelf newBase)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> LogP1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Log2<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Log2P1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Log10<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Log10P1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Exp<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> ExpM1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Exp2<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Exp2M1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Exp10<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector2F<TSelf> Exp10M1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Acos<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acos(x.X), TSelf.Acos(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> AcosPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Asin<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asin(x.X), TSelf.Asin(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> AsinPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Atan<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan(x.X), TSelf.Atan(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> AtanPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Cos<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cos(x.X), TSelf.Cos(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> CosPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Sin<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sin(x.X), TSelf.Sin(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> SinPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Tan<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tan(x.X), TSelf.Tan(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> TanPi<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
+        public static Vector2F<TSelf> DegreesToRadians<TSelf>(this Vector2F<TSelf> degrees)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
+        public static Vector2F<TSelf> RadiansToDegrees<TSelf>(this Vector2F<TSelf> radians)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Acosh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Asinh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Atanh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Cosh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Sinh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector2F<TSelf> Tanh<TSelf>(this Vector2F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y));
     }
 }
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
index fceb7b5b44..88adc7cb6e 100644
--- a/sources/Maths/Maths/Vector2I.cs
+++ b/sources/Maths/Maths/Vector2I.cs
@@ -20,84 +20,6 @@ internal partial struct Vector2I<T>
         /// <summary> Computes the cross product of two vectors. </summary>
         public static T Cross(Vector2I<T> left, Vector2I<T> right) => (left.X * right.Y) - (left.Y * right.X);
 
-        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
-        public Vector2I<T> Max(Vector2I<T> other) =>
-            new Vector2I<T>(T.Max(X, other.X), T.Max(Y, other.Y));
-
-        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
-        public static Vector2I<T> Max(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y));
-
-        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
-        public Vector2I<T> Max(T scalar) =>
-            new Vector2I<T>(T.Max(X, scalar), T.Max(Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
-        public static Vector2I<T> Max(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
-        public Vector2I<T> Min(Vector2I<T> other) =>
-            new Vector2I<T>(T.Min(X, other.X), T.Min(Y, other.Y));
-
-        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
-        public static Vector2I<T> Min(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y));
-
-        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
-        public Vector2I<T> Min(T scalar) =>
-            new Vector2I<T>(T.Min(X, scalar), T.Min(Y, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
-        public static Vector2I<T> Min(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar));
-
-        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
-        public Vector2I<T> Clamp(Vector2I<T> min, Vector2I<T> max) =>
-            new Vector2I<T>(T.Clamp(X, min.X, max.X), T.Clamp(Y, min.Y, max.Y));
-
-        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
-        public static Vector2I<T> Clamp(Vector2I<T> vector, Vector2I<T> min, Vector2I<T> max) =>
-            new Vector2I<T>(T.Clamp(vector.X, min.X, max.X), T.Clamp(vector.Y, min.Y, max.Y));
-
-        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
-        public Vector2I<T> Clamp(T min, T max) =>
-            new Vector2I<T>(T.Clamp(X, min, max), T.Clamp(Y, min, max));
-
-        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
-        public static Vector2I<T> Clamp(Vector2I<T> vector, T min, T max) =>
-            new Vector2I<T>(T.Clamp(vector.X, min, max), T.Clamp(vector.Y, min, max));
-
-        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
-        public Vector2I<T> Abs() => new Vector2I<T>(T.Abs(X), T.Abs(Y));
-
-        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
-        public static Vector2I<T> Abs(Vector2I<T> vector) =>
-            new Vector2I<T>(T.Abs(vector.X), T.Abs(vector.Y));
-
-        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
-        public Vector2I<T> Sign() => new Vector2I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)));
-
-        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
-        public static Vector2I<T> Sign(Vector2I<T> vector) =>
-            new Vector2I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)));
-
-        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
-        public Vector2I<T> CopySign(Vector2I<T> signSource) =>
-            new Vector2I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y));
-
-        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
-        public static Vector2I<T> CopySign(Vector2I<T> value, Vector2I<T> signSource) =>
-            new Vector2I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y));
-
-        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
-        public Vector2I<T> CopySign(T signScalar) =>
-            new Vector2I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar));
-
-        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
-        public static Vector2I<T> CopySign(Vector2I<T> value, T signScalar) =>
-            new Vector2I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar));
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2I{T}"/>.</summary>
@@ -108,20 +30,11 @@ public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
         public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
             new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
 
-        // IBinaryInteger
-        // TODO: Verify these are actually correct
-
-        public static Vector2I<T> Log2(Vector2I<T> x) =>
-            new Vector2I<T>(T.Log2(x.X), T.Log2(x.Y));
-
         public static (Vector2I<T> Quotient, Vector2I<T> Remainder) DivRem(Vector2I<T> left, Vector2I<T> right)
         {
             var (qX, rX) = T.DivRem(left.X, right.X);
             var (qY, rY) = T.DivRem(left.Y, right.Y);
             return (new Vector2I<T>(qX, qY), new Vector2I<T>(rX, rY));
         }
-
-        public static Vector2I<T> PopCount(Vector2I<T> x) =>
-            new Vector2I<T>(T.PopCount(x.X), T.PopCount(x.Y));
     }
 }
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
index afe221d779..5295369eb4 100644
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ b/sources/Maths/Maths/Vector2I.gen.cs
@@ -40,16 +40,16 @@ public Vector2I(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2I<T> One => new(Scalar<T>.One);
+        public static Vector2I<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
         public static Vector2I<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector2I<T> UnitX => new(T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector2I<T> UnitY => new(T.Zero, T.One);
 
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
@@ -305,44 +305,61 @@ static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        public void Deconstruct(out T x, out T y)
+        {
+            x = X;
+            y = Y;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2I{T}"/>.</summary>
+        public static implicit operator Vector2I<T>((T X, T Y) v) =>
+            new(v.X, v.Y);
+
+        /// <summary>Implicitly casts a <see cref="Vector2I{T}"/> to a <see cref="ValueTuple{T, T}"/>.</summary>
+        public static implicit operator (T X, T Y)(Vector2I<T> v) =>
+            (v.X, v.Y);
+
         public static Vector2I<T> operator +(Vector2I<T> vector) =>
             vector;
 
         public static Vector2I<T> operator -(Vector2I<T> vector) =>
-            new Vector2I<T>(-vector.X, -vector.Y);
+            new(-vector.X, -vector.Y);
 
         public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X + right.X, left.Y + right.Y);
+            new(left.X + right.X, left.Y + right.Y);
 
         public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X - right.X, left.Y - right.Y);
+            new(left.X - right.X, left.Y - right.Y);
 
         public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X * right.X, left.Y * right.Y);
+            new(left.X * right.X, left.Y * right.Y);
 
         public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X / right.X, left.Y / right.Y);
+            new(left.X / right.X, left.Y / right.Y);
 
         public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X % right.X, left.Y % right.Y);
+            new(left.X % right.X, left.Y % right.Y);
 
         public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X + scalar, vector.Y + scalar);
+            new(vector.X + scalar, vector.Y + scalar);
 
         public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X - scalar, vector.Y - scalar);
+            new(vector.X - scalar, vector.Y - scalar);
 
         public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X * scalar, vector.Y * scalar);
+            new(vector.X * scalar, vector.Y * scalar);
 
         public static Vector2I<T> operator *(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar * vector.X, scalar * vector.Y);
+            new(scalar * vector.X, scalar * vector.Y);
 
         public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X / scalar, vector.Y / scalar);
+            new(vector.X / scalar, vector.Y / scalar);
 
         public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X % scalar, vector.Y % scalar);
+            new(vector.X % scalar, vector.Y % scalar);
 
         public static Vector2I<T> operator ~(Vector2I<T> vector) =>
             new Vector2I<T>(~vector.X, ~vector.Y);
@@ -390,56 +407,136 @@ public static Vector2I<T> Reflect<T>(Vector2I<T> vector, Vector2I<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X), TSelf.Log(x.Y));
-
-        public static Vector2I<TSelf> Log<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> newBase)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y));
-
-        public static Vector2I<TSelf> LogP1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y));
-
-        public static Vector2I<TSelf> Log2<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2(x.X), TSelf.Log2(x.Y));
-
-        public static Vector2I<TSelf> Log2P1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y));
-
-        public static Vector2I<TSelf> Log10<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10(x.X), TSelf.Log10(x.Y));
-
-        public static Vector2I<TSelf> Log10P1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y));
-
-        public static Vector2I<TSelf> Exp<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp(x.X), TSelf.Exp(x.Y));
-
-        public static Vector2I<TSelf> ExpM1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y));
-
-        public static Vector2I<TSelf> Exp2<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y));
-
-        public static Vector2I<TSelf> Exp2M1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y));
-
-        public static Vector2I<TSelf> Exp10<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y));
-
-        public static Vector2I<TSelf> Exp10M1<TSelf>(this Vector2I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y));
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2I<int> Sign<TSelf>(this Vector2I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> Max<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> Max<TSelf>(this Vector2I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MaxNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MaxNumber<TSelf>(this Vector2I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> Min<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> Min<TSelf>(this Vector2I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MinNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MinNumber<TSelf>(this Vector2I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector2I<TSelf> Clamp<TSelf>(this Vector2I<TSelf> value, Vector2I<TSelf> min, Vector2I<TSelf> max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector2I<TSelf> Clamp<TSelf>(this Vector2I<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector2I<TSelf> CopySign<TSelf>(this Vector2I<TSelf> value, Vector2I<TSelf> sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector2I<TSelf> CopySign<TSelf>(this Vector2I<TSelf> value, TSelf sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2I<TSelf> Abs<TSelf>(this Vector2I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MaxMagnitude<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MinMagnitude<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector2I<TSelf> MinMagnitudeNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y));
+
+        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2I<TSelf> Log2<TSelf>(this Vector2I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Log2(value.X), TSelf.Log2(value.Y));
     }
 }
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3F.gen.cs
index 6c9a8a9f67..2c0d24db9c 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3F.gen.cs
@@ -47,19 +47,19 @@ public Vector3F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3F<T> One => new(Scalar<T>.One);
+        public static Vector3F<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
         public static Vector3F<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector3F<T> UnitX => new(T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector3F<T> UnitY => new(T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector3F<T> UnitZ => new(T.Zero, T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => Vector3F.Dot(this, this);
@@ -339,44 +339,63 @@ static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        public void Deconstruct(out T x, out T y, out T z)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3F{T}"/>.</summary>
+        public static implicit operator Vector3F<T>((T X, T Y, T Z) v) =>
+            new(v.X, v.Y, v.Z);
+
+        /// <summary>Implicitly casts a <see cref="Vector3F{T}"/> to a <see cref="ValueTuple{T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z)(Vector3F<T> v) =>
+            (v.X, v.Y, v.Z);
+
         public static Vector3F<T> operator +(Vector3F<T> vector) =>
             vector;
 
         public static Vector3F<T> operator -(Vector3F<T> vector) =>
-            new Vector3F<T>(-vector.X, -vector.Y, -vector.Z);
+            new(-vector.X, -vector.Y, -vector.Z);
 
         public static Vector3F<T> operator +(Vector3F<T> left, Vector3F<T> right) =>
-            new Vector3F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
 
         public static Vector3F<T> operator -(Vector3F<T> left, Vector3F<T> right) =>
-            new Vector3F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
 
         public static Vector3F<T> operator *(Vector3F<T> left, Vector3F<T> right) =>
-            new Vector3F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
 
         public static Vector3F<T> operator /(Vector3F<T> left, Vector3F<T> right) =>
-            new Vector3F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
 
         public static Vector3F<T> operator %(Vector3F<T> left, Vector3F<T> right) =>
-            new Vector3F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
 
         public static Vector3F<T> operator +(Vector3F<T> vector, T scalar) =>
-            new Vector3F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
 
         public static Vector3F<T> operator -(Vector3F<T> vector, T scalar) =>
-            new Vector3F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
 
         public static Vector3F<T> operator *(Vector3F<T> vector, T scalar) =>
-            new Vector3F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
 
         public static Vector3F<T> operator *(T scalar, Vector3F<T> vector) =>
-            new Vector3F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
 
         public static Vector3F<T> operator /(Vector3F<T> vector, T scalar) =>
-            new Vector3F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
 
         public static Vector3F<T> operator %(Vector3F<T> vector, T scalar) =>
-            new Vector3F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
 
     }
 
@@ -408,56 +427,504 @@ public static Vector3F<T> Normalize<T>(this Vector3F<T> vector)
             return length != T.Zero ? vector / length : Vector3F<T>.Zero;
         }
 
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3I<int> Sign<TSelf>(this Vector3F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Max<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Max<TSelf>(this Vector3F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MaxNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MaxNumber<TSelf>(this Vector3F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Min<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Min<TSelf>(this Vector3F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MinNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MinNumber<TSelf>(this Vector3F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector3F<TSelf> Clamp<TSelf>(this Vector3F<TSelf> value, Vector3F<TSelf> min, Vector3F<TSelf> max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector3F<TSelf> Clamp<TSelf>(this Vector3F<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector3F<TSelf> CopySign<TSelf>(this Vector3F<TSelf> value, Vector3F<TSelf> sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector3F<TSelf> CopySign<TSelf>(this Vector3F<TSelf> value, TSelf sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3F<TSelf> Abs<TSelf>(this Vector3F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MaxMagnitude<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MinMagnitude<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> MinMagnitudeNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Ceiling<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y), TSelf.Ceiling(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Floor<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Floor(x.X), TSelf.Floor(x.Y), TSelf.Floor(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Round<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X), TSelf.Round(x.Y), TSelf.Round(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
+        /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
+        public static Vector3F<TSelf> Round<TSelf>(this Vector3F<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode), TSelf.Round(x.Z, digits, mode));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Truncate<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y), TSelf.Truncate(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Atan2<TSelf>(this Vector3F<TSelf> y, Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y), TSelf.Atan2(y.Z, x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Atan2Pi<TSelf>(this Vector3F<TSelf> y, Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y), TSelf.Atan2Pi(y.Z, x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Lerp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
+        /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
+        /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
+        public static Vector3F<TSelf> Lerp<TSelf>(this Vector3F<TSelf> value1, Vector3F<TSelf> value2, TSelf amount)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount), TSelf.Lerp(value1.Z, value2.Z, amount));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> BitDecrement<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y), TSelf.BitDecrement(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> BitIncrement<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y), TSelf.BitIncrement(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
+        public static Vector3F<TSelf> FusedMultiplyAdd<TSelf>(this Vector3F<TSelf> left, Vector3F<TSelf> right, Vector3F<TSelf> addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y), TSelf.FusedMultiplyAdd(left.Z, right.Z, addend.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
+        public static Vector3F<TSelf> FusedMultiplyAdd<TSelf>(this Vector3F<TSelf> left, TSelf right, TSelf addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend), TSelf.FusedMultiplyAdd(left.Z, right, addend));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        public static Vector3F<TSelf> Ieee754Remainder<TSelf>(this Vector3F<TSelf> left, Vector3F<TSelf> right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y), TSelf.Ieee754Remainder(left.Z, right.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        public static Vector3F<TSelf> Ieee754Remainder<TSelf>(this Vector3F<TSelf> left, TSelf right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right), TSelf.Ieee754Remainder(left.Z, right));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3I<int> ILogB<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y), TSelf.ILogB(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> ReciprocalEstimate<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y), TSelf.ReciprocalEstimate(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y), TSelf.ReciprocalSqrtEstimate(x.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector3F<TSelf> ScaleB<TSelf>(this Vector3F<TSelf> x, Vector3I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y), TSelf.ScaleB(x.Z, n.Z));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector3F<TSelf> ScaleB<TSelf>(this Vector3F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n), TSelf.ScaleB(x.Z, n));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Pow<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y), TSelf.Pow(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Pow<TSelf>(this Vector3F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y), TSelf.Pow(x.Z, y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Cbrt<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y), TSelf.Cbrt(x.Z));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Sqrt<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y), TSelf.Sqrt(x.Z));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector3F<TSelf> RootN<TSelf>(this Vector3F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n), TSelf.RootN(x.Z, n));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector3F<TSelf> RootN<TSelf>(this Vector3F<TSelf> x, Vector3I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y), TSelf.RootN(x.Z, n.Z));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3F<TSelf> Hypot<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y), TSelf.Hypot(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
 
-        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> newBase)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z));
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
+        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x, TSelf newBase)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase), TSelf.Log(x.Z, newBase));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> LogP1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Log2<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Log2P1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Log10<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Log10P1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Exp<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> ExpM1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Exp2<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Exp2M1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Exp10<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector3F<TSelf> Exp10M1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Acos<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acos(x.X), TSelf.Acos(x.Y), TSelf.Acos(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> AcosPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y), TSelf.AcosPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Asin<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asin(x.X), TSelf.Asin(x.Y), TSelf.Asin(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> AsinPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y), TSelf.AsinPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Atan<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan(x.X), TSelf.Atan(x.Y), TSelf.Atan(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> AtanPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y), TSelf.AtanPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Cos<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cos(x.X), TSelf.Cos(x.Y), TSelf.Cos(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> CosPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y), TSelf.CosPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Sin<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sin(x.X), TSelf.Sin(x.Y), TSelf.Sin(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> SinPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y), TSelf.SinPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Tan<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tan(x.X), TSelf.Tan(x.Y), TSelf.Tan(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> TanPi<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y), TSelf.TanPi(x.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
+        public static Vector3F<TSelf> DegreesToRadians<TSelf>(this Vector3F<TSelf> degrees)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y), TSelf.DegreesToRadians(degrees.Z));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
+        public static Vector3F<TSelf> RadiansToDegrees<TSelf>(this Vector3F<TSelf> radians)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y), TSelf.RadiansToDegrees(radians.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Acosh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y), TSelf.Acosh(x.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Asinh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y), TSelf.Asinh(x.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Atanh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y), TSelf.Atanh(x.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Cosh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y), TSelf.Cosh(x.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Sinh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y), TSelf.Sinh(x.Z));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector3F<TSelf> Tanh<TSelf>(this Vector3F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y), TSelf.Tanh(x.Z));
     }
 }
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3I.cs
index 167273b467..4141292c52 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3I.cs
@@ -30,101 +30,6 @@ public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
                 (left.X * right.Y) - (left.Y * right.X)
             );
 
-        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
-        public Vector3I<T> Max(Vector3I<T> other) =>
-            new Vector3I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z));
-
-        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
-        public static Vector3I<T> Max(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y), T.Max(left.Z, right.Z));
-
-        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
-        public Vector3I<T> Max(T scalar) =>
-            new Vector3I<T>(T.Max(X, scalar), T.Max(Y, scalar), T.Max(Z, scalar));
-
-        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
-        public static Vector3I<T> Max(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar), T.Max(vector.Z, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
-        public Vector3I<T> Min(Vector3I<T> other) =>
-            new Vector3I<T>(T.Min(X, other.X), T.Min(Y, other.Y), T.Min(Z, other.Z));
-
-        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
-        public static Vector3I<T> Min(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y), T.Min(left.Z, right.Z));
-
-        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
-        public Vector3I<T> Min(T scalar) =>
-            new Vector3I<T>(T.Min(X, scalar), T.Min(Y, scalar), T.Min(Z, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
-        public static Vector3I<T> Min(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar), T.Min(vector.Z, scalar));
-
-        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
-        public Vector3I<T> Clamp(Vector3I<T> min, Vector3I<T> max) =>
-            new Vector3I<T>(
-                T.Clamp(X, min.X, max.X),
-                T.Clamp(Y, min.Y, max.Y),
-                T.Clamp(Z, min.Z, max.Z)
-            );
-
-        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
-        public static Vector3I<T> Clamp(Vector3I<T> vector, Vector3I<T> min, Vector3I<T> max) =>
-            new Vector3I<T>(
-                T.Clamp(vector.X, min.X, max.X),
-                T.Clamp(vector.Y, min.Y, max.Y),
-                T.Clamp(vector.Z, min.Z, max.Z)
-            );
-
-        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
-        public Vector3I<T> Clamp(T min, T max) =>
-            new Vector3I<T>(
-                T.Clamp(X, min, max),
-                T.Clamp(Y, min, max),
-                T.Clamp(Z, min, max)
-            );
-
-        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
-        public static Vector3I<T> Clamp(Vector3I<T> vector, T min, T max) =>
-            new Vector3I<T>(
-                T.Clamp(vector.X, min, max),
-                T.Clamp(vector.Y, min, max),
-                T.Clamp(vector.Z, min, max)
-            );
-
-        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
-        public Vector3I<T> Abs() => new Vector3I<T>(T.Abs(X), T.Abs(Y), T.Abs(Z));
-
-        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
-        public static Vector3I<T> Abs(Vector3I<T> vector) =>
-            new Vector3I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z));
-
-        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
-        public Vector3I<T> Sign() =>
-            new Vector3I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)));
-
-        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
-        public static Vector3I<T> Sign(Vector3I<T> vector) =>
-            new Vector3I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)), T.CreateChecked(T.Sign(vector.Z)));
-
-        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
-        public Vector3I<T> CopySign(Vector3I<T> signSource) =>
-            new Vector3I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y), T.CopySign(Z, signSource.Z));
-
-        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
-        public static Vector3I<T> CopySign(Vector3I<T> value, Vector3I<T> signSource) =>
-            new Vector3I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y), T.CopySign(value.Z, signSource.Z));
-
-        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
-        public Vector3I<T> CopySign(T signScalar) =>
-            new Vector3I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar), T.CopySign(Z, signScalar));
-
-        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
-        public static Vector3I<T> CopySign(Vector3I<T> value, T signScalar) =>
-            new Vector3I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar));
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3I{T}"/>.</summary>
@@ -135,10 +40,6 @@ public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
         public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
             new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
 
-        // IBinaryInteger
-        public static Vector3I<T> Log2(Vector3I<T> x) =>
-            new Vector3I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z));
-
         public static (Vector3I<T> Quotient, Vector3I<T> Remainder) DivRem(Vector3I<T> left, Vector3I<T> right)
         {
             var (qX, rX) = T.DivRem(left.X, right.X);
@@ -146,8 +47,5 @@ public static (Vector3I<T> Quotient, Vector3I<T> Remainder) DivRem(Vector3I<T> l
             var (qZ, rZ) = T.DivRem(left.Z, right.Z);
             return (new Vector3I<T>(qX, qY, qZ), new Vector3I<T>(rX, rY, rZ));
         }
-
-        public static Vector3I<T> PopCount(Vector3I<T> x) =>
-            new Vector3I<T>(T.PopCount(x.X), T.PopCount(x.Y), T.PopCount(x.Z));
     }
 }
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
index 05bb368e10..197cb262d2 100644
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ b/sources/Maths/Maths/Vector3I.gen.cs
@@ -47,19 +47,19 @@ public Vector3I(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3I<T> One => new(Scalar<T>.One);
+        public static Vector3I<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
         public static Vector3I<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector3I<T> UnitX => new(T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector3I<T> UnitY => new(T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector3I<T> UnitZ => new(T.Zero, T.Zero, T.One);
 
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
@@ -342,44 +342,63 @@ static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        public void Deconstruct(out T x, out T y, out T z)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3I{T}"/>.</summary>
+        public static implicit operator Vector3I<T>((T X, T Y, T Z) v) =>
+            new(v.X, v.Y, v.Z);
+
+        /// <summary>Implicitly casts a <see cref="Vector3I{T}"/> to a <see cref="ValueTuple{T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z)(Vector3I<T> v) =>
+            (v.X, v.Y, v.Z);
+
         public static Vector3I<T> operator +(Vector3I<T> vector) =>
             vector;
 
         public static Vector3I<T> operator -(Vector3I<T> vector) =>
-            new Vector3I<T>(-vector.X, -vector.Y, -vector.Z);
+            new(-vector.X, -vector.Y, -vector.Z);
 
         public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
+            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
 
         public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
+            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
 
         public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
+            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
 
         public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
+            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
 
         public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
+            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
 
         public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
+            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
 
         public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
+            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
 
         public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
+            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
 
         public static Vector3I<T> operator *(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
+            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
 
         public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
 
         public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
+            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
 
         public static Vector3I<T> operator ~(Vector3I<T> vector) =>
             new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
@@ -427,56 +446,136 @@ public static Vector3I<T> Reflect<T>(Vector3I<T> vector, Vector3I<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
-
-        public static Vector3I<TSelf> Log<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> newBase)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z));
-
-        public static Vector3I<TSelf> LogP1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z));
-
-        public static Vector3I<TSelf> Log2<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z));
-
-        public static Vector3I<TSelf> Log2P1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z));
-
-        public static Vector3I<TSelf> Log10<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z));
-
-        public static Vector3I<TSelf> Log10P1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z));
-
-        public static Vector3I<TSelf> Exp<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z));
-
-        public static Vector3I<TSelf> ExpM1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z));
-
-        public static Vector3I<TSelf> Exp2<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z));
-
-        public static Vector3I<TSelf> Exp2M1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z));
-
-        public static Vector3I<TSelf> Exp10<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z));
-
-        public static Vector3I<TSelf> Exp10M1<TSelf>(this Vector3I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z));
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3I<int> Sign<TSelf>(this Vector3I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> Max<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> Max<TSelf>(this Vector3I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MaxNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MaxNumber<TSelf>(this Vector3I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> Min<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> Min<TSelf>(this Vector3I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MinNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MinNumber<TSelf>(this Vector3I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector3I<TSelf> Clamp<TSelf>(this Vector3I<TSelf> value, Vector3I<TSelf> min, Vector3I<TSelf> max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector3I<TSelf> Clamp<TSelf>(this Vector3I<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector3I<TSelf> CopySign<TSelf>(this Vector3I<TSelf> value, Vector3I<TSelf> sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector3I<TSelf> CopySign<TSelf>(this Vector3I<TSelf> value, TSelf sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3I<TSelf> Abs<TSelf>(this Vector3I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MaxMagnitude<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MinMagnitude<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector3I<TSelf> MinMagnitudeNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z));
+
+        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3I<TSelf> Log2<TSelf>(this Vector3I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Log2(value.X), TSelf.Log2(value.Y), TSelf.Log2(value.Z));
     }
 }
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4F.gen.cs
index be1a8e23ed..cd0dd8a87d 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4F.gen.cs
@@ -54,22 +54,22 @@ public Vector4F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4F<T> One => new(Scalar<T>.One);
+        public static Vector4F<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
         public static Vector4F<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4F<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector4F<T> UnitX => new(T.One, T.Zero, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4F<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector4F<T> UnitY => new(T.Zero, T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4F<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector4F<T> UnitZ => new(T.Zero, T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4F<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector4F<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
         public T LengthSquared => Vector4F.Dot(this, this);
@@ -376,44 +376,65 @@ static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        /// <param name="w">The W component.</param>
+        public void Deconstruct(out T x, out T y, out T z, out T w)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+            w = W;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4F{T}"/>.</summary>
+        public static implicit operator Vector4F<T>((T X, T Y, T Z, T W) v) =>
+            new(v.X, v.Y, v.Z, v.W);
+
+        /// <summary>Implicitly casts a <see cref="Vector4F{T}"/> to a <see cref="ValueTuple{T, T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z, T W)(Vector4F<T> v) =>
+            (v.X, v.Y, v.Z, v.W);
+
         public static Vector4F<T> operator +(Vector4F<T> vector) =>
             vector;
 
         public static Vector4F<T> operator -(Vector4F<T> vector) =>
-            new Vector4F<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+            new(-vector.X, -vector.Y, -vector.Z, -vector.W);
 
         public static Vector4F<T> operator +(Vector4F<T> left, Vector4F<T> right) =>
-            new Vector4F<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
 
         public static Vector4F<T> operator -(Vector4F<T> left, Vector4F<T> right) =>
-            new Vector4F<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
 
         public static Vector4F<T> operator *(Vector4F<T> left, Vector4F<T> right) =>
-            new Vector4F<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
 
         public static Vector4F<T> operator /(Vector4F<T> left, Vector4F<T> right) =>
-            new Vector4F<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
 
         public static Vector4F<T> operator %(Vector4F<T> left, Vector4F<T> right) =>
-            new Vector4F<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
 
         public static Vector4F<T> operator +(Vector4F<T> vector, T scalar) =>
-            new Vector4F<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
 
         public static Vector4F<T> operator -(Vector4F<T> vector, T scalar) =>
-            new Vector4F<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
 
         public static Vector4F<T> operator *(Vector4F<T> vector, T scalar) =>
-            new Vector4F<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
 
         public static Vector4F<T> operator *(T scalar, Vector4F<T> vector) =>
-            new Vector4F<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
 
         public static Vector4F<T> operator /(Vector4F<T> vector, T scalar) =>
-            new Vector4F<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
 
         public static Vector4F<T> operator %(Vector4F<T> vector, T scalar) =>
-            new Vector4F<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
 
     }
 
@@ -445,56 +466,504 @@ public static Vector4F<T> Normalize<T>(this Vector4F<T> vector)
             return length != T.Zero ? vector / length : Vector4F<T>.Zero;
         }
 
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4I<int> Sign<TSelf>(this Vector4F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z), TSelf.Sign(value.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Max<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z), TSelf.Max(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Max<TSelf>(this Vector4F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y), TSelf.Max(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MaxNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z), TSelf.MaxNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MaxNumber<TSelf>(this Vector4F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y), TSelf.MaxNumber(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Min<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z), TSelf.Min(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Min<TSelf>(this Vector4F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y), TSelf.Min(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MinNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z), TSelf.MinNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MinNumber<TSelf>(this Vector4F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y), TSelf.MinNumber(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector4F<TSelf> Clamp<TSelf>(this Vector4F<TSelf> value, Vector4F<TSelf> min, Vector4F<TSelf> max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z), TSelf.Clamp(value.W, min.W, max.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector4F<TSelf> Clamp<TSelf>(this Vector4F<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max), TSelf.Clamp(value.W, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector4F<TSelf> CopySign<TSelf>(this Vector4F<TSelf> value, Vector4F<TSelf> sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z), TSelf.CopySign(value.W, sign.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector4F<TSelf> CopySign<TSelf>(this Vector4F<TSelf> value, TSelf sign)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign), TSelf.CopySign(value.W, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4F<TSelf> Abs<TSelf>(this Vector4F<TSelf> value)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z), TSelf.Abs(value.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MaxMagnitude<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z), TSelf.MaxMagnitude(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z), TSelf.MaxMagnitudeNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MinMagnitude<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z), TSelf.MinMagnitude(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> MinMagnitudeNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z), TSelf.MinMagnitudeNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Ceiling<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y), TSelf.Ceiling(x.Z), TSelf.Ceiling(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Floor<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Floor(x.X), TSelf.Floor(x.Y), TSelf.Floor(x.Z), TSelf.Floor(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Round<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X), TSelf.Round(x.Y), TSelf.Round(x.Z), TSelf.Round(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
+        /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
+        public static Vector4F<TSelf> Round<TSelf>(this Vector4F<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode), TSelf.Round(x.Z, digits, mode), TSelf.Round(x.W, digits, mode));
+
+        /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Truncate<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y), TSelf.Truncate(x.Z), TSelf.Truncate(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Atan2<TSelf>(this Vector4F<TSelf> y, Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y), TSelf.Atan2(y.Z, x.Z), TSelf.Atan2(y.W, x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Atan2Pi<TSelf>(this Vector4F<TSelf> y, Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y), TSelf.Atan2Pi(y.Z, x.Z), TSelf.Atan2Pi(y.W, x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Lerp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
+        /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
+        /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
+        public static Vector4F<TSelf> Lerp<TSelf>(this Vector4F<TSelf> value1, Vector4F<TSelf> value2, TSelf amount)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount), TSelf.Lerp(value1.Z, value2.Z, amount), TSelf.Lerp(value1.W, value2.W, amount));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> BitDecrement<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y), TSelf.BitDecrement(x.Z), TSelf.BitDecrement(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> BitIncrement<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y), TSelf.BitIncrement(x.Z), TSelf.BitIncrement(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
+        public static Vector4F<TSelf> FusedMultiplyAdd<TSelf>(this Vector4F<TSelf> left, Vector4F<TSelf> right, Vector4F<TSelf> addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y), TSelf.FusedMultiplyAdd(left.Z, right.Z, addend.Z), TSelf.FusedMultiplyAdd(left.W, right.W, addend.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.FusedMultiplyAdd(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
+        public static Vector4F<TSelf> FusedMultiplyAdd<TSelf>(this Vector4F<TSelf> left, TSelf right, TSelf addend)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend), TSelf.FusedMultiplyAdd(left.Z, right, addend), TSelf.FusedMultiplyAdd(left.W, right, addend));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
+        public static Vector4F<TSelf> Ieee754Remainder<TSelf>(this Vector4F<TSelf> left, Vector4F<TSelf> right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y), TSelf.Ieee754Remainder(left.Z, right.Z), TSelf.Ieee754Remainder(left.W, right.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A single value provided for <parameref name="right"/>.</param>
+        public static Vector4F<TSelf> Ieee754Remainder<TSelf>(this Vector4F<TSelf> left, TSelf right)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right), TSelf.Ieee754Remainder(left.Z, right), TSelf.Ieee754Remainder(left.W, right));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4I<int> ILogB<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y), TSelf.ILogB(x.Z), TSelf.ILogB(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> ReciprocalEstimate<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y), TSelf.ReciprocalEstimate(x.Z), TSelf.ReciprocalEstimate(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y), TSelf.ReciprocalSqrtEstimate(x.Z), TSelf.ReciprocalSqrtEstimate(x.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector4F<TSelf> ScaleB<TSelf>(this Vector4F<TSelf> x, Vector4I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y), TSelf.ScaleB(x.Z, n.Z), TSelf.ScaleB(x.W, n.W));
+
+        /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector4F<TSelf> ScaleB<TSelf>(this Vector4F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n), TSelf.ScaleB(x.Z, n), TSelf.ScaleB(x.W, n));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Pow<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y), TSelf.Pow(x.Z, y.Z), TSelf.Pow(x.W, y.W));
+
+        /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Pow<TSelf>(this Vector4F<TSelf> x, TSelf y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y), TSelf.Pow(x.Z, y), TSelf.Pow(x.W, y));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Cbrt<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y), TSelf.Cbrt(x.Z), TSelf.Cbrt(x.W));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Sqrt<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y), TSelf.Sqrt(x.Z), TSelf.Sqrt(x.W));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A single value provided for <parameref name="n"/>.</param>
+        public static Vector4F<TSelf> RootN<TSelf>(this Vector4F<TSelf> x, int n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n), TSelf.RootN(x.Z, n), TSelf.RootN(x.W, n));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
+        public static Vector4F<TSelf> RootN<TSelf>(this Vector4F<TSelf> x, Vector4I<int> n)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y), TSelf.RootN(x.Z, n.Z), TSelf.RootN(x.W, n.W));
+
+        /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4F<TSelf> Hypot<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y), TSelf.Hypot(x.Z, y.Z), TSelf.Hypot(x.W, y.W));
+
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
 
-        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> newBase)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z), TSelf.Log(x.W, newBase.W));
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
+        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x, TSelf newBase)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase), TSelf.Log(x.Z, newBase), TSelf.Log(x.W, newBase));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> LogP1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z), TSelf.LogP1(x.W));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Log2<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z), TSelf.Log2(x.W));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Log2P1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z), TSelf.Log2P1(x.W));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Log10<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z), TSelf.Log10(x.W));
 
+        /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Log10P1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, ILogarithmicFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z), TSelf.Log10P1(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Exp<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z), TSelf.Exp(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> ExpM1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z), TSelf.ExpM1(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Exp2<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z), TSelf.Exp2(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Exp2M1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z), TSelf.Exp2M1(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Exp10<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z), TSelf.Exp10(x.W));
 
+        /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static Vector4F<TSelf> Exp10M1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf>, IExponentialFunctions<TSelf> =>
+            where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z), TSelf.Exp10M1(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Acos<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acos(x.X), TSelf.Acos(x.Y), TSelf.Acos(x.Z), TSelf.Acos(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> AcosPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y), TSelf.AcosPi(x.Z), TSelf.AcosPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Asin<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asin(x.X), TSelf.Asin(x.Y), TSelf.Asin(x.Z), TSelf.Asin(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> AsinPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y), TSelf.AsinPi(x.Z), TSelf.AsinPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Atan<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atan(x.X), TSelf.Atan(x.Y), TSelf.Atan(x.Z), TSelf.Atan(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> AtanPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y), TSelf.AtanPi(x.Z), TSelf.AtanPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Cos<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cos(x.X), TSelf.Cos(x.Y), TSelf.Cos(x.Z), TSelf.Cos(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> CosPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y), TSelf.CosPi(x.Z), TSelf.CosPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Sin<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sin(x.X), TSelf.Sin(x.Y), TSelf.Sin(x.Z), TSelf.Sin(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> SinPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y), TSelf.SinPi(x.Z), TSelf.SinPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Tan<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tan(x.X), TSelf.Tan(x.Y), TSelf.Tan(x.Z), TSelf.Tan(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> TanPi<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y), TSelf.TanPi(x.Z), TSelf.TanPi(x.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
+        public static Vector4F<TSelf> DegreesToRadians<TSelf>(this Vector4F<TSelf> degrees)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y), TSelf.DegreesToRadians(degrees.Z), TSelf.DegreesToRadians(degrees.W));
+
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
+        public static Vector4F<TSelf> RadiansToDegrees<TSelf>(this Vector4F<TSelf> radians)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y), TSelf.RadiansToDegrees(radians.Z), TSelf.RadiansToDegrees(radians.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Acosh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y), TSelf.Acosh(x.Z), TSelf.Acosh(x.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Asinh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y), TSelf.Asinh(x.Z), TSelf.Asinh(x.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Atanh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y), TSelf.Atanh(x.Z), TSelf.Atanh(x.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Cosh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y), TSelf.Cosh(x.Z), TSelf.Cosh(x.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Sinh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y), TSelf.Sinh(x.Z), TSelf.Sinh(x.W));
+
+        /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        public static Vector4F<TSelf> Tanh<TSelf>(this Vector4F<TSelf> x)
+            where TSelf : IFloatingPointIeee754<TSelf> =>
+            new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y), TSelf.Tanh(x.Z), TSelf.Tanh(x.W));
     }
 }
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4I.cs
index 16c3e21720..3b7442adbc 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4I.cs
@@ -13,105 +13,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 4D integer vector.</summary>
     internal partial struct Vector4I<T>
     {
-        /// <summary>Returns a vector with the component-wise maximum of this and another vector.</summary>
-        public Vector4I<T> Max(Vector4I<T> other) =>
-            new Vector4I<T>(T.Max(X, other.X), T.Max(Y, other.Y), T.Max(Z, other.Z), T.Max(W, other.W));
-
-        /// <summary>Returns a vector with the component-wise maximum of two vectors.</summary>
-        public static Vector4I<T> Max(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(T.Max(left.X, right.X), T.Max(left.Y, right.Y), T.Max(left.Z, right.Z), T.Max(left.W, right.W));
-
-        /// <summary>Returns a vector with the component-wise maximum of this vector and a scalar.</summary>
-        public Vector4I<T> Max(T scalar) =>
-            new Vector4I<T>(T.Max(X, scalar), T.Max(Y, scalar), T.Max(Z, scalar), T.Max(W, scalar));
-
-        /// <summary>Returns a vector with the component-wise maximum of a vector and a scalar.</summary>
-        public static Vector4I<T> Max(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(T.Max(vector.X, scalar), T.Max(vector.Y, scalar), T.Max(vector.Z, scalar), T.Max(vector.W, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of this and another vector.</summary>
-        public Vector4I<T> Min(Vector4I<T> other) =>
-            new Vector4I<T>(T.Min(X, other.X), T.Min(Y, other.Y), T.Min(Z, other.Z), T.Min(W, other.W));
-
-        /// <summary>Returns a vector with the component-wise minimum of two vectors.</summary>
-        public static Vector4I<T> Min(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(T.Min(left.X, right.X), T.Min(left.Y, right.Y), T.Min(left.Z, right.Z), T.Min(left.W, right.W));
-
-        /// <summary>Returns a vector with the component-wise minimum of this vector and a scalar.</summary>
-        public Vector4I<T> Min(T scalar) =>
-            new Vector4I<T>(T.Min(X, scalar), T.Min(Y, scalar), T.Min(Z, scalar), T.Min(W, scalar));
-
-        /// <summary>Returns a vector with the component-wise minimum of a vector and a scalar.</summary>
-        public static Vector4I<T> Min(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(T.Min(vector.X, scalar), T.Min(vector.Y, scalar), T.Min(vector.Z, scalar), T.Min(vector.W, scalar));
-
-        /// <summary>Clamps this vector's components between the corresponding Min and Max vectors.</summary>
-        public Vector4I<T> Clamp(Vector4I<T> min, Vector4I<T> max) =>
-            new Vector4I<T>(
-                T.Clamp(X, min.X, max.X),
-                T.Clamp(Y, min.Y, max.Y),
-                T.Clamp(Z, min.Z, max.Z),
-                T.Clamp(W, min.W, max.W)
-            );
-
-        /// <summary>Clamps the components of a vector between the corresponding Min and Max vectors.</summary>
-        public static Vector4I<T> Clamp(Vector4I<T> vector, Vector4I<T> min, Vector4I<T> max) =>
-            new Vector4I<T>(
-                T.Clamp(vector.X, min.X, max.X),
-                T.Clamp(vector.Y, min.Y, max.Y),
-                T.Clamp(vector.Z, min.Z, max.Z),
-                T.Clamp(vector.W, min.W, max.W)
-            );
-
-        /// <summary>Clamps this vector's components between the Min and Max scalar values.</summary>
-        public Vector4I<T> Clamp(T min, T max) =>
-            new Vector4I<T>(
-                T.Clamp(X, min, max),
-                T.Clamp(Y, min, max),
-                T.Clamp(Z, min, max),
-                T.Clamp(W, min, max)
-            );
-
-        /// <summary>Clamps the components of a vector between the Min and Max scalar values.</summary>
-        public static Vector4I<T> Clamp(Vector4I<T> vector, T min, T max) =>
-            new Vector4I<T>(
-                T.Clamp(vector.X, min, max),
-                T.Clamp(vector.Y, min, max),
-                T.Clamp(vector.Z, min, max),
-                T.Clamp(vector.W, min, max)
-            );
-
-        /// <summary>Returns a vector with the absolute value of each component of this vector.</summary>
-        public Vector4I<T> Abs() => new Vector4I<T>(T.Abs(X), T.Abs(Y), T.Abs(Z), T.Abs(W));
-
-        /// <summary>Returns a vector with the absolute value of each component of the specified vector.</summary>
-        public static Vector4I<T> Abs(Vector4I<T> vector) =>
-            new Vector4I<T>(T.Abs(vector.X), T.Abs(vector.Y), T.Abs(vector.Z), T.Abs(vector.W));
-
-        /// <summary>Returns a vector where each component is the sign of the original vector's component.</summary>
-        public Vector4I<T> Sign() =>
-            new Vector4I<T>(T.CreateChecked(T.Sign(X)), T.CreateChecked(T.Sign(Y)), T.CreateChecked(T.Sign(Z)), T.CreateChecked(T.Sign(W)));
-
-        /// <summary>Returns a vector where each component is the sign of the input vector's component.</summary>
-        public static Vector4I<T> Sign(Vector4I<T> vector) =>
-            new Vector4I<T>(T.CreateChecked(T.Sign(vector.X)), T.CreateChecked(T.Sign(vector.Y)), T.CreateChecked(T.Sign(vector.Z)), T.CreateChecked(T.Sign(vector.W)));
-
-        /// <summary>Copies the sign of each component from another vector to this vector's components.</summary>
-        public Vector4I<T> CopySign(Vector4I<T> signSource) =>
-            new Vector4I<T>(T.CopySign(X, signSource.X), T.CopySign(Y, signSource.Y), T.CopySign(Z, signSource.Z), T.CopySign(W, signSource.W));
-
-        /// <summary>Copies the sign of each component from another vector to a new vector.</summary>
-        public static Vector4I<T> CopySign(Vector4I<T> value, Vector4I<T> signSource) =>
-            new Vector4I<T>(T.CopySign(value.X, signSource.X), T.CopySign(value.Y, signSource.Y), T.CopySign(value.Z, signSource.Z), T.CopySign(value.W, signSource.W));
-
-        /// <summary>Copies the sign of a scalar onto each component of this vector.</summary>
-        public Vector4I<T> CopySign(T signScalar) =>
-            new Vector4I<T>(T.CopySign(X, signScalar), T.CopySign(Y, signScalar), T.CopySign(Z, signScalar), T.CopySign(W, signScalar));
-
-        /// <summary>Copies the sign of a scalar onto each component of a new vector.</summary>
-        public static Vector4I<T> CopySign(Vector4I<T> value, T signScalar) =>
-            new Vector4I<T>(T.CopySign(value.X, signScalar), T.CopySign(value.Y, signScalar), T.CopySign(value.Z, signScalar), T.CopySign(value.W, signScalar));
-
         // Casts
 
         /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4I.</summary>
@@ -122,10 +23,6 @@ public static explicit operator Vector4I<T>(System.Numerics.Vector4 v) =>
         public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
             new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
 
-        // IBinaryInteger
-        public static Vector4I<T> Log2(Vector4I<T> x) =>
-            new Vector4I<T>(T.Log2(x.X), T.Log2(x.Y), T.Log2(x.Z), T.Log2(x.W));
-
         public static (Vector4I<T> Quotient, Vector4I<T> Remainder) DivRem(Vector4I<T> left, Vector4I<T> right)
         {
             var (qX, rX) = T.DivRem(left.X, right.X);
@@ -134,8 +31,5 @@ public static (Vector4I<T> Quotient, Vector4I<T> Remainder) DivRem(Vector4I<T> l
             var (qW, rW) = T.DivRem(left.W, right.W);
             return (new Vector4I<T>(qX, qY, qZ, qW), new Vector4I<T>(rX, rY, rZ, rW));
         }
-
-        public static Vector4I<T> PopCount(Vector4I<T> x) =>
-            new Vector4I<T>(T.PopCount(x.X), T.PopCount(x.Y), T.PopCount(x.Z), T.PopCount(x.W));
     }
 }
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
index 04eb7ca61c..b87494d968 100644
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ b/sources/Maths/Maths/Vector4I.gen.cs
@@ -54,22 +54,22 @@ public Vector4I(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4I<T> One => new(Scalar<T>.One);
+        public static Vector4I<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
         public static Vector4I<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4I<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector4I<T> UnitX => new(T.One, T.Zero, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4I<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
+        public static Vector4I<T> UnitY => new(T.Zero, T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4I<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
+        public static Vector4I<T> UnitZ => new(T.Zero, T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4I<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+        public static Vector4I<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
 
         /// <summary>Gets a vector with all bits set for each component.</summary>
         public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
@@ -379,44 +379,65 @@ static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        /// <param name="w">The W component.</param>
+        public void Deconstruct(out T x, out T y, out T z, out T w)
+        {
+            x = X;
+            y = Y;
+            z = Z;
+            w = W;
+        }
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4I{T}"/>.</summary>
+        public static implicit operator Vector4I<T>((T X, T Y, T Z, T W) v) =>
+            new(v.X, v.Y, v.Z, v.W);
+
+        /// <summary>Implicitly casts a <see cref="Vector4I{T}"/> to a <see cref="ValueTuple{T, T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z, T W)(Vector4I<T> v) =>
+            (v.X, v.Y, v.Z, v.W);
+
         public static Vector4I<T> operator +(Vector4I<T> vector) =>
             vector;
 
         public static Vector4I<T> operator -(Vector4I<T> vector) =>
-            new Vector4I<T>(-vector.X, -vector.Y, -vector.Z, -vector.W);
+            new(-vector.X, -vector.Y, -vector.Z, -vector.W);
 
         public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
+            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
 
         public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
+            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
 
         public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
+            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
 
         public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
+            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
 
         public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
+            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
 
         public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
+            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
 
         public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
+            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
 
         public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
+            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
 
         public static Vector4I<T> operator *(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
+            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
 
         public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
 
         public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
+            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
 
         public static Vector4I<T> operator ~(Vector4I<T> vector) =>
             new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
@@ -464,56 +485,136 @@ public static Vector4I<T> Reflect<T>(Vector4I<T> vector, Vector4I<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
-
-        public static Vector4I<TSelf> Log<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> newBase)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log(x.X, newBase.X), TSelf.Log(x.Y, newBase.Y), TSelf.Log(x.Z, newBase.Z), TSelf.Log(x.W, newBase.W));
-
-        public static Vector4I<TSelf> LogP1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z), TSelf.LogP1(x.W));
-
-        public static Vector4I<TSelf> Log2<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z), TSelf.Log2(x.W));
-
-        public static Vector4I<TSelf> Log2P1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z), TSelf.Log2P1(x.W));
-
-        public static Vector4I<TSelf> Log10<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z), TSelf.Log10(x.W));
-
-        public static Vector4I<TSelf> Log10P1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, ILogarithmicFunctions<TSelf> =>
-            new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z), TSelf.Log10P1(x.W));
-
-        public static Vector4I<TSelf> Exp<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z), TSelf.Exp(x.W));
-
-        public static Vector4I<TSelf> ExpM1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z), TSelf.ExpM1(x.W));
-
-        public static Vector4I<TSelf> Exp2<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z), TSelf.Exp2(x.W));
-
-        public static Vector4I<TSelf> Exp2M1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z), TSelf.Exp2M1(x.W));
-
-        public static Vector4I<TSelf> Exp10<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z), TSelf.Exp10(x.W));
-
-        public static Vector4I<TSelf> Exp10M1<TSelf>(this Vector4I<TSelf> x)
-            where TSelf : IBinaryInteger<TSelf>, IExponentialFunctions<TSelf> =>
-            new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z), TSelf.Exp10M1(x.W));
+        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4I<int> Sign<TSelf>(this Vector4I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z), TSelf.Sign(value.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> Max<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z), TSelf.Max(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> Max<TSelf>(this Vector4I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y), TSelf.Max(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MaxNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z), TSelf.MaxNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MaxNumber<TSelf>(this Vector4I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y), TSelf.MaxNumber(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> Min<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z), TSelf.Min(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> Min<TSelf>(this Vector4I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y), TSelf.Min(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MinNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z), TSelf.MinNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MinNumber<TSelf>(this Vector4I<TSelf> x, TSelf y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y), TSelf.MinNumber(x.W, y));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
+        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
+        public static Vector4I<TSelf> Clamp<TSelf>(this Vector4I<TSelf> value, Vector4I<TSelf> min, Vector4I<TSelf> max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z), TSelf.Clamp(value.W, min.W, max.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
+        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
+        public static Vector4I<TSelf> Clamp<TSelf>(this Vector4I<TSelf> value, TSelf min, TSelf max)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max), TSelf.Clamp(value.W, min, max));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
+        public static Vector4I<TSelf> CopySign<TSelf>(this Vector4I<TSelf> value, Vector4I<TSelf> sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z), TSelf.CopySign(value.W, sign.W));
+
+        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
+        public static Vector4I<TSelf> CopySign<TSelf>(this Vector4I<TSelf> value, TSelf sign)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign), TSelf.CopySign(value.W, sign));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4I<TSelf> Abs<TSelf>(this Vector4I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z), TSelf.Abs(value.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MaxMagnitude<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z), TSelf.MaxMagnitude(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z), TSelf.MaxMagnitudeNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MinMagnitude<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z), TSelf.MinMagnitude(x.W, y.W));
+
+        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
+        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
+        public static Vector4I<TSelf> MinMagnitudeNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z), TSelf.MinMagnitudeNumber(x.W, y.W));
+
+        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4I<TSelf> Log2<TSelf>(this Vector4I<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.Log2(value.X), TSelf.Log2(value.Y), TSelf.Log2(value.Z), TSelf.Log2(value.W));
     }
 }

From 070c6f57e06d066169e8cf2701652febde62f44e Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Mon, 30 Jun 2025 16:56:01 -0700
Subject: [PATCH 35/52] Replace generated I/F types with D types.

---
 sources/Maths/Maths/Box3D.cs                  |   5 +-
 sources/Maths/Maths/Legacy/Vector2D.Ops.cs    | 288 --------
 sources/Maths/Maths/Legacy/Vector2D.cs        | 356 ----------
 sources/Maths/Maths/Legacy/Vector3D.Ops.cs    | 299 ---------
 sources/Maths/Maths/Legacy/Vector3D.cs        | 383 -----------
 sources/Maths/Maths/Legacy/Vector4D.Ops.cs    | 357 ----------
 sources/Maths/Maths/Legacy/Vector4D.cs        | 417 ------------
 .../{Matrix2x2F.gen.cs => Matrix2X2.gen.cs}   |  40 +-
 .../{Matrix2x3F.gen.cs => Matrix2X3.gen.cs}   |  40 +-
 .../{Matrix2x4F.gen.cs => Matrix2X4.gen.cs}   |  42 +-
 sources/Maths/Maths/Matrix2x2I.gen.cs         | 122 ----
 sources/Maths/Maths/Matrix2x3I.gen.cs         | 134 ----
 sources/Maths/Maths/Matrix2x4I.gen.cs         | 152 -----
 .../{Matrix3x2F.gen.cs => Matrix3X2.gen.cs}   |  42 +-
 .../{Matrix3x3F.gen.cs => Matrix3X3.gen.cs}   |  46 +-
 .../{Matrix3x4F.gen.cs => Matrix3X4.gen.cs}   |  46 +-
 sources/Maths/Maths/Matrix3x2I.gen.cs         | 144 ----
 sources/Maths/Maths/Matrix3x3I.gen.cs         | 171 -----
 sources/Maths/Maths/Matrix3x4I.gen.cs         | 187 ------
 .../{Matrix4x2F.gen.cs => Matrix4X2.gen.cs}   |  46 +-
 .../{Matrix4x3F.gen.cs => Matrix4X3.gen.cs}   |  48 +-
 sources/Maths/Maths/Matrix4x2I.gen.cs         | 173 -----
 sources/Maths/Maths/Matrix4x3I.gen.cs         | 198 ------
 sources/Maths/Maths/Matrix4x4F.gen.cs         | 240 -------
 sources/Maths/Maths/Matrix4x4I.gen.cs         | 231 -------
 .../{Matrix5x4F.gen.cs => Matrix5X4.gen.cs}   |  42 +-
 sources/Maths/Maths/Matrix5x4I.gen.cs         | 206 ------
 sources/Maths/Maths/Vector2D.cs               |  78 +++
 .../{Vector2F.gen.cs => Vector2D.gen.cs}      | 429 ++++++------
 sources/Maths/Maths/Vector2F.cs               |  67 --
 sources/Maths/Maths/Vector2I.cs               |  40 --
 sources/Maths/Maths/Vector2I.gen.cs           | 542 ---------------
 .../Maths/Maths/{Vector3I.cs => Vector3D.cs}  |  24 +-
 .../{Vector3F.gen.cs => Vector3D.gen.cs}      | 435 ++++++------
 sources/Maths/Maths/Vector3I.gen.cs           | 581 ----------------
 .../Maths/Maths/{Vector4I.cs => Vector4D.cs}  |  16 +-
 .../{Vector4F.gen.cs => Vector4D.gen.cs}      | 441 +++++++------
 sources/Maths/Maths/Vector4I.gen.cs           | 620 ------------------
 38 files changed, 966 insertions(+), 6762 deletions(-)
 delete mode 100644 sources/Maths/Maths/Legacy/Vector2D.Ops.cs
 delete mode 100644 sources/Maths/Maths/Legacy/Vector2D.cs
 delete mode 100644 sources/Maths/Maths/Legacy/Vector3D.Ops.cs
 delete mode 100644 sources/Maths/Maths/Legacy/Vector3D.cs
 delete mode 100644 sources/Maths/Maths/Legacy/Vector4D.Ops.cs
 delete mode 100644 sources/Maths/Maths/Legacy/Vector4D.cs
 rename sources/Maths/Maths/{Matrix2x2F.gen.cs => Matrix2X2.gen.cs} (77%)
 rename sources/Maths/Maths/{Matrix2x3F.gen.cs => Matrix2X3.gen.cs} (79%)
 rename sources/Maths/Maths/{Matrix2x4F.gen.cs => Matrix2X4.gen.cs} (81%)
 delete mode 100644 sources/Maths/Maths/Matrix2x2I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix2x3I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix2x4I.gen.cs
 rename sources/Maths/Maths/{Matrix3x2F.gen.cs => Matrix3X2.gen.cs} (79%)
 rename sources/Maths/Maths/{Matrix3x3F.gen.cs => Matrix3X3.gen.cs} (81%)
 rename sources/Maths/Maths/{Matrix3x4F.gen.cs => Matrix3X4.gen.cs} (83%)
 delete mode 100644 sources/Maths/Maths/Matrix3x2I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix3x3I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix3x4I.gen.cs
 rename sources/Maths/Maths/{Matrix4x2F.gen.cs => Matrix4X2.gen.cs} (81%)
 rename sources/Maths/Maths/{Matrix4x3F.gen.cs => Matrix4X3.gen.cs} (83%)
 delete mode 100644 sources/Maths/Maths/Matrix4x2I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix4x3I.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix4x4F.gen.cs
 delete mode 100644 sources/Maths/Maths/Matrix4x4I.gen.cs
 rename sources/Maths/Maths/{Matrix5x4F.gen.cs => Matrix5X4.gen.cs} (86%)
 delete mode 100644 sources/Maths/Maths/Matrix5x4I.gen.cs
 create mode 100644 sources/Maths/Maths/Vector2D.cs
 rename sources/Maths/Maths/{Vector2F.gen.cs => Vector2D.gen.cs} (73%)
 delete mode 100644 sources/Maths/Maths/Vector2F.cs
 delete mode 100644 sources/Maths/Maths/Vector2I.cs
 delete mode 100644 sources/Maths/Maths/Vector2I.gen.cs
 rename sources/Maths/Maths/{Vector3I.cs => Vector3D.cs} (69%)
 rename sources/Maths/Maths/{Vector3F.gen.cs => Vector3D.gen.cs} (75%)
 delete mode 100644 sources/Maths/Maths/Vector3I.gen.cs
 rename sources/Maths/Maths/{Vector4I.cs => Vector4D.cs} (69%)
 rename sources/Maths/Maths/{Vector4F.gen.cs => Vector4D.gen.cs} (76%)
 delete mode 100644 sources/Maths/Maths/Vector4I.gen.cs

diff --git a/sources/Maths/Maths/Box3D.cs b/sources/Maths/Maths/Box3D.cs
index 36c4ab815c..48812a2039 100644
--- a/sources/Maths/Maths/Box3D.cs
+++ b/sources/Maths/Maths/Box3D.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -157,7 +158,7 @@ public Box3D<T> GetScaled(Vector3D<T> scale, Vector3D<T> anchor)
         /// <param name="anchor">The anchor.</param>
         /// <returns>The calculated box.</returns>
         public Box3D<T> GetScaled<TScale>(Vector3D<TScale> scale, Vector3D<T> anchor)
-            where TScale : unmanaged, IFormattable, IEquatable<TScale>, IComparable<TScale>
+            where TScale : INumberBase<TScale>
         {
             var convertedAnchor = anchor.As<TScale>();
             var min = (scale * (Min.As<TScale>() - convertedAnchor)) + convertedAnchor;
@@ -226,4 +227,4 @@ public Box3D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquat
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs b/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
deleted file mode 100644
index df68ebed3b..0000000000
--- a/sources/Maths/Maths/Legacy/Vector2D.Ops.cs
+++ /dev/null
@@ -1,288 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Vector2D{T}"/>
-    /// </summary>
-    public static class Vector2D
-    {
-        /// <summary>Returns a vector whose elements are the absolute values of each of the specified vector's elements.</summary>
-        /// <param name="value">A vector.</param>
-        /// <returns>The absolute value vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Abs<T>(Vector2D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Abs(value.X), Scalar.Abs(value.Y));
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first vector to add.</param>
-        /// <param name="right">The second vector to add.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Add<T>(Vector2D<T> left, Vector2D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Add(left.X, right.X), Scalar.Add(left.Y, right.Y));
-
-        /// <summary>Restricts a vector between a minimum and a maximum value.</summary>
-        /// <param name="value1">The vector to restrict.</param>
-        /// <param name="min">The minimum value.</param>
-        /// <param name="max">The maximum value.</param>
-        /// <returns>The restricted vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Clamp<T>(Vector2D<T> value1, Vector2D<T> min, Vector2D<T> max)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            // We must follow HLSL behavior in the case user specified min value is bigger than max value.
-            => Min(Max(value1, min), max);
-
-        /// <summary>Computes the Euclidean distance between the two given points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Distance<T>(Vector2D<T> value1, Vector2D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Sqrt(DistanceSquared(value1, value2));
-
-        /// <summary>Returns the Euclidean distance squared between two specified points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance squared.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T DistanceSquared<T>(Vector2D<T> value1, Vector2D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            var difference = value1 - value2;
-            return Dot(difference, difference);
-        }
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first vector.</param>
-        /// <param name="right">The second vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Divide<T>(Vector2D<T> left, Vector2D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Divide(left.X, right.X), Scalar.Divide(left.Y, right.Y));
-
-        /// <summary>Divides the specified vector by a specified scalar value.</summary>
-        /// <param name="left">The vector.</param>
-        /// <param name="divisor">The scalar value.</param>
-        /// <returns>The vector that results from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Divide<T>(Vector2D<T> left, T divisor)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Divide(left.X, divisor), Scalar.Divide(left.Y, divisor));
-
-        /// <summary>Returns the dot product of two vectors.</summary>
-        /// <param name="value1">The first vector.</param>
-        /// <param name="value2">The second vector.</param>
-        /// <returns>The dot product.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Dot<T>(Vector2D<T> value1, Vector2D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Add(Scalar.Multiply(value1.X, value2.X), Scalar.Multiply(value1.Y, value2.Y));
-
-        /// <summary>Linearly interpolates between two vectors based on the given weighting.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <param name="amount">Value between 0 and 1 indicating the weight of the second source vector.</param>
-        /// <returns>The interpolated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Lerp<T>(Vector2D<T> value1, Vector2D<T> value2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => (value1 * Scalar.Subtract(Scalar<T>.One, amount)) + (value2 * amount);
-
-        /// <summary>Returns a vector whose elements are the maximum of each of the pairs of elements in the two source vectors</summary>
-        /// <param name="value1">The first source vector</param>
-        /// <param name="value2">The second source vector</param>
-        /// <returns>The maximized vector</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Max<T>(Vector2D<T> value1, Vector2D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Max(value1.X, value2.X), Scalar.Max(value1.Y, value2.Y));
-
-        /// <summary>Returns a vector whose elements are the minimum of each of the pairs of elements in the two source vectors.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <returns>The minimized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Min<T>(Vector2D<T> value1, Vector2D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Min(value1.X, value2.X), Scalar.Min(value1.Y, value2.Y));
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector2D<T> left, Vector2D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Multiply(left.X, right.X), Scalar.Multiply(left.Y, right.Y));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector2D<T> left, T right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Multiply(left.X, right), Scalar.Multiply(left.Y, right));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(T left, Vector2D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Multiply(left, right.X), Scalar.Multiply(left, right.Y));
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Negate<T>(Vector2D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => -value;
-
-        /// <summary>Returns a vector with the same direction as the given vector, but with a length of 1.</summary>
-        /// <param name="value">The vector to normalize.</param>
-        /// <returns>The normalized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Normalize<T>(Vector2D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value / value.Length;
-
-        /// <summary>Returns the reflection of a vector off a surface that has the specified normal.</summary>
-        /// <param name="vector">The source vector.</param>
-        /// <param name="normal">The normal of the surface being reflected off.</param>
-        /// <returns>The reflected vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Reflect<T>(Vector2D<T> vector, Vector2D<T> normal)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => vector - Scalar.Multiply(Scalar<T>.Two, Dot(vector, normal)) * normal;
-
-        /// <summary>Returns a vector whose elements are the square root of each of the source vector's elements.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The square root vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> SquareRoot<T>(Vector2D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Sqrt(value.X), Scalar.Sqrt(value.Y));
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Subtract<T>(Vector2D<T> left, Vector2D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left - right;
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="position">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> Transform<T>(Vector2D<T> position, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M11), Scalar.Multiply(position.Y, matrix.M21)), matrix.M41),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M12), Scalar.Multiply(position.Y, matrix.M22)), matrix.M42)
-            );
-        }
-
-        /// <summary>Transforms a vector normal by the given matrix.</summary>
-        /// <param name="normal">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> TransformNormal<T>(Vector2D<T> normal, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Multiply(normal.X, matrix.M11), Scalar.Multiply(normal.Y, matrix.M21)),
-                Scalar.Add(Scalar.Multiply(normal.X, matrix.M12), Scalar.Multiply(normal.Y, matrix.M22)));
-        }
-
-        /// <summary>Transforms a vector by the given Quaternion rotation value.</summary>
-        /// <param name="value">The source vector to be rotated.</param>
-        /// <param name="rotation">The rotation to apply.</param>
-        /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> Transform<T>(Vector2D<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            T x2 = Scalar.Add(rotation.X, rotation.X);
-            T y2 = Scalar.Add(rotation.Y, rotation.Y);
-            T z2 = Scalar.Add(rotation.Z, rotation.Z);
-
-            T wz2 = Scalar.Multiply(rotation.W, z2);
-            T xx2 = Scalar.Multiply(rotation.X, x2);
-            T xy2 = Scalar.Multiply(rotation.X, y2);
-            T yy2 = Scalar.Multiply(rotation.Y, y2);
-            T zz2 = Scalar.Multiply(rotation.Z, z2);
-
-            return new(
-                Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, yy2), zz2)), Scalar.Multiply(value.Y, Scalar.Subtract(xy2, wz2))),
-                Scalar.Add(Scalar.Multiply(value.X, Scalar.Add(xy2, wz2)), Scalar.Multiply(value.Y, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), zz2)))
-            );
-        }
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="position">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> Transform<T>(Vector2D<T> position, Matrix3X2<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M11), Scalar.Multiply(position.Y, matrix.M21)), matrix.M31),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M12), Scalar.Multiply(position.Y, matrix.M22)), matrix.M32)
-            );
-        }
-
-        /// <summary>Transforms a vector normal by the given matrix.</summary>
-        /// <param name="normal">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        public static Vector2D<T> TransformNormal<T>(Vector2D<T> normal, Matrix3X2<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Multiply(normal.X, matrix.M11), Scalar.Multiply(normal.Y, matrix.M21)),
-                Scalar.Add(Scalar.Multiply(normal.X, matrix.M12), Scalar.Multiply(normal.Y, matrix.M22))
-            );
-        }
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector2D<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector2D<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-    }
-}
diff --git a/sources/Maths/Maths/Legacy/Vector2D.cs b/sources/Maths/Maths/Legacy/Vector2D.cs
deleted file mode 100644
index cb5b5fabdb..0000000000
--- a/sources/Maths/Maths/Legacy/Vector2D.cs
+++ /dev/null
@@ -1,356 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Globalization;
-using System.Runtime.CompilerServices;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>A structure encapsulating two values and provides hardware accelerated methods.</summary>
-    [Serializable]
-    [DataContract]
-    public struct Vector2D<T>
-        : IEquatable<Vector2D<T>>, IFormattable
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        [DataMember]
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        [DataMember]
-        public T Y;
-
-        /// <summary>Creates a new <see cref="Vector2D{T}"/> object whose two elements have the same value.</summary>
-        /// <param name="value">The value to assign to both elements.</param>
-        public Vector2D(T value) => (X, Y) = (value, value);
-
-        /// <summary>Creates a vector whose elements have the specified values.</summary>
-        /// <param name="x">The value to assign to the <see cref="X"/> field.</param>
-        /// <param name="y">The value to assign to the <see cref="Y"/> field.</param>
-        public Vector2D(T x, T y) => (X, Y) = (x, y);
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2D<T> One => new(Scalar<T>.One);
-
-        /// <summary>Gets the vector (1,0).</summary>
-        public static Vector2D<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Gets the vector (0,1).</summary>
-        public static Vector2D<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2D<T> Zero => default;
-
-        /// <summary>
-        /// Indexer for the components of this vector.
-        /// </summary>
-        /// <param name="i">The component to select. Zero based.</param>
-        public T this[int i]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 1 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(i);
-                return Unsafe.Add(ref X, i);
-            }
-        }
-
-        /// <summary>Copies the elements of the vector to a specified array.</summary>
-        /// <param name="array">The destination array.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="array"> is <c>null</c></paramref></exception>
-        /// <exception cref="ArgumentException">The number of elements in the current instance is greater than in the array.</exception>
-        /// <exception cref="RankException"><paramref name="array"> is multidimensional.</paramref></exception>
-        /// <remarks><paramref name="array"></paramref> must have at least two elements. The method copies the vector's elements starting at index 0.</remarks>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array) => CopyTo(array, 0);
-
-        /// <summary>Copies the elements of the vector to a specified array starting at a specified index position.</summary>
-        /// <param name="array">The destination array.</param>
-        /// <param name="index">The index at which to copy the first element of the vector.</param>
-        /// <exception cref="ArgumentNullException"><paramref name="array"> is <c>null</c></paramref></exception>
-        /// <exception cref="ArgumentException">The number of elements in the current instance is greater than in the array.</exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"> is less then zero.</paramref></exception>
-        /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"> is greater then or equal to the array length.</paramref></exception>
-        /// <exception cref="RankException"><paramref name="array"> is multidimensional.</paramref></exception>
-        /// <remarks>array must have a sufficient number of elements to accommodate the two vector elements. In other words, elements index and index + 1 must already exist in array.</remarks>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array, int index)
-        {
-            if (array is null)
-            {
-                throw new NullReferenceException("Object reference not set to an instance of an object.");
-            }
-
-            if ((index < 0) || (index >= array.Length))
-            {
-                throw new ArgumentOutOfRangeException(nameof(index), "Specified argument was out of the range of valid values.");
-            }
-
-            if ((array.Length - index) < 2)
-            {
-                throw new ArgumentException("Value does not fall within the expected range.");
-            }
-
-            array[index] = X;
-            array[index + 1] = Y;
-        }
-
-        /// <summary>Returns a boolean indicating whether the given <see cref="Vector2D{T}"/> is equal to this <see cref="Vector2D{T}"/> instance.</summary>
-        /// <param name="other">The <see cref="Vector2D{T}"/> to compare this instance to.</param>
-        /// <returns>True if the other <see cref="Vector2D{T}"/> is equal to this instance; False otherwise.</returns>
-        public readonly bool Equals(Vector2D<T> other) => this == other;
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector2D{T}"/> instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this Vector2D; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj) => (obj is Vector2D<T> other) && Equals(other);
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode() => HashCode.Combine(X, Y);
-
-        /// <summary>Returns the length of the vector.</summary>
-        /// <value>The vector's length.</value>
-        public T Length
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Scalar.Sqrt(LengthSquared);
-        }
-
-        /// <summary>Returns the length of the vector squared. This operation is cheaper than Length().</summary>
-        /// <returns>The vector's length squared.</returns>
-        public readonly T LengthSquared
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Vector2D.Dot(this, this);
-        }
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator +(Vector2D<T> left, Vector2D<T> right)
-            => new(Scalar.Add(left.X, right.X), Scalar.Add(left.Y, right.Y));
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator /(Vector2D<T> left, Vector2D<T> right)
-            => new(Scalar.Divide(left.X, right.X), Scalar.Divide(left.Y, right.Y));
-
-        /// <summary>Divides the vector by the given scalar.</summary>
-        /// <param name="value1">The source vector.</param>
-        /// <param name="value2">The scalar value.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator /(Vector2D<T> value1, T value2)
-            => new(Scalar.Divide(value1.X, value2), Scalar.Divide(value1.Y, value2));
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are equal; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator ==(Vector2D<T> left, Vector2D<T> right)
-            => Scalar.Equal(left.X, right.X) && Scalar.Equal(left.Y, right.Y);
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are not equal; False if they are equal.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator !=(Vector2D<T> left, Vector2D<T> right) => !(left == right);
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator *(Vector2D<T> left, Vector2D<T> right)
-            => new(Scalar.Multiply(left.X, right.X), Scalar.Multiply(left.Y, right.Y));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator *(Vector2D<T> left, T right)
-            => new(Scalar.Multiply(left.X, right), Scalar.Multiply(left.Y, right));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator *(T left, Vector2D<T> right) => right * left;
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator -(Vector2D<T> left, Vector2D<T> right)
-            => new(Scalar.Subtract(left.X, right.X), Scalar.Subtract(left.Y, right.Y));
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> operator -(Vector2D<T> value) => Zero - value;
-
-        /// <summary>Returns a String representing this <see cref="Vector2D{T}"/> instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString() => ToString("G", CultureInfo.CurrentCulture);
-
-        /// <summary>Returns a String representing this <see cref="Vector2D{T}"/> instance, using the specified format to format individual elements.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format) => ToString(format, CultureInfo.CurrentCulture);
-
-        /// <summary>Returns a String representing this <see cref="Vector2D{T}"/> instance, using the specified format to format individual elements and the given IFormatProvider.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <param name="formatProvider">The format provider to use when formatting elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format, IFormatProvider? formatProvider)
-        {
-            StringBuilder sb = new();
-            string separator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
-            sb.Append('<');
-            sb.Append(X.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(Y.ToString(format, formatProvider));
-            sb.Append('>');
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Vector2D<Half>(Vector2D<T> from)
-            => new(Scalar.As<T, Half>(from.X), Scalar.As<T, Half>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Vector2D<float>(Vector2D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into <see cref="System.Numerics.Vector2"/>
-        /// </summary>
-        /// <param name="from">The source vector</param>
-        /// <returns>The <see cref="System.Numerics"/> vector</returns>
-        public static explicit operator System.Numerics.Vector2(Vector2D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y));
-        
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Vector2D<double>(Vector2D<T> from)
-            => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Vector2D<decimal>(Vector2D<T> from)
-            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Vector2D<sbyte>(Vector2D<T> from)
-            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Vector2D<byte>(Vector2D<T> from)
-            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Vector2D<ushort>(Vector2D<T> from)
-            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Vector2D<short>(Vector2D<T> from)
-            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Vector2D<uint>(Vector2D<T> from)
-            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Vector2D<int>(Vector2D<T> from)
-            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Vector2D<ulong>(Vector2D<T> from)
-            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y));
-
-        /// <summary>
-        /// Converts a <see cref="Vector2D{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Vector2D<long>(Vector2D<T> from)
-            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y));
-        
-        /// <summary>
-        /// Returns this vector casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted vector</returns>
-        public Vector2D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
-        {
-            return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y));
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs b/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
deleted file mode 100644
index 618c53b805..0000000000
--- a/sources/Maths/Maths/Legacy/Vector3D.Ops.cs
+++ /dev/null
@@ -1,299 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Vector3D{T}"/>
-    /// </summary>
-    public static class Vector3D
-    {
-
-        /// <summary>Returns a vector whose elements are the absolute values of each of the source vector's elements.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The absolute value vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Abs<T>(Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Abs(value.X), Scalar.Abs(value.Y), Scalar.Abs(value.Z));
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Add<T>(Vector3D<T> left, Vector3D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left + right;
-
-        /// <summary>Restricts a vector between a min and max value.</summary>
-        /// <param name="value1">The source vector.</param>
-        /// <param name="min">The minimum value.</param>
-        /// <param name="max">The maximum value.</param>
-        /// <returns>The restricted vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Clamp<T>(Vector3D<T> value1, Vector3D<T> min, Vector3D<T> max)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            // We must follow HLSL behavior in the case user specified min value is bigger than max value.
-            => Min(Max(value1, min), max);
-
-        /// <summary>Computes the cross product of two vectors.</summary>
-        /// <param name="vector1">The first vector.</param>
-        /// <param name="vector2">The second vector.</param>
-        /// <returns>The cross product.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Cross<T>(Vector3D<T> vector1, Vector3D<T> vector2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(
-                Scalar.Subtract(Scalar.Multiply(vector1.Y, vector2.Z),
-                    Scalar.Multiply(vector1.Z, vector2.Y)),
-                Scalar.Subtract(Scalar.Multiply(vector1.Z, vector2.X),
-                    Scalar.Multiply(vector1.X, vector2.Z)),
-                Scalar.Subtract(Scalar.Multiply(vector1.X, vector2.Y),
-                    Scalar.Multiply(vector1.Y, vector2.X)));
-
-        /// <summary>Returns the Euclidean distance between the two given points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Distance<T>(Vector3D<T> value1, Vector3D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Sqrt(DistanceSquared(value1, value2));
-
-        /// <summary>Returns the Euclidean distance squared between the two given points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance squared.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T DistanceSquared<T>(Vector3D<T> value1, Vector3D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            var difference = value1 - value2;
-            return Dot(difference, difference);
-        }
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Divide<T>(Vector3D<T> left, Vector3D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left / right;
-
-        /// <summary>Divides the vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="divisor">The scalar value.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Divide<T>(Vector3D<T> left, T divisor)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left / divisor;
-
-        /// <summary>Returns the dot product of two vectors.</summary>
-        /// <param name="vector1">The first vector.</param>
-        /// <param name="vector2">The second vector.</param>
-        /// <returns>The dot product.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Dot<T>(Vector3D<T> vector1, Vector3D<T> vector2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Add(
-                Scalar.Add(Scalar.Multiply(vector1.X, vector2.X),
-                    Scalar.Multiply(vector1.Y, vector2.Y)),
-                Scalar.Multiply(vector1.Z, vector2.Z));
-
-        /// <summary>Linearly interpolates between two vectors based on the given weighting.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <param name="amount">Value between 0 and 1 indicating the weight of the second source vector.</param>
-        /// <returns>The interpolated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Lerp<T>(Vector3D<T> value1, Vector3D<T> value2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return (value1 * Scalar.Subtract(Scalar<T>.One, amount) + (value2 * amount));
-        }
-
-        /// <summary>Returns a vector whose elements are the maximum of each of the pairs of elements in the two source vectors.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <returns>The maximized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Max<T>(Vector3D<T> value1, Vector3D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Max(value1.X, value2.X), Scalar.Max(value1.Y, value2.Y),
-                Scalar.Max(value1.Z, value2.Z));
-
-        /// <summary>Returns a vector whose elements are the minimum of each of the pairs of elements in the two source vectors.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <returns>The minimized vector.</returns>
-        public static Vector3D<T> Min<T>(Vector3D<T> value1, Vector3D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Min(value1.X, value2.X), Scalar.Min(value1.Y, value2.Y),
-                Scalar.Min(value1.Z, value2.Z));
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector3D<T> left, Vector3D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector3D<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector3D<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector3D<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector3D<T> left, T right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(T left, Vector3D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Negate<T>(Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => -value;
-
-        /// <summary>Returns a vector with the same direction as the given vector, but with a length of 1.</summary>
-        /// <param name="value">The vector to normalize.</param>
-        /// <returns>The normalized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Normalize<T>(Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value / value.Length;
-
-        /// <summary>Returns the reflection of a vector off a surface that has the specified normal.</summary>
-        /// <param name="vector">The source vector.</param>
-        /// <param name="normal">The normal of the surface being reflected off.</param>
-        /// <returns>The reflected vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Reflect<T>(Vector3D<T> vector, Vector3D<T> normal)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => vector - (Scalar.Multiply(Scalar<T>.Two, Dot(vector, normal)) * normal);
-
-        /// <summary>Returns a vector whose elements are the square root of each of the source vector's elements.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The square root vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> SquareRoot<T>(Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Sqrt(value.X), Scalar.Sqrt(value.Y), Scalar.Sqrt(value.Z));
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Subtract<T>(Vector3D<T> left, Vector3D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left - right;
-
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="position">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix) // TODO: Matrix4X3
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M11), Scalar.Multiply(position.Y, matrix.M21)), Scalar.Multiply(position.Z, matrix.M31)), matrix.M41),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M12), Scalar.Multiply(position.Y, matrix.M22)), Scalar.Multiply(position.Z, matrix.M32)), matrix.M42),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M13), Scalar.Multiply(position.Y, matrix.M23)), Scalar.Multiply(position.Z, matrix.M33)), matrix.M43)
-            );
-        }
-
-        /// <summary>Transforms a vector by the given Quaternion rotation value.</summary>
-        /// <param name="value">The source vector to be rotated.</param>
-        /// <param name="rotation">The rotation to apply.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            T x2 = Scalar.Add(rotation.X, rotation.X);
-            T y2 = Scalar.Add(rotation.Y, rotation.Y);
-            T z2 = Scalar.Add(rotation.Z, rotation.Z);
-
-            T wx2 = Scalar.Multiply(rotation.W, x2);
-            T wy2 = Scalar.Multiply(rotation.W, y2);
-            T wz2 = Scalar.Multiply(rotation.W, z2);
-            T xx2 = Scalar.Multiply(rotation.X, x2);
-            T xy2 = Scalar.Multiply(rotation.X, y2);
-            T xz2 = Scalar.Multiply(rotation.X, z2);
-            T yy2 = Scalar.Multiply(rotation.Y, y2);
-            T yz2 = Scalar.Multiply(rotation.Y, z2);
-            T zz2 = Scalar.Multiply(rotation.Z, z2);
-
-            // TODO: Vectorize
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, yy2), zz2)), Scalar.Multiply(value.Y, Scalar.Subtract(xy2, wz2))), Scalar.Multiply(value.Z, Scalar.Add(xz2, wy2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Add(xy2, wz2)), Scalar.Multiply(value.Y, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), zz2))), Scalar.Multiply(value.Z, Scalar.Subtract(yz2, wx2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(xz2, wy2)), Scalar.Multiply(value.Y, Scalar.Add(yz2, wx2))), Scalar.Multiply(value.Z, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), yy2)))
-            );
-        }
-
-
-
-        /// <summary>Transforms a vector normal by the given matrix.</summary>
-        /// <param name="normal">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> TransformNormal<T>(Vector3D<T> normal, Matrix4X4<T> matrix) // TODO: Matrix3X3
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(normal.X, matrix.M11), Scalar.Multiply(normal.Y, matrix.M21)), Scalar.Multiply(normal.Z, matrix.M31)),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(normal.X, matrix.M12), Scalar.Multiply(normal.Y, matrix.M22)), Scalar.Multiply(normal.Z, matrix.M32)),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(normal.X, matrix.M13), Scalar.Multiply(normal.Y, matrix.M23)), Scalar.Multiply(normal.Z, matrix.M33))
-            );
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Legacy/Vector3D.cs b/sources/Maths/Maths/Legacy/Vector3D.cs
deleted file mode 100644
index 486057d3f7..0000000000
--- a/sources/Maths/Maths/Legacy/Vector3D.cs
+++ /dev/null
@@ -1,383 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Globalization;
-using System.Runtime.CompilerServices;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>A structure encapsulating three values and provides hardware accelerated methods.</summary>
-    [Serializable]
-    [DataContract]
-    public struct Vector3D<T>
-        : IEquatable<Vector3D<T>>, IFormattable
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        [DataMember]
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        [DataMember]
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        [DataMember]
-        public T Z;
-
-        /// <summary>Constructs a vector whose elements are all the single specified value.</summary>
-        /// <param name="value">The element to fill the vector with.</param>
-        public Vector3D(T value) => (X, Y, Z) = (value, value, value);
-
-        /// <summary>Constructs a <see cref="Vector3D{T}"/> from the given <see cref="Vector2D{T}"/> and a third value.</summary>
-        /// <param name="value">The Vector to extract X and Y components from.</param>
-        /// <param name="z">The Z component.</param>
-        public Vector3D(Vector2D<T> value, T z) => (X, Y, Z) = (value.X, value.Y, z);
-
-        /// <summary>Constructs a vector with the given individual elements.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        /// <param name="z">The Z component.</param>
-        public Vector3D(T x, T y, T z) => (X, Y, Z) = (x, y, z);
-
-        /// <summary>Returns the vector (0,0,0).</summary>
-        public static Vector3D<T> Zero => default;
-
-        /// <summary>Returns the vector (1,1,1).</summary>
-        public static Vector3D<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns the vector (1,0,0).</summary>
-        public static Vector3D<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Returns the vector (0,1,0).</summary>
-        public static Vector3D<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Returns the vector (0,0,1).</summary>
-        public static Vector3D<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>
-        /// Indexer for the components of this vector.
-        /// </summary>
-        /// <param name="i">The component to select. Zero based.</param>
-        public T this[int i]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 2 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(i);
-                return Unsafe.Add(ref X, i);
-            }
-        }
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator +(Vector3D<T> left, Vector3D<T> right)
-            => new(Scalar.Add(left.X, right.X), Scalar.Add(left.Y, right.Y), Scalar.Add(left.Z, right.Z));
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator /(Vector3D<T> left, Vector3D<T> right)
-            => new(Scalar.Divide(left.X, right.X), Scalar.Divide(left.Y, right.Y),
-                Scalar.Divide(left.Z, right.Z));
-
-        /// <summary>Divides the vector by the given scalar.</summary>
-        /// <param name="value1">The source vector.</param>
-        /// <param name="value2">The scalar value.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator /(Vector3D<T> value1, T value2)
-            => new(Scalar.Divide(value1.X, value2), Scalar.Divide(value1.Y, value2),
-                Scalar.Divide(value1.Z, value2));
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are equal; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator ==(Vector3D<T> left, Vector3D<T> right)
-            => Scalar.Equal(left.X, right.X)
-            && Scalar.Equal(left.Y, right.Y)
-            && Scalar.Equal(left.Z, right.Z);
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are not equal; False if they are equal.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator !=(Vector3D<T> left, Vector3D<T> right) => !(left == right);
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator *(Vector3D<T> left, Vector3D<T> right)
-            => new(Scalar.Multiply(left.X, right.X), Scalar.Multiply(left.Y, right.Y),
-                Scalar.Multiply(left.Z, right.Z));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator *(Vector3D<T> left, T right)
-            => new(Scalar.Multiply(left.X, right), Scalar.Multiply(left.Y, right),
-                Scalar.Multiply(left.Z, right));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator *(T left, Vector3D<T> right)
-            => right * left;
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator -(Vector3D<T> left, Vector3D<T> right)
-            => new(Scalar.Subtract(left.X, right.X), Scalar.Subtract(left.Y, right.Y),
-                Scalar.Subtract(left.Z, right.Z));
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> operator -(Vector3D<T> value)
-            => Zero - value;
-
-        /// <summary>Copies the contents of the vector into the given array.</summary>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array)
-            => CopyTo(array, 0);
-
-        /// <summary>Copies the contents of the vector into the given array, starting from index.</summary>
-        /// <exception cref="ArgumentNullException">If array is null.</exception>
-        /// <exception cref="RankException">If array is multidimensional.</exception>
-        /// <exception cref="ArgumentOutOfRangeException">If index is greater than end of the array or index is less than zero.</exception>
-        /// <exception cref="ArgumentException">If number of elements in source vector is greater than those available in destination array.</exception>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array, int index)
-        {
-            if (array is null)
-            {
-                throw new NullReferenceException("Object reference not set to an instance of an object.");
-            }
-
-            if ((index < 0) || (index >= array.Length))
-            {
-                throw new ArgumentOutOfRangeException(nameof(index), "Specified argument was out of the range of valid values.");
-            }
-
-            if ((array.Length - index) < 3)
-            {
-                throw new ArgumentException("Value does not fall within the expected range.");
-            }
-
-            array[index] = X;
-            array[index + 1] = Y;
-            array[index + 2] = Z;
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector3D{T}"/> instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this Vector3D; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-        {
-            return (obj is Vector3D<T> other) && Equals(other);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given <see cref="Vector3D{T}"/> is equal to this <see cref="Vector3D{T}"/> instance.</summary>
-        /// <param name="other">The <see cref="Vector3D{T}"/> to compare this instance to.</param>
-        /// <returns>True if the other <see cref="Vector3D{T}"/> is equal to this instance; False otherwise.</returns>
-        public readonly bool Equals(Vector3D<T> other)
-        {
-            return this == other;
-        }
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode()
-        {
-            return HashCode.Combine(X, Y, Z);
-        }
-
-        /// <summary>Returns the length of the vector.</summary>
-        /// <value>The vector's length.</value>
-        public T Length
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Scalar.Sqrt(LengthSquared);
-        }
-
-        /// <summary>Returns the length of the vector squared. This operation is cheaper than Length().</summary>
-        /// <value>The vector's length squared.</value>
-        public T LengthSquared
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Vector3D.Dot(this, this);
-        }
-
-        /// <summary>Returns a String representing this <see cref="Vector3D{T}"/> instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString() => ToString("G", CultureInfo.CurrentCulture);
-
-        /// <summary>Returns a String representing this <see cref="Vector3D{T}"/> instance, using the specified format to format individual elements.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format) => ToString(format, CultureInfo.CurrentCulture);
-
-        /// <summary>Returns a String representing this <see cref="Vector3D{T}"/> instance, using the specified format to format individual elements and the given IFormatProvider.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <param name="formatProvider">The format provider to use when formatting elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format, IFormatProvider? formatProvider)
-        {
-            StringBuilder sb = new();
-            string separator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
-            sb.Append('<');
-            sb.Append(X.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(Y.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(Z.ToString(format, formatProvider));
-            sb.Append('>');
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Vector3D<Half>(Vector3D<T> from)
-            => new(Scalar.As<T, Half>(from.X), Scalar.As<T, Half>(from.Y), Scalar.As<T, Half>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Vector3D<float>(Vector3D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into <see cref="System.Numerics.Vector3"/>
-        /// </summary>
-        /// <param name="from">The source vector</param>
-        /// <returns>The <see cref="System.Numerics"/> vector</returns>
-        public static explicit operator System.Numerics.Vector3(Vector3D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z));
-        
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Vector3D<double>(Vector3D<T> from)
-            => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y), Scalar.As<T, double>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Vector3D<decimal>(Vector3D<T> from)
-            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y), Scalar.As<T, decimal>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Vector3D<sbyte>(Vector3D<T> from)
-            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y), Scalar.As<T, sbyte>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Vector3D<byte>(Vector3D<T> from)
-            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y), Scalar.As<T, byte>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Vector3D<ushort>(Vector3D<T> from)
-            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y), Scalar.As<T, ushort>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Vector3D<short>(Vector3D<T> from)
-            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y), Scalar.As<T, short>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Vector3D<uint>(Vector3D<T> from)
-            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y), Scalar.As<T, uint>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Vector3D<int>(Vector3D<T> from)
-            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y), Scalar.As<T, int>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Vector3D<ulong>(Vector3D<T> from)
-            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y), Scalar.As<T, ulong>(from.Z));
-
-        /// <summary>
-        /// Converts a <see cref="Vector3D{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Vector3D<long>(Vector3D<T> from)
-            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y), Scalar.As<T, long>(from.Z));
-        
-        /// <summary>
-        /// Returns this vector casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted vector</returns>
-        public Vector3D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
-        {
-            return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z));
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs b/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
deleted file mode 100644
index b86726fc19..0000000000
--- a/sources/Maths/Maths/Legacy/Vector4D.Ops.cs
+++ /dev/null
@@ -1,357 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Vector4D"/>
-    /// </summary>
-    public static class Vector4D
-    {
-        /// <summary>Returns a vector whose elements are the absolute values of each of the source vector's elements.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The absolute value vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Abs<T>(Vector4D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(
-                Scalar.Abs(value.X),
-                Scalar.Abs(value.Y),
-                Scalar.Abs(value.Z),
-                Scalar.Abs(value.W)
-            );
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Add<T>(Vector4D<T> left, Vector4D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left + right;
-
-        /// <summary>Restricts a vector between a min and max value.</summary>
-        /// <param name="value1">The source vector.</param>
-        /// <param name="min">The minimum value.</param>
-        /// <param name="max">The maximum value.</param>
-        /// <returns>The restricted vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Clamp<T>(Vector4D<T> value1, Vector4D<T> min, Vector4D<T> max)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            // We must follow HLSL behavior in the case user specified min value is bigger than max value.
-            => Min(Max(value1, min), max);
-
-        /// <summary>Returns the Euclidean distance between the two given points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Distance<T>(Vector4D<T> value1, Vector4D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Sqrt(DistanceSquared(value1, value2));
-
-        /// <summary>Returns the Euclidean distance squared between the two given points.</summary>
-        /// <param name="value1">The first point.</param>
-        /// <param name="value2">The second point.</param>
-        /// <returns>The distance squared.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T DistanceSquared<T>(Vector4D<T> value1, Vector4D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            var difference = value1 - value2;
-            return Dot(difference, difference);
-        }
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Divide<T>(Vector4D<T> left, Vector4D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left / right;
-
-        /// <summary>Divides the vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="divisor">The scalar value.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Divide<T>(Vector4D<T> left, T divisor)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left / divisor;
-
-        /// <summary>Returns the dot product of two vectors.</summary>
-        /// <param name="vector1">The first vector.</param>
-        /// <param name="vector2">The second vector.</param>
-        /// <returns>The dot product.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static T Dot<T>(Vector4D<T> vector1, Vector4D<T> vector2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => Scalar.Add(
-                Scalar.Add(
-                    Scalar.Add(Scalar.Multiply(vector1.X, vector2.X),
-                        Scalar.Multiply(vector1.Y, vector2.Y)), Scalar.Multiply(vector1.Z, vector2.Z)),
-                Scalar.Multiply(vector1.W, vector2.W));
-
-        /// <summary>Linearly interpolates between two vectors based on the given weighting.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <param name="amount">Value between 0 and 1 indicating the weight of the second source vector.</param>
-        /// <returns>The interpolated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Lerp<T>(Vector4D<T> value1, Vector4D<T> value2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => (value1 * Scalar.Subtract(Scalar<T>.One, amount)) + (value2 * amount);
-
-        /// <summary>Returns a vector whose elements are the maximum of each of the pairs of elements in the two source vectors.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <returns>The maximized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Max<T>(Vector4D<T> value1, Vector4D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Max(value1.X, value2.X), Scalar.Max(value1.Y, value2.Y),
-                Scalar.Max(value1.Z, value2.Z), Scalar.Max(value1.W, value2.W));
-
-        /// <summary>Returns a vector whose elements are the minimum of each of the pairs of elements in the two source vectors.</summary>
-        /// <param name="value1">The first source vector.</param>
-        /// <param name="value2">The second source vector.</param>
-        /// <returns>The minimized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Min<T>(Vector4D<T> value1, Vector4D<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => new(Scalar.Min(value1.X, value2.X), Scalar.Min(value1.Y, value2.Y),
-                Scalar.Min(value1.Z, value2.Z), Scalar.Min(value1.W, value2.W));
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector4D<T> left, Vector4D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector4D<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector4D<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector4D<T> left, T right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(T left, Vector4D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left * right;
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Negate<T>(Vector4D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => -value;
-
-        /// <summary>Returns a vector with the same direction as the given vector, but with a length of 1.</summary>
-        /// <param name="vector">The vector to normalize.</param>
-        /// <returns>The normalized vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Normalize<T>(Vector4D<T> vector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => vector / vector.Length;
-
-        /// <summary>Returns a vector whose elements are the square root of each of the source vector's elements.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The square root vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> SquareRoot<T>(Vector4D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(Scalar.Sqrt(value.X), Scalar.Sqrt(value.Y), Scalar.Sqrt(value.Z),
-                Scalar.Sqrt(value.W));
-        }
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Subtract<T>(Vector4D<T> left, Vector4D<T> right)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-            => left - right;
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="position">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector2D<T> position, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M11), Scalar.Multiply(position.Y, matrix.M21)), matrix.M41),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M12), Scalar.Multiply(position.Y, matrix.M22)), matrix.M42),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M13), Scalar.Multiply(position.Y, matrix.M23)), matrix.M43),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M14), Scalar.Multiply(position.Y, matrix.M24)), matrix.M44)
-            );
-        }
-
-        /// <summary>Transforms a vector by the given Quaternion rotation value.</summary>
-        /// <param name="value">The source vector to be rotated.</param>
-        /// <param name="rotation">The rotation to apply.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector2D<T> value, Silk.NET.Maths.Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            T x2 = Scalar.Add(rotation.X, rotation.X);
-            T y2 = Scalar.Add(rotation.Y, rotation.Y);
-            T z2 = Scalar.Add(rotation.Z, rotation.Z);
-
-            T wx2 = Scalar.Multiply(rotation.W, x2);
-            T wy2 = Scalar.Multiply(rotation.W, y2);
-            T wz2 = Scalar.Multiply(rotation.W, z2);
-            T xx2 = Scalar.Multiply(rotation.X, x2);
-            T xy2 = Scalar.Multiply(rotation.X, y2);
-            T xz2 = Scalar.Multiply(rotation.X, z2);
-            T yy2 = Scalar.Multiply(rotation.Y, y2);
-            T yz2 = Scalar.Multiply(rotation.Y, z2);
-            T zz2 = Scalar.Multiply(rotation.Z, z2);
-
-            return new(
-                Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, yy2), zz2)), Scalar.Multiply(value.Y, Scalar.Subtract(xy2, wz2))),
-                Scalar.Add(Scalar.Multiply(value.X, Scalar.Add(xy2, wz2)), Scalar.Multiply(value.Y, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), zz2))),
-                Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(xz2, wy2)), Scalar.Multiply(value.Y, Scalar.Add(yz2, wx2))),
-                Scalar<T>.One
-            );
-        }
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="position">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector3D<T> position, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M11), Scalar.Multiply(position.Y, matrix.M21)), Scalar.Multiply(position.Z, matrix.M31)), matrix.M41),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M12), Scalar.Multiply(position.Y, matrix.M22)), Scalar.Multiply(position.Z, matrix.M32)), matrix.M42),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M13), Scalar.Multiply(position.Y, matrix.M23)), Scalar.Multiply(position.Z, matrix.M33)), matrix.M43),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(position.X, matrix.M14), Scalar.Multiply(position.Y, matrix.M24)), Scalar.Multiply(position.Z, matrix.M34)), matrix.M44)
-            );
-        }
-
-        /// <summary>Transforms a vector by the given Quaternion rotation value.</summary>
-        /// <param name="value">The source vector to be rotated.</param>
-        /// <param name="rotation">The rotation to apply.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector3D<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            T x2 = Scalar.Add(rotation.X, rotation.X);
-            T y2 = Scalar.Add(rotation.Y, rotation.Y);
-            T z2 = Scalar.Add(rotation.Z, rotation.Z);
-
-            T wx2 = Scalar.Multiply(rotation.W, x2);
-            T wy2 = Scalar.Multiply(rotation.W, y2);
-            T wz2 = Scalar.Multiply(rotation.W, z2);
-            T xx2 = Scalar.Multiply(rotation.X, x2);
-            T xy2 = Scalar.Multiply(rotation.X, y2);
-            T xz2 = Scalar.Multiply(rotation.X, z2);
-            T yy2 = Scalar.Multiply(rotation.Y, y2);
-            T yz2 = Scalar.Multiply(rotation.Y, z2);
-            T zz2 = Scalar.Multiply(rotation.Z, z2);
-
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, yy2), zz2)), Scalar.Multiply(value.Y, Scalar.Subtract(xy2, wz2))), Scalar.Multiply(value.Z, Scalar.Add(xz2, wy2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Add(xy2, wz2)), Scalar.Multiply(value.Y, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), zz2))), Scalar.Multiply(value.Z, Scalar.Subtract(yz2, wx2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(xz2, wy2)), Scalar.Multiply(value.Y, Scalar.Add(yz2, wx2))), Scalar.Multiply(value.Z, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), yy2))),
-                Scalar<T>.One
-            );
-        }
-
-        /// <summary>Transforms a vector by the given matrix.</summary>
-        /// <param name="vector">The source vector.</param>
-        /// <param name="matrix">The transformation matrix.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector4D<T> vector, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(vector.X, matrix.M11), Scalar.Multiply(vector.Y, matrix.M21)), Scalar.Multiply(vector.Z, matrix.M31)), Scalar.Multiply(vector.W, matrix.M41)),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(vector.X, matrix.M12), Scalar.Multiply(vector.Y, matrix.M22)), Scalar.Multiply(vector.Z, matrix.M32)), Scalar.Multiply(vector.W, matrix.M42)),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(vector.X, matrix.M13), Scalar.Multiply(vector.Y, matrix.M23)), Scalar.Multiply(vector.Z, matrix.M33)), Scalar.Multiply(vector.W, matrix.M43)),
-                Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(vector.X, matrix.M14), Scalar.Multiply(vector.Y, matrix.M24)), Scalar.Multiply(vector.Z, matrix.M34)), Scalar.Multiply(vector.W, matrix.M44))
-            );
-        }
-
-        /// <summary>Transforms a vector by the given Quaternion rotation value.</summary>
-        /// <param name="value">The source vector to be rotated.</param>
-        /// <param name="rotation">The rotation to apply.</param>
-        /// <returns>The transformed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Transform<T>(Vector4D<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            T x2 = Scalar.Add(rotation.X, rotation.X);
-            T y2 = Scalar.Add(rotation.Y, rotation.Y);
-            T z2 = Scalar.Add(rotation.Z, rotation.Z);
-
-            T wx2 = Scalar.Multiply(rotation.W, x2);
-            T wy2 = Scalar.Multiply(rotation.W, y2);
-            T wz2 = Scalar.Multiply(rotation.W, z2);
-            T xx2 = Scalar.Multiply(rotation.X, x2);
-            T xy2 = Scalar.Multiply(rotation.X, y2);
-            T xz2 = Scalar.Multiply(rotation.X, z2);
-            T yy2 = Scalar.Multiply(rotation.Y, y2);
-            T yz2 = Scalar.Multiply(rotation.Y, z2);
-            T zz2 = Scalar.Multiply(rotation.Z, z2);
-
-            return new(
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, yy2), zz2)), Scalar.Multiply(value.Y, Scalar.Subtract(xy2, wz2))), Scalar.Multiply(value.Z, Scalar.Add(xz2, wy2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Add(xy2, wz2)), Scalar.Multiply(value.Y, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), zz2))), Scalar.Multiply(value.Z, Scalar.Subtract(yz2, wx2))),
-                Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, Scalar.Subtract(xz2, wy2)), Scalar.Multiply(value.Y, Scalar.Add(yz2, wx2))), Scalar.Multiply(value.Z, Scalar.Subtract(Scalar.Subtract(Scalar<T>.One, xx2), yy2))),
-                value.W
-            );
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Legacy/Vector4D.cs b/sources/Maths/Maths/Legacy/Vector4D.cs
deleted file mode 100644
index 3722ecde42..0000000000
--- a/sources/Maths/Maths/Legacy/Vector4D.cs
+++ /dev/null
@@ -1,417 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Globalization;
-using System.Runtime.CompilerServices;
-using System.Runtime.Serialization;
-using System.Text;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>A structure encapsulating four single precision floating point values and provides hardware accelerated methods.</summary>
-    [Serializable]
-    [DataContract]
-    public struct Vector4D<T>
-        : IEquatable<Vector4D<T>>, IFormattable
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        [DataMember]
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        [DataMember]
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        [DataMember]
-        public T Z;
-
-        /// <summary>The W component of the vector.</summary>
-        [DataMember]
-        public T W;
-
-        /// <summary>
-        /// Indexer for the components of this vector.
-        /// </summary>
-        /// <param name="i">The component to select. Zero based.</param>
-        public T this[int i]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 3 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(i);
-                return Unsafe.Add(ref X, i);
-            }
-        }
-
-        /// <summary>Constructs a vector whose elements are all the single specified value.</summary>
-        /// <param name="value">The element to fill the vector with.</param>
-        public Vector4D(T value) => (X, Y, Z, W) = (value, value, value, value);
-
-        /// <summary>Constructs a <see cref="Vector4D{T}"/> from the given <see cref="Vector2D{T}"/> and a Z and W component.</summary>
-        /// <param name="value">The vector to use as the X and Y components.</param>
-        /// <param name="z">The Z component.</param>
-        /// <param name="w">The W component.</param>
-        public Vector4D(Vector2D<T> value, T z, T w) => (X, Y, Z, W) = (value.X, value.Y, z, w);
-
-        /// <summary>Constructs a <see cref="Vector4D{T}"/> from the given <see cref="Vector3D{T}"/> and a W component.</summary>
-        /// <param name="value">The vector to use as the X, Y, and Z components.</param>
-        /// <param name="w">The W component.</param>
-        public Vector4D(Vector3D<T> value, T w) => (X, Y, Z, W) = (value.X, value.Y, value.Z, w);
-
-        /// <summary>Constructs a vector with the given individual elements.</summary>
-        /// <param name="w">W component.</param>
-        /// <param name="x">X component.</param>
-        /// <param name="y">Y component.</param>
-        /// <param name="z">Z component.</param>
-        public Vector4D(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
-
-        /// <summary>Returns the vector (0,0,0,0).</summary>
-        public static Vector4D<T> Zero => default;
-
-        /// <summary>Returns the vector (1,1,1,1).</summary>
-        public static Vector4D<T> One => new(Scalar<T>.One);
-
-        /// <summary>Returns the vector (1,0,0,0).</summary>
-        public static Vector4D<T> UnitX => new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Returns the vector (0,1,0,0).</summary>
-        public static Vector4D<T> UnitY => new(Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero);
-
-        /// <summary>Returns the vector (0,0,1,0).</summary>
-        public static Vector4D<T> UnitZ => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero);
-
-        /// <summary>Returns the vector (0,0,0,1).</summary>
-        public static Vector4D<T> UnitW => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
-        /// <summary>Adds two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The summed vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator +(Vector4D<T> left, Vector4D<T> right)
-            => new(Scalar.Add(left.X, right.X), Scalar.Add(left.Y, right.Y), Scalar.Add(left.Z, right.Z),
-                Scalar.Add(left.W, right.W));
-
-        /// <summary>Divides the first vector by the second.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The vector resulting from the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator /(Vector4D<T> left, Vector4D<T> right)
-            => new(Scalar.Divide(left.X, right.X), Scalar.Divide(left.Y, right.Y), Scalar.Divide(left.Z, right.Z),
-                Scalar.Divide(left.W, right.W));
-
-        /// <summary>Divides the vector by the given scalar.</summary>
-        /// <param name="value1">The source vector.</param>
-        /// <param name="value2">The scalar value.</param>
-        /// <returns>The result of the division.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator /(Vector4D<T> value1, T value2)
-            => new(Scalar.Divide(value1.X, value2), Scalar.Divide(value1.Y, value2),
-                Scalar.Divide(value1.Z, value2), Scalar.Divide(value1.W, value2));
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are equal; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator ==(Vector4D<T> left, Vector4D<T> right)
-            => Scalar.Equal(left.X, right.X)
-            && Scalar.Equal(left.Y, right.Y)
-            && Scalar.Equal(left.Z, right.Z)
-            && Scalar.Equal(left.W, right.W);
-
-        /// <summary>Returns a boolean indicating whether the two given vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns>True if the vectors are not equal; False if they are equal.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static bool operator !=(Vector4D<T> left, Vector4D<T> right)
-            => !(left == right);
-
-        /// <summary>Multiplies two vectors together.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The product vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator *(Vector4D<T> left, Vector4D<T> right)
-            => new(Scalar.Multiply(left.X, right.X), Scalar.Multiply(left.Y, right.Y),
-                Scalar.Multiply(left.Z, right.Z), Scalar.Multiply(left.W, right.W));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The source vector.</param>
-        /// <param name="right">The scalar value.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator *(Vector4D<T> left, T right)
-            => new(Scalar.Multiply(left.X, right), Scalar.Multiply(left.Y, right),
-                Scalar.Multiply(left.Z, right), Scalar.Multiply(left.W, right));
-
-        /// <summary>Multiplies a vector by the given scalar.</summary>
-        /// <param name="left">The scalar value.</param>
-        /// <param name="right">The source vector.</param>
-        /// <returns>The scaled vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator *(T left, Vector4D<T> right)
-            => right * left;
-
-        /// <summary>Subtracts the second vector from the first.</summary>
-        /// <param name="left">The first source vector.</param>
-        /// <param name="right">The second source vector.</param>
-        /// <returns>The difference vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator -(Vector4D<T> left, Vector4D<T> right)
-            => new(Scalar.Subtract(left.X, right.X), Scalar.Subtract(left.Y, right.Y),
-                Scalar.Subtract(left.Z, right.Z), Scalar.Subtract(left.W, right.W));
-
-        /// <summary>Negates a given vector.</summary>
-        /// <param name="value">The source vector.</param>
-        /// <returns>The negated vector.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> operator -(Vector4D<T> value) => Zero - value;
-
-        /// <summary>Copies the contents of the vector into the given array.</summary>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array)
-            => CopyTo(array, 0);
-
-        /// <summary>Copies the contents of the vector into the given array, starting from index.</summary>
-        /// <exception cref="ArgumentNullException">If array is null.</exception>
-        /// <exception cref="RankException">If array is multidimensional.</exception>
-        /// <exception cref="ArgumentOutOfRangeException">If index is greater than end of the array or index is less than zero.</exception>
-        /// <exception cref="ArgumentException">If number of elements in source vector is greater than those available in destination array.</exception>
-        [MethodImpl((MethodImplOptions) 768)]
-        public readonly void CopyTo(T[]? array, int index)
-        {
-            if (array is null)
-            {
-                throw new NullReferenceException("Object reference not set to an instance of an object.");
-            }
-
-            if ((index < 0) || (index >= array.Length))
-            {
-                throw new ArgumentOutOfRangeException(nameof(index), "Specified argument was out of the range of valid values.");
-            }
-
-            if ((array.Length - index) < 4)
-            {
-                throw new ArgumentException("Value does not fall within the expected range.");
-            }
-
-            array[index] = X;
-            array[index + 1] = Y;
-            array[index + 2] = Z;
-            array[index + 3] = W;
-        }
-
-        /// <summary>Returns a boolean indicating whether the given <see cref="Vector4D{T}"/> is equal to this <see cref="Vector4D{T}"/> instance.</summary>
-        /// <param name="other">The <see cref="Vector4D{T}"/> to compare this instance to.</param>
-        /// <returns>True if the other <see cref="Vector4D{T}"/> is equal to this instance; False otherwise.</returns>
-        public readonly bool Equals(Vector4D<T> other)
-            => this == other;
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Vector4D{T}"/> instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this Vector4D; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Vector4D<T> other) && Equals(other);
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode()
-            => HashCode.Combine(X, Y, Z, W);
-
-        /// <summary>Returns the length of the vector. This operation is cheaper than Length().</summary>
-        /// <value>The vector's length.</value>
-        public T Length
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Scalar.Sqrt(LengthSquared);
-        }
-
-        /// <summary>Returns the length of the vector squared.</summary>
-        /// <value>The vector's length squared.</value>
-        public T LengthSquared
-        {
-            [MethodImpl((MethodImplOptions) 768)]
-            get => Vector4D.Dot(this, this);
-        }
-
-        /// <summary>Returns a String representing this <see cref="Vector4D{T}"/> instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return ToString("G", CultureInfo.CurrentCulture);
-        }
-
-        /// <summary>Returns a String representing this <see cref="Vector4D{T}"/> instance, using the specified format to format individual elements.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format)
-        {
-            return ToString(format, CultureInfo.CurrentCulture);
-        }
-
-        /// <summary>Returns a String representing this <see cref="Vector4D{T}"/> instance, using the specified format to format individual elements
-        /// and the given IFormatProvider.</summary>
-        /// <param name="format">The format of individual elements.</param>
-        /// <param name="formatProvider">The format provider to use when formatting elements.</param>
-        /// <returns>The string representation.</returns>
-        public readonly string ToString(string? format, IFormatProvider? formatProvider)
-        {
-            StringBuilder sb = new();
-            string separator = NumberFormatInfo.GetInstance(formatProvider).NumberGroupSeparator;
-            sb.Append('<');
-            sb.Append(X.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(Y.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(Z.ToString(format, formatProvider));
-            sb.Append(separator);
-            sb.Append(' ');
-            sb.Append(W.ToString(format, formatProvider));
-            sb.Append('>');
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Vector4D<Half>(Vector4D<T> from)
-            => new(Scalar.As<T, Half>(from.X), Scalar.As<T, Half>(from.Y), Scalar.As<T, Half>(from.Z),
-                Scalar.As<T, Half>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Vector4D<float>(Vector4D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
-                Scalar.As<T, float>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D{T}"/> into <see cref="System.Numerics.Vector4"/>
-        /// </summary>
-        /// <param name="from">The source vector</param>
-        /// <returns>The <see cref="System.Numerics"/> vector</returns>
-        public static explicit operator System.Numerics.Vector4(Vector4D<T> from)
-            => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
-                Scalar.As<T, float>(from.W));
-        
-        /// <summary>
-        /// Converts a <see cref="Vector4D{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Vector4D<double>(Vector4D<T> from)
-            => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y), Scalar.As<T, double>(from.Z),
-                Scalar.As<T, double>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Vector4D<decimal>(Vector4D<T> from)
-            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y), Scalar.As<T, decimal>(from.Z),
-                Scalar.As<T, decimal>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Vector4D<sbyte>(Vector4D<T> from)
-            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y), Scalar.As<T, sbyte>(from.Z),
-                Scalar.As<T, sbyte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Vector4D<byte>(Vector4D<T> from)
-            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y), Scalar.As<T, byte>(from.Z),
-                Scalar.As<T, byte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Vector4D<ushort>(Vector4D<T> from)
-            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y), Scalar.As<T, ushort>(from.Z),
-                Scalar.As<T, ushort>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Vector4D<short>(Vector4D<T> from)
-            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y), Scalar.As<T, short>(from.Z),
-                Scalar.As<T, short>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Vector4D<uint>(Vector4D<T> from)
-            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y), Scalar.As<T, uint>(from.Z),
-                Scalar.As<T, uint>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Vector4D<int>(Vector4D<T> from)
-            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y), Scalar.As<T, int>(from.Z),
-                Scalar.As<T, int>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Vector4D<ulong>(Vector4D<T> from)
-            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y), Scalar.As<T, ulong>(from.Z),
-                Scalar.As<T, ulong>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Vector4D"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Vector4D<long>(Vector4D<T> from)
-            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y), Scalar.As<T, long>(from.Z),
-                Scalar.As<T, long>(from.W));
-        
-        /// <summary>
-        /// Returns this vector casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted vector</returns>
-        public Vector4D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
-        {
-            return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z), Scalar.As<T, TOther>(W));
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Matrix2x2F.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
similarity index 77%
rename from sources/Maths/Maths/Matrix2x2F.gen.cs
rename to sources/Maths/Maths/Matrix2X2.gen.cs
index 0d43a43ed1..fb351734b6 100644
--- a/sources/Maths/Maths/Matrix2x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -3,28 +3,28 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x2F<T> :
-        IEquatable<Matrix2x2F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix2X2<T> :
+        IEquatable<Matrix2X2<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The multiplicative identity matrix of size 2x2.</summary>
-        public static readonly Matrix2x2F<T> Identity = new(
+        public static readonly Matrix2X2<T> Identity = new(
             new(T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.MultiplicativeIdentity));
 
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row1;
+        public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row2;
+        public Vector2D<T> Row2;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix2x2F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix2X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix2x2F(Vector2F<T> row1, Vector2F<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X2(Vector2D<T> row1, Vector2D<T> row2) => (Row1, Row2) = (row1, row2);
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row]
+        public ref Vector2D<T> this[int row]
         {
             get
             {
@@ -60,16 +60,16 @@ public ref Vector2F<T> this[int row]
         public ref T M22 => ref Row2.Y;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x2F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix2X2<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix2x2F<T> other) => this == other;
+        public bool Equals(Matrix2X2<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x2F<T> Transpose() =>
+        public Matrix2X2<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22));
 
@@ -77,7 +77,7 @@ public Matrix2x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+        public static bool operator ==(Matrix2X2<T> left, Matrix2X2<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2;
 
@@ -85,13 +85,13 @@ public Matrix2x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x2F<T> left, Matrix2x2F<T> right) => !(left == right);
+        public static bool operator !=(Matrix2X2<T> left, Matrix2X2<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x2F<T> operator +(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+        public static Matrix2X2<T> operator +(Matrix2X2<T> left, Matrix2X2<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2);
 
@@ -99,14 +99,14 @@ public Matrix2x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x2F<T> operator -(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+        public static Matrix2X2<T> operator -(Matrix2X2<T> left, Matrix2X2<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix2x2F<T> operator -(Matrix2x2F<T> value) =>
+        public static Matrix2X2<T> operator -(Matrix2X2<T> value) =>
             new(-value.Row1,
                 -value.Row2);
 
@@ -114,14 +114,14 @@ public Matrix2x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x2F<T> left, Matrix2x2F<T> right) =>
+        public static Matrix2X2<T> operator *(Matrix2X2<T> left, Matrix2X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
     }
 
-    static partial class Matrix2x2F
+    public static partial class Matrix2X2
     {
-        public static Matrix2x2F<T> Lerp<T>(Matrix2x2F<T> value1, Matrix2x2F<T> value2, T amount)
+        public static Matrix2X2<T> Lerp<T>(Matrix2X2<T> value1, Matrix2X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)));
diff --git a/sources/Maths/Maths/Matrix2x3F.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
similarity index 79%
rename from sources/Maths/Maths/Matrix2x3F.gen.cs
rename to sources/Maths/Maths/Matrix2X3.gen.cs
index 9c946035c6..2039da3a7d 100644
--- a/sources/Maths/Maths/Matrix2x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -3,23 +3,23 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x3F<T> :
-        IEquatable<Matrix2x3F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix2X3<T> :
+        IEquatable<Matrix2X3<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row1;
+        public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row2;
+        public Vector3D<T> Row2;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix2x3F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix2X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix2x3F(Vector3F<T> row1, Vector3F<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X3(Vector3D<T> row1, Vector3D<T> row2) => (Row1, Row2) = (row1, row2);
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row]
+        public ref Vector3D<T> this[int row]
         {
             get
             {
@@ -63,16 +63,16 @@ public ref Vector3F<T> this[int row]
         public ref T M23 => ref Row2.Z;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x3F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix2X3<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix2x3F<T> other) => this == other;
+        public bool Equals(Matrix2X3<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x2F<T> Transpose() =>
+        public Matrix3X2<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
                 new(M13, M23));
@@ -81,7 +81,7 @@ public Matrix3x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+        public static bool operator ==(Matrix2X3<T> left, Matrix2X3<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2;
 
@@ -89,13 +89,13 @@ public Matrix3x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x3F<T> left, Matrix2x3F<T> right) => !(left == right);
+        public static bool operator !=(Matrix2X3<T> left, Matrix2X3<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x3F<T> operator +(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+        public static Matrix2X3<T> operator +(Matrix2X3<T> left, Matrix2X3<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2);
 
@@ -103,14 +103,14 @@ public Matrix3x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x3F<T> operator -(Matrix2x3F<T> left, Matrix2x3F<T> right) =>
+        public static Matrix2X3<T> operator -(Matrix2X3<T> left, Matrix2X3<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix2x3F<T> operator -(Matrix2x3F<T> value) =>
+        public static Matrix2X3<T> operator -(Matrix2X3<T> value) =>
             new(-value.Row1,
                 -value.Row2);
 
@@ -118,7 +118,7 @@ public Matrix3x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x2F<T> left, Matrix2x3F<T> right) =>
+        public static Matrix2X3<T> operator *(Matrix2X2<T> left, Matrix2X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
 
@@ -126,14 +126,14 @@ public Matrix3x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x3F<T> left, Matrix3x2F<T> right) =>
+        public static Matrix2X2<T> operator *(Matrix2X3<T> left, Matrix3X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
     }
 
-    static partial class Matrix2x3F
+    public static partial class Matrix2X3
     {
-        public static Matrix2x3F<T> Lerp<T>(Matrix2x3F<T> value1, Matrix2x3F<T> value2, T amount)
+        public static Matrix2X3<T> Lerp<T>(Matrix2X3<T> value1, Matrix2X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)));
diff --git a/sources/Maths/Maths/Matrix2x4F.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
similarity index 81%
rename from sources/Maths/Maths/Matrix2x4F.gen.cs
rename to sources/Maths/Maths/Matrix2X4.gen.cs
index b4d4f8c6f0..10496deda3 100644
--- a/sources/Maths/Maths/Matrix2x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -3,23 +3,23 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix2x4F<T> :
-        IEquatable<Matrix2x4F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix2X4<T> :
+        IEquatable<Matrix2X4<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row1;
+        public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row2;
+        public Vector4D<T> Row2;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix2x4F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix2X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix2x4F(Vector4F<T> row1, Vector4F<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X4(Vector4D<T> row1, Vector4D<T> row2) => (Row1, Row2) = (row1, row2);
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row]
+        public ref Vector4D<T> this[int row]
         {
             get
             {
@@ -71,16 +71,16 @@ public ref Vector4F<T> this[int row]
         public ref T M24 => ref Row2.W;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x4F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix2X4<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix2x4F<T> other) => this == other;
+        public bool Equals(Matrix2X4<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x2F<T> Transpose() =>
+        public Matrix4X2<T> Transpose() =>
             new(new(M11, M21),
                 new(M12, M22),
                 new(M13, M23),
@@ -90,7 +90,7 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+        public static bool operator ==(Matrix2X4<T> left, Matrix2X4<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2;
 
@@ -98,13 +98,13 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x4F<T> left, Matrix2x4F<T> right) => !(left == right);
+        public static bool operator !=(Matrix2X4<T> left, Matrix2X4<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix2x4F<T> operator +(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+        public static Matrix2X4<T> operator +(Matrix2X4<T> left, Matrix2X4<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2);
 
@@ -112,14 +112,14 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x4F<T> operator -(Matrix2x4F<T> left, Matrix2x4F<T> right) =>
+        public static Matrix2X4<T> operator -(Matrix2X4<T> left, Matrix2X4<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2);
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix2x4F<T> operator -(Matrix2x4F<T> value) =>
+        public static Matrix2X4<T> operator -(Matrix2X4<T> value) =>
             new(-value.Row1,
                 -value.Row2);
 
@@ -127,7 +127,7 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x2F<T> left, Matrix2x4F<T> right) =>
+        public static Matrix2X4<T> operator *(Matrix2X2<T> left, Matrix2X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
 
@@ -135,7 +135,7 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2F<T> operator *(Matrix2x4F<T> left, Matrix4x2F<T> right) =>
+        public static Matrix2X2<T> operator *(Matrix2X4<T> left, Matrix4X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
 
@@ -143,15 +143,15 @@ public Matrix4x2F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x2F<T> left, Matrix2x4F<T> right) =>
+        public static Matrix3X4<T> operator *(Matrix3X2<T> left, Matrix2X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 
-    static partial class Matrix2x4F
+    public static partial class Matrix2X4
     {
-        public static Matrix2x4F<T> Lerp<T>(Matrix2x4F<T> value1, Matrix2x4F<T> value2, T amount)
+        public static Matrix2X4<T> Lerp<T>(Matrix2X4<T> value1, Matrix2X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)));
diff --git a/sources/Maths/Maths/Matrix2x2I.gen.cs b/sources/Maths/Maths/Matrix2x2I.gen.cs
deleted file mode 100644
index 662608b49d..0000000000
--- a/sources/Maths/Maths/Matrix2x2I.gen.cs
+++ /dev/null
@@ -1,122 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix2x2I<T> :
-        IEquatable<Matrix2x2I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The multiplicative identity matrix of size 2x2.</summary>
-        public static readonly Matrix2x2I<T> Identity = new(
-            new(T.MultiplicativeIdentity, T.Zero),
-            new(T.Zero, T.MultiplicativeIdentity));
-
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row2;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix2x2I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix2x2I(Vector2I<T> row1, Vector2I<T> row2) => (Row1, Row2) = (row1, row2);
-
-        [UnscopedRef]
-        public ref Vector2I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x2I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix2x2I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x2I<T> Transpose() =>
-            new(new(M11, M21),
-                new(M12, M22));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x2I<T> left, Matrix2x2I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix2x2I<T> operator +(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x2I<T> operator -(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix2x2I<T> operator -(Matrix2x2I<T> value) =>
-            new(-value.Row1,
-                -value.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x2I<T> left, Matrix2x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix2x3I.gen.cs b/sources/Maths/Maths/Matrix2x3I.gen.cs
deleted file mode 100644
index 03431eaac6..0000000000
--- a/sources/Maths/Maths/Matrix2x3I.gen.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix2x3I<T> :
-        IEquatable<Matrix2x3I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row2;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix2x3I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix2x3I(Vector3I<T> row1, Vector3I<T> row2) => (Row1, Row2) = (row1, row2);
-
-        [UnscopedRef]
-        public ref Vector3I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x3I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix2x3I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x2I<T> Transpose() =>
-            new(new(M11, M21),
-                new(M12, M22),
-                new(M13, M23));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x3I<T> left, Matrix2x3I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix2x3I<T> operator +(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x3I<T> operator -(Matrix2x3I<T> left, Matrix2x3I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix2x3I<T> operator -(Matrix2x3I<T> value) =>
-            new(-value.Row1,
-                -value.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x2I<T> left, Matrix2x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x3I<T> left, Matrix3x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix2x4I.gen.cs b/sources/Maths/Maths/Matrix2x4I.gen.cs
deleted file mode 100644
index e116d0b528..0000000000
--- a/sources/Maths/Maths/Matrix2x4I.gen.cs
+++ /dev/null
@@ -1,152 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix2x4I<T> :
-        IEquatable<Matrix2x4I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row2;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix2x4I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix2x4I(Vector4I<T> row1, Vector4I<T> row2) => (Row1, Row2) = (row1, row2);
-
-        [UnscopedRef]
-        public ref Vector4I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M14 => ref Row1.W;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M24 => ref Row2.W;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix2x4I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix2x4I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x2I<T> Transpose() =>
-            new(new(M11, M21),
-                new(M12, M22),
-                new(M13, M23),
-                new(M14, M24));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix2x4I<T> left, Matrix2x4I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix2x4I<T> operator +(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix2x4I<T> operator -(Matrix2x4I<T> left, Matrix2x4I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix2x4I<T> operator -(Matrix2x4I<T> value) =>
-            new(-value.Row1,
-                -value.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x2I<T> left, Matrix2x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x2I<T> operator *(Matrix2x4I<T> left, Matrix4x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x2I<T> left, Matrix2x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix3x2F.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
similarity index 79%
rename from sources/Maths/Maths/Matrix3x2F.gen.cs
rename to sources/Maths/Maths/Matrix3X2.gen.cs
index fa7209a596..bde0ebf4e0 100644
--- a/sources/Maths/Maths/Matrix3x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -3,26 +3,26 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x2F<T> :
-        IEquatable<Matrix3x2F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix3X2<T> :
+        IEquatable<Matrix3X2<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row1;
+        public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row2;
+        public Vector2D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row3;
+        public Vector2D<T> Row3;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix3x2F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix3X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix3x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row]
+        public ref Vector2D<T> this[int row]
         {
             get
             {
@@ -68,16 +68,16 @@ public ref Vector2F<T> this[int row]
         public ref T M32 => ref Row3.Y;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x2F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix3X2<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix3x2F<T> other) => this == other;
+        public bool Equals(Matrix3X2<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x3F<T> Transpose() =>
+        public Matrix2X3<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32));
 
@@ -85,7 +85,7 @@ public Matrix2x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+        public static bool operator ==(Matrix3X2<T> left, Matrix3X2<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3;
@@ -94,13 +94,13 @@ public Matrix2x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x2F<T> left, Matrix3x2F<T> right) => !(left == right);
+        public static bool operator !=(Matrix3X2<T> left, Matrix3X2<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x2F<T> operator +(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+        public static Matrix3X2<T> operator +(Matrix3X2<T> left, Matrix3X2<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3);
@@ -109,7 +109,7 @@ public Matrix2x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x2F<T> operator -(Matrix3x2F<T> left, Matrix3x2F<T> right) =>
+        public static Matrix3X2<T> operator -(Matrix3X2<T> left, Matrix3X2<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
@@ -117,7 +117,7 @@ public Matrix2x3F<T> Transpose() =>
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix3x2F<T> operator -(Matrix3x2F<T> value) =>
+        public static Matrix3X2<T> operator -(Matrix3X2<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3);
@@ -126,7 +126,7 @@ public Matrix2x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x2F<T> left, Matrix2x2F<T> right) =>
+        public static Matrix3X2<T> operator *(Matrix3X2<T> left, Matrix2X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
@@ -135,15 +135,15 @@ public Matrix2x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x2F<T> left, Matrix2x3F<T> right) =>
+        public static Matrix3X3<T> operator *(Matrix3X2<T> left, Matrix2X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
     }
 
-    static partial class Matrix3x2F
+    public static partial class Matrix3X2
     {
-        public static Matrix3x2F<T> Lerp<T>(Matrix3x2F<T> value1, Matrix3x2F<T> value2, T amount)
+        public static Matrix3X2<T> Lerp<T>(Matrix3X2<T> value1, Matrix3X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
diff --git a/sources/Maths/Maths/Matrix3x3F.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
similarity index 81%
rename from sources/Maths/Maths/Matrix3x3F.gen.cs
rename to sources/Maths/Maths/Matrix3X3.gen.cs
index 2c94325eb2..df79a5c810 100644
--- a/sources/Maths/Maths/Matrix3x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -3,32 +3,32 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x3F<T> :
-        IEquatable<Matrix3x3F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix3X3<T> :
+        IEquatable<Matrix3X3<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The multiplicative identity matrix of size 3x3.</summary>
-        public static readonly Matrix3x3F<T> Identity = new(
+        public static readonly Matrix3X3<T> Identity = new(
             new(T.MultiplicativeIdentity, T.Zero, T.Zero),
             new(T.Zero, T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.Zero, T.MultiplicativeIdentity));
 
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row1;
+        public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row2;
+        public Vector3D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row3;
+        public Vector3D<T> Row3;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix3x3F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix3X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix3x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row]
+        public ref Vector3D<T> this[int row]
         {
             get
             {
@@ -86,16 +86,16 @@ public ref Vector3F<T> this[int row]
         public ref T M33 => ref Row3.Z;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x3F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix3X3<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix3x3F<T> other) => this == other;
+        public bool Equals(Matrix3X3<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x3F<T> Transpose() =>
+        public Matrix3X3<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
                 new(M13, M23, M33));
@@ -104,7 +104,7 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+        public static bool operator ==(Matrix3X3<T> left, Matrix3X3<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3;
@@ -113,13 +113,13 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x3F<T> left, Matrix3x3F<T> right) => !(left == right);
+        public static bool operator !=(Matrix3X3<T> left, Matrix3X3<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x3F<T> operator +(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+        public static Matrix3X3<T> operator +(Matrix3X3<T> left, Matrix3X3<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3);
@@ -128,7 +128,7 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x3F<T> operator -(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+        public static Matrix3X3<T> operator -(Matrix3X3<T> left, Matrix3X3<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
@@ -136,7 +136,7 @@ public Matrix3x3F<T> Transpose() =>
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix3x3F<T> operator -(Matrix3x3F<T> value) =>
+        public static Matrix3X3<T> operator -(Matrix3X3<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3);
@@ -145,7 +145,7 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x3F<T> left, Matrix3x3F<T> right) =>
+        public static Matrix2X3<T> operator *(Matrix2X3<T> left, Matrix3X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
 
@@ -153,7 +153,7 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x3F<T> left, Matrix3x2F<T> right) =>
+        public static Matrix3X2<T> operator *(Matrix3X3<T> left, Matrix3X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
@@ -162,15 +162,15 @@ public Matrix3x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x3F<T> left, Matrix3x3F<T> right) =>
+        public static Matrix3X3<T> operator *(Matrix3X3<T> left, Matrix3X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
     }
 
-    static partial class Matrix3x3F
+    public static partial class Matrix3X3
     {
-        public static Matrix3x3F<T> Lerp<T>(Matrix3x3F<T> value1, Matrix3x3F<T> value2, T amount)
+        public static Matrix3X3<T> Lerp<T>(Matrix3X3<T> value1, Matrix3X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
diff --git a/sources/Maths/Maths/Matrix3x4F.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
similarity index 83%
rename from sources/Maths/Maths/Matrix3x4F.gen.cs
rename to sources/Maths/Maths/Matrix3X4.gen.cs
index 45de27a659..72a40e990d 100644
--- a/sources/Maths/Maths/Matrix3x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -3,26 +3,26 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix3x4F<T> :
-        IEquatable<Matrix3x4F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix3X4<T> :
+        IEquatable<Matrix3X4<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row1;
+        public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row2;
+        public Vector4D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row3;
+        public Vector4D<T> Row3;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix3x4F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix3X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix3x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row]
+        public ref Vector4D<T> this[int row]
         {
             get
             {
@@ -92,16 +92,16 @@ public ref Vector4F<T> this[int row]
         public ref T M34 => ref Row3.W;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x4F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix3X4<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix3x4F<T> other) => this == other;
+        public bool Equals(Matrix3X4<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x3F<T> Transpose() =>
+        public Matrix4X3<T> Transpose() =>
             new(new(M11, M21, M31),
                 new(M12, M22, M32),
                 new(M13, M23, M33),
@@ -111,7 +111,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+        public static bool operator ==(Matrix3X4<T> left, Matrix3X4<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3;
@@ -120,13 +120,13 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x4F<T> left, Matrix3x4F<T> right) => !(left == right);
+        public static bool operator !=(Matrix3X4<T> left, Matrix3X4<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix3x4F<T> operator +(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+        public static Matrix3X4<T> operator +(Matrix3X4<T> left, Matrix3X4<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3);
@@ -135,7 +135,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x4F<T> operator -(Matrix3x4F<T> left, Matrix3x4F<T> right) =>
+        public static Matrix3X4<T> operator -(Matrix3X4<T> left, Matrix3X4<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3);
@@ -143,7 +143,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix3x4F<T> operator -(Matrix3x4F<T> value) =>
+        public static Matrix3X4<T> operator -(Matrix3X4<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3);
@@ -152,7 +152,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x3F<T> left, Matrix3x4F<T> right) =>
+        public static Matrix2X4<T> operator *(Matrix2X3<T> left, Matrix3X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
 
@@ -160,7 +160,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x3F<T> left, Matrix3x4F<T> right) =>
+        public static Matrix3X4<T> operator *(Matrix3X3<T> left, Matrix3X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
@@ -169,7 +169,7 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2F<T> operator *(Matrix3x4F<T> left, Matrix4x2F<T> right) =>
+        public static Matrix3X2<T> operator *(Matrix3X4<T> left, Matrix4X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
@@ -178,15 +178,15 @@ public Matrix4x3F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3F<T> operator *(Matrix3x4F<T> left, Matrix4x3F<T> right) =>
+        public static Matrix3X3<T> operator *(Matrix3X4<T> left, Matrix4X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
     }
 
-    static partial class Matrix3x4F
+    public static partial class Matrix3X4
     {
-        public static Matrix3x4F<T> Lerp<T>(Matrix3x4F<T> value1, Matrix3x4F<T> value2, T amount)
+        public static Matrix3X4<T> Lerp<T>(Matrix3X4<T> value1, Matrix3X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
diff --git a/sources/Maths/Maths/Matrix3x2I.gen.cs b/sources/Maths/Maths/Matrix3x2I.gen.cs
deleted file mode 100644
index 868cfc9584..0000000000
--- a/sources/Maths/Maths/Matrix3x2I.gen.cs
+++ /dev/null
@@ -1,144 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix3x2I<T> :
-        IEquatable<Matrix3x2I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row3;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3x2I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix3x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
-
-        [UnscopedRef]
-        public ref Vector2I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x2I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix3x2I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x3I<T> Transpose() =>
-            new(new(M11, M21, M31),
-                new(M12, M22, M32));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x2I<T> left, Matrix3x2I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix3x2I<T> operator +(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x2I<T> operator -(Matrix3x2I<T> left, Matrix3x2I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix3x2I<T> operator -(Matrix3x2I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x2I<T> left, Matrix2x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x2I<T> left, Matrix2x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix3x3I.gen.cs b/sources/Maths/Maths/Matrix3x3I.gen.cs
deleted file mode 100644
index 3cee1adfaf..0000000000
--- a/sources/Maths/Maths/Matrix3x3I.gen.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix3x3I<T> :
-        IEquatable<Matrix3x3I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The multiplicative identity matrix of size 3x3.</summary>
-        public static readonly Matrix3x3I<T> Identity = new(
-            new(T.MultiplicativeIdentity, T.Zero, T.Zero),
-            new(T.Zero, T.MultiplicativeIdentity, T.Zero),
-            new(T.Zero, T.Zero, T.MultiplicativeIdentity));
-
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row3;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3x3I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix3x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
-
-        [UnscopedRef]
-        public ref Vector3I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x3I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix3x3I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x3I<T> Transpose() =>
-            new(new(M11, M21, M31),
-                new(M12, M22, M32),
-                new(M13, M23, M33));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x3I<T> left, Matrix3x3I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix3x3I<T> operator +(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x3I<T> operator -(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix3x3I<T> operator -(Matrix3x3I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x3I<T> left, Matrix3x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x3I<T> left, Matrix3x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x3I<T> left, Matrix3x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix3x4I.gen.cs b/sources/Maths/Maths/Matrix3x4I.gen.cs
deleted file mode 100644
index 83fba2ab2f..0000000000
--- a/sources/Maths/Maths/Matrix3x4I.gen.cs
+++ /dev/null
@@ -1,187 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix3x4I<T> :
-        IEquatable<Matrix3x4I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row3;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3x4I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix3x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
-
-        [UnscopedRef]
-        public ref Vector4I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M14 => ref Row1.W;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M24 => ref Row2.W;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M34 => ref Row3.W;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix3x4I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix3x4I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x3I<T> Transpose() =>
-            new(new(M11, M21, M31),
-                new(M12, M22, M32),
-                new(M13, M23, M33),
-                new(M14, M24, M34));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix3x4I<T> left, Matrix3x4I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix3x4I<T> operator +(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix3x4I<T> operator -(Matrix3x4I<T> left, Matrix3x4I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix3x4I<T> operator -(Matrix3x4I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x3I<T> left, Matrix3x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x3I<T> left, Matrix3x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x2I<T> operator *(Matrix3x4I<T> left, Matrix4x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x3I<T> operator *(Matrix3x4I<T> left, Matrix4x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix4x2F.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
similarity index 81%
rename from sources/Maths/Maths/Matrix4x2F.gen.cs
rename to sources/Maths/Maths/Matrix4X2.gen.cs
index b5d608a7e0..36b257c507 100644
--- a/sources/Maths/Maths/Matrix4x2F.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -3,29 +3,29 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x2F<T> :
-        IEquatable<Matrix4x2F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix4X2<T> :
+        IEquatable<Matrix4X2<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row1;
+        public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row2;
+        public Vector2D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row3;
+        public Vector2D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector2F<T> Row4;
+        public Vector2D<T> Row4;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix4x2F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix4X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix4x2F(Vector2F<T> row1, Vector2F<T> row2, Vector2F<T> row3, Vector2F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        public Matrix4X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3, Vector2D<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
 
         [UnscopedRef]
-        public ref Vector2F<T> this[int row]
+        public ref Vector2D<T> this[int row]
         {
             get
             {
@@ -81,16 +81,16 @@ public ref Vector2F<T> this[int row]
         public ref T M42 => ref Row4.Y;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x2F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix4X2<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix4x2F<T> other) => this == other;
+        public bool Equals(Matrix4X2<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x4F<T> Transpose() =>
+        public Matrix2X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42));
 
@@ -98,7 +98,7 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+        public static bool operator ==(Matrix4X2<T> left, Matrix4X2<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3 &&
@@ -108,13 +108,13 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x2F<T> left, Matrix4x2F<T> right) => !(left == right);
+        public static bool operator !=(Matrix4X2<T> left, Matrix4X2<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x2F<T> operator +(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+        public static Matrix4X2<T> operator +(Matrix4X2<T> left, Matrix4X2<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3,
@@ -124,7 +124,7 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x2F<T> operator -(Matrix4x2F<T> left, Matrix4x2F<T> right) =>
+        public static Matrix4X2<T> operator -(Matrix4X2<T> left, Matrix4X2<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3,
@@ -133,7 +133,7 @@ public Matrix2x4F<T> Transpose() =>
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix4x2F<T> operator -(Matrix4x2F<T> value) =>
+        public static Matrix4X2<T> operator -(Matrix4X2<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3,
@@ -143,7 +143,7 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x2F<T> left, Matrix2x2F<T> right) =>
+        public static Matrix4X2<T> operator *(Matrix4X2<T> left, Matrix2X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2,
@@ -153,7 +153,7 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x2F<T> left, Matrix2x3F<T> right) =>
+        public static Matrix4X3<T> operator *(Matrix4X2<T> left, Matrix2X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2,
@@ -163,16 +163,16 @@ public Matrix2x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x2F<T> left, Matrix2x4F<T> right) =>
+        public static Matrix4X4<T> operator *(Matrix4X2<T> left, Matrix2X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
     }
 
-    static partial class Matrix4x2F
+    public static partial class Matrix4X2
     {
-        public static Matrix4x2F<T> Lerp<T>(Matrix4x2F<T> value1, Matrix4x2F<T> value2, T amount)
+        public static Matrix4X2<T> Lerp<T>(Matrix4X2<T> value1, Matrix4X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
diff --git a/sources/Maths/Maths/Matrix4x3F.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
similarity index 83%
rename from sources/Maths/Maths/Matrix4x3F.gen.cs
rename to sources/Maths/Maths/Matrix4X3.gen.cs
index 5600ad456c..ba7647e55a 100644
--- a/sources/Maths/Maths/Matrix4x3F.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -3,29 +3,29 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix4x3F<T> :
-        IEquatable<Matrix4x3F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix4X3<T> :
+        IEquatable<Matrix4X3<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row1;
+        public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row2;
+        public Vector3D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row3;
+        public Vector3D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector3F<T> Row4;
+        public Vector3D<T> Row4;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix4x3F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix4X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix4x3F(Vector3F<T> row1, Vector3F<T> row2, Vector3F<T> row3, Vector3F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        public Matrix4X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3, Vector3D<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
 
         [UnscopedRef]
-        public ref Vector3F<T> this[int row]
+        public ref Vector3D<T> this[int row]
         {
             get
             {
@@ -97,16 +97,16 @@ public ref Vector3F<T> this[int row]
         public ref T M43 => ref Row4.Z;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x3F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix4X3<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix4x3F<T> other) => this == other;
+        public bool Equals(Matrix4X3<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
         /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x4F<T> Transpose() =>
+        public Matrix3X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
                 new(M12, M22, M32, M42),
                 new(M13, M23, M33, M43));
@@ -115,7 +115,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+        public static bool operator ==(Matrix4X3<T> left, Matrix4X3<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3 &&
@@ -125,13 +125,13 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x3F<T> left, Matrix4x3F<T> right) => !(left == right);
+        public static bool operator !=(Matrix4X3<T> left, Matrix4X3<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix4x3F<T> operator +(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+        public static Matrix4X3<T> operator +(Matrix4X3<T> left, Matrix4X3<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3,
@@ -141,7 +141,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x3F<T> operator -(Matrix4x3F<T> left, Matrix4x3F<T> right) =>
+        public static Matrix4X3<T> operator -(Matrix4X3<T> left, Matrix4X3<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3,
@@ -150,7 +150,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix4x3F<T> operator -(Matrix4x3F<T> value) =>
+        public static Matrix4X3<T> operator -(Matrix4X3<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3,
@@ -160,7 +160,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3F<T> operator *(Matrix2x4F<T> left, Matrix4x3F<T> right) =>
+        public static Matrix2X3<T> operator *(Matrix2X4<T> left, Matrix4X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
 
@@ -168,7 +168,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x3F<T> left, Matrix3x2F<T> right) =>
+        public static Matrix4X2<T> operator *(Matrix4X3<T> left, Matrix3X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
@@ -178,7 +178,7 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x3F<T> left, Matrix3x3F<T> right) =>
+        public static Matrix4X3<T> operator *(Matrix4X3<T> left, Matrix3X3<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
@@ -188,16 +188,16 @@ public Matrix3x4F<T> Transpose() =>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x3F<T> left, Matrix3x4F<T> right) =>
+        public static Matrix4X4<T> operator *(Matrix4X3<T> left, Matrix3X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
     }
 
-    static partial class Matrix4x3F
+    public static partial class Matrix4X3
     {
-        public static Matrix4x3F<T> Lerp<T>(Matrix4x3F<T> value1, Matrix4x3F<T> value2, T amount)
+        public static Matrix4X3<T> Lerp<T>(Matrix4X3<T> value1, Matrix4X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
diff --git a/sources/Maths/Maths/Matrix4x2I.gen.cs b/sources/Maths/Maths/Matrix4x2I.gen.cs
deleted file mode 100644
index a1d468858e..0000000000
--- a/sources/Maths/Maths/Matrix4x2I.gen.cs
+++ /dev/null
@@ -1,173 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix4x2I<T> :
-        IEquatable<Matrix4x2I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row3;
-
-        /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector2I<T> Row4;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4x2I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4x2I(Vector2I<T> row1, Vector2I<T> row2, Vector2I<T> row3, Vector2I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
-
-        [UnscopedRef]
-        public ref Vector2I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                    case 3:
-                        return ref Row4;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M41 => ref Row4.X;
-
-        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M42 => ref Row4.Y;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x2I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix4x2I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix2x4I<T> Transpose() =>
-            new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3 &&
-            left.Row4 == right.Row4;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x2I<T> left, Matrix4x2I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix4x2I<T> operator +(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3,
-                left.Row4 + right.Row4);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x2I<T> operator -(Matrix4x2I<T> left, Matrix4x2I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3,
-                left.Row4 - right.Row4);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix4x2I<T> operator -(Matrix4x2I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x2I<T> left, Matrix2x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2,
-                left.M41 * right.Row1 + left.M42 * right.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x2I<T> left, Matrix2x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2,
-                left.M41 * right.Row1 + left.M42 * right.Row2);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x2I<T> left, Matrix2x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2,
-                left.M21 * right.Row1 + left.M22 * right.Row2,
-                left.M31 * right.Row1 + left.M32 * right.Row2,
-                left.M41 * right.Row1 + left.M42 * right.Row2);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix4x3I.gen.cs b/sources/Maths/Maths/Matrix4x3I.gen.cs
deleted file mode 100644
index 49b3576f0a..0000000000
--- a/sources/Maths/Maths/Matrix4x3I.gen.cs
+++ /dev/null
@@ -1,198 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix4x3I<T> :
-        IEquatable<Matrix4x3I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row3;
-
-        /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector3I<T> Row4;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4x3I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4x3I(Vector3I<T> row1, Vector3I<T> row2, Vector3I<T> row3, Vector3I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
-
-        [UnscopedRef]
-        public ref Vector3I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                    case 3:
-                        return ref Row4;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M41 => ref Row4.X;
-
-        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M42 => ref Row4.Y;
-
-        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M43 => ref Row4.Z;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x3I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix4x3I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix3x4I<T> Transpose() =>
-            new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42),
-                new(M13, M23, M33, M43));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3 &&
-            left.Row4 == right.Row4;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x3I<T> left, Matrix4x3I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix4x3I<T> operator +(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3,
-                left.Row4 + right.Row4);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x3I<T> operator -(Matrix4x3I<T> left, Matrix4x3I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3,
-                left.Row4 - right.Row4);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix4x3I<T> operator -(Matrix4x3I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x3I<T> operator *(Matrix2x4I<T> left, Matrix4x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x3I<T> left, Matrix3x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x3I<T> left, Matrix3x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x3I<T> left, Matrix3x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix4x4F.gen.cs b/sources/Maths/Maths/Matrix4x4F.gen.cs
deleted file mode 100644
index 9c2acdddf3..0000000000
--- a/sources/Maths/Maths/Matrix4x4F.gen.cs
+++ /dev/null
@@ -1,240 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix4x4F<T> :
-        IEquatable<Matrix4x4F<T>>
-        where T : IFloatingPointIeee754<T>
-    {
-        /// <summary>The multiplicative identity matrix of size 4x4.</summary>
-        public static readonly Matrix4x4F<T> Identity = new(
-            new(T.MultiplicativeIdentity, T.Zero, T.Zero, T.Zero),
-            new(T.Zero, T.MultiplicativeIdentity, T.Zero, T.Zero),
-            new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
-            new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
-
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row3;
-
-        /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row4;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4x4F{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
-
-        [UnscopedRef]
-        public ref Vector4F<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                    case 3:
-                        return ref Row4;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M14 => ref Row1.W;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M24 => ref Row2.W;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M34 => ref Row3.W;
-
-        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M41 => ref Row4.X;
-
-        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M42 => ref Row4.Y;
-
-        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M43 => ref Row4.Z;
-
-        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M44 => ref Row4.W;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x4F<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix4x4F<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x4F<T> Transpose() =>
-            new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42),
-                new(M13, M23, M33, M43),
-                new(M14, M24, M34, M44));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3 &&
-            left.Row4 == right.Row4;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x4F<T> left, Matrix4x4F<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix4x4F<T> operator +(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3,
-                left.Row4 + right.Row4);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x4F<T> operator -(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3,
-                left.Row4 - right.Row4);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix4x4F<T> operator -(Matrix4x4F<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4F<T> operator *(Matrix2x4F<T> left, Matrix4x4F<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4F<T> operator *(Matrix3x4F<T> left, Matrix4x4F<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2F<T> operator *(Matrix4x4F<T> left, Matrix4x2F<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3F<T> operator *(Matrix4x4F<T> left, Matrix4x3F<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4F<T> operator *(Matrix4x4F<T> left, Matrix4x4F<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-    }
-
-    static partial class Matrix4x4F
-    {
-        public static Matrix4x4F<T> Lerp<T>(Matrix4x4F<T> value1, Matrix4x4F<T> value2, T amount)
-            where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)),
-                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount), T.Lerp(value1.M44, value2.M44, amount)));
-    }
-}
diff --git a/sources/Maths/Maths/Matrix4x4I.gen.cs b/sources/Maths/Maths/Matrix4x4I.gen.cs
deleted file mode 100644
index ebae4c3681..0000000000
--- a/sources/Maths/Maths/Matrix4x4I.gen.cs
+++ /dev/null
@@ -1,231 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix4x4I<T> :
-        IEquatable<Matrix4x4I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The multiplicative identity matrix of size 4x4.</summary>
-        public static readonly Matrix4x4I<T> Identity = new(
-            new(T.MultiplicativeIdentity, T.Zero, T.Zero, T.Zero),
-            new(T.Zero, T.MultiplicativeIdentity, T.Zero, T.Zero),
-            new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
-            new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
-
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row3;
-
-        /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row4;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4x4I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
-
-        [UnscopedRef]
-        public ref Vector4I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                    case 3:
-                        return ref Row4;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M14 => ref Row1.W;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M24 => ref Row2.W;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M34 => ref Row3.W;
-
-        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M41 => ref Row4.X;
-
-        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M42 => ref Row4.Y;
-
-        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M43 => ref Row4.Z;
-
-        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M44 => ref Row4.W;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix4x4I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix4x4I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
-
-        /// <summary>Computes the transpose of the matrix.</summary>
-        public Matrix4x4I<T> Transpose() =>
-            new(new(M11, M21, M31, M41),
-                new(M12, M22, M32, M42),
-                new(M13, M23, M33, M43),
-                new(M14, M24, M34, M44));
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3 &&
-            left.Row4 == right.Row4;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix4x4I<T> left, Matrix4x4I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix4x4I<T> operator +(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3,
-                left.Row4 + right.Row4);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix4x4I<T> operator -(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3,
-                left.Row4 - right.Row4);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix4x4I<T> operator -(Matrix4x4I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix2x4I<T> operator *(Matrix2x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix3x4I<T> operator *(Matrix3x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x2I<T> operator *(Matrix4x4I<T> left, Matrix4x2I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x3I<T> operator *(Matrix4x4I<T> left, Matrix4x3I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix4x4I<T> operator *(Matrix4x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
-    }
-
-}
diff --git a/sources/Maths/Maths/Matrix5x4F.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
similarity index 86%
rename from sources/Maths/Maths/Matrix5x4F.gen.cs
rename to sources/Maths/Maths/Matrix5X4.gen.cs
index 0c299fd514..f2eeff2e38 100644
--- a/sources/Maths/Maths/Matrix5x4F.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -3,32 +3,32 @@ namespace Silk.NET.Maths
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
 
-    partial struct Matrix5x4F<T> :
-        IEquatable<Matrix5x4F<T>>
-        where T : IFloatingPointIeee754<T>
+    public partial struct Matrix5X4<T> :
+        IEquatable<Matrix5X4<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row1;
+        public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row2;
+        public Vector4D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row3;
+        public Vector4D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row4;
+        public Vector4D<T> Row4;
 
         /// <summary>The 5th row of the matrix represented as a vector.</summary>
-        public Vector4F<T> Row5;
+        public Vector4D<T> Row5;
 
         /// <summary>
-        /// Constructs a <see cref="Matrix5x4F{T}"/> from the given rows.
+        /// Constructs a <see cref="Matrix5X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix5x4F(Vector4F<T> row1, Vector4F<T> row2, Vector4F<T> row3, Vector4F<T> row4, Vector4F<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+        public Matrix5X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4, Vector4D<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
 
         [UnscopedRef]
-        public ref Vector4F<T> this[int row]
+        public ref Vector4D<T> this[int row]
         {
             get
             {
@@ -134,10 +134,10 @@ public ref Vector4F<T> this[int row]
         public ref T M54 => ref Row5.W;
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix5x4F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Matrix5X4<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Matrix5x4F<T> other) => this == other;
+        public bool Equals(Matrix5X4<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
@@ -146,7 +146,7 @@ public ref Vector4F<T> this[int row]
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+        public static bool operator ==(Matrix5X4<T> left, Matrix5X4<T> right) =>
             left.Row1 == right.Row1 &&
             left.Row2 == right.Row2 &&
             left.Row3 == right.Row3 &&
@@ -157,13 +157,13 @@ public ref Vector4F<T> this[int row]
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
         /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix5x4F<T> left, Matrix5x4F<T> right) => !(left == right);
+        public static bool operator !=(Matrix5X4<T> left, Matrix5X4<T> right) => !(left == right);
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the addition.</returns>
-        public static Matrix5x4F<T> operator +(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+        public static Matrix5X4<T> operator +(Matrix5X4<T> left, Matrix5X4<T> right) =>
             new(left.Row1 + right.Row1,
                 left.Row2 + right.Row2,
                 left.Row3 + right.Row3,
@@ -174,7 +174,7 @@ public ref Vector4F<T> this[int row]
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
-        public static Matrix5x4F<T> operator -(Matrix5x4F<T> left, Matrix5x4F<T> right) =>
+        public static Matrix5X4<T> operator -(Matrix5X4<T> left, Matrix5X4<T> right) =>
             new(left.Row1 - right.Row1,
                 left.Row2 - right.Row2,
                 left.Row3 - right.Row3,
@@ -184,7 +184,7 @@ public ref Vector4F<T> this[int row]
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
-        public static Matrix5x4F<T> operator -(Matrix5x4F<T> value) =>
+        public static Matrix5X4<T> operator -(Matrix5X4<T> value) =>
             new(-value.Row1,
                 -value.Row2,
                 -value.Row3,
@@ -195,7 +195,7 @@ public ref Vector4F<T> this[int row]
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
-        public static Matrix5x4F<T> operator *(Matrix5x4F<T> left, Matrix4x4F<T> right) =>
+        public static Matrix5X4<T> operator *(Matrix5X4<T> left, Matrix4X4<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
@@ -203,9 +203,9 @@ public ref Vector4F<T> this[int row]
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
     }
 
-    static partial class Matrix5x4F
+    public static partial class Matrix5X4
     {
-        public static Matrix5x4F<T> Lerp<T>(Matrix5x4F<T> value1, Matrix5x4F<T> value2, T amount)
+        public static Matrix5X4<T> Lerp<T>(Matrix5X4<T> value1, Matrix5X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
             new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
                 new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
diff --git a/sources/Maths/Maths/Matrix5x4I.gen.cs b/sources/Maths/Maths/Matrix5x4I.gen.cs
deleted file mode 100644
index a57e492891..0000000000
--- a/sources/Maths/Maths/Matrix5x4I.gen.cs
+++ /dev/null
@@ -1,206 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-
-    partial struct Matrix5x4I<T> :
-        IEquatable<Matrix5x4I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The 1st row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row1;
-
-        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row2;
-
-        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row3;
-
-        /// <summary>The 4th row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row4;
-
-        /// <summary>The 5th row of the matrix represented as a vector.</summary>
-        public Vector4I<T> Row5;
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix5x4I{T}"/> from the given rows.
-        /// </summary>
-        public Matrix5x4I(Vector4I<T> row1, Vector4I<T> row2, Vector4I<T> row3, Vector4I<T> row4, Vector4I<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
-
-        [UnscopedRef]
-        public ref Vector4I<T> this[int row]
-        {
-            get
-            {
-                switch (row)
-                {
-                    case 0:
-                        return ref Row1;
-                    case 1:
-                        return ref Row2;
-                    case 2:
-                        return ref Row3;
-                    case 3:
-                        return ref Row4;
-                    case 4:
-                        return ref Row5;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(row));
-            }
-        }
-
-        [UnscopedRef]
-        public ref T this[int row, int column] => ref this[row][column];
-
-        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M11 => ref Row1.X;
-
-        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M12 => ref Row1.Y;
-
-        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M13 => ref Row1.Z;
-
-        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M14 => ref Row1.W;
-
-        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M21 => ref Row2.X;
-
-        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M22 => ref Row2.Y;
-
-        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M23 => ref Row2.Z;
-
-        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M24 => ref Row2.W;
-
-        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M31 => ref Row3.X;
-
-        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M32 => ref Row3.Y;
-
-        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M33 => ref Row3.Z;
-
-        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M34 => ref Row3.W;
-
-        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M41 => ref Row4.X;
-
-        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M42 => ref Row4.Y;
-
-        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M43 => ref Row4.Z;
-
-        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M44 => ref Row4.W;
-
-        /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M51 => ref Row5.X;
-
-        /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M52 => ref Row5.Y;
-
-        /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M53 => ref Row5.Z;
-
-        /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
-        [UnscopedRef]
-        public ref T M54 => ref Row5.W;
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Matrix5x4I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Matrix5x4I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
-            left.Row1 == right.Row1 &&
-            left.Row2 == right.Row2 &&
-            left.Row3 == right.Row3 &&
-            left.Row4 == right.Row4 &&
-            left.Row5 == right.Row5;
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="left">The first matrix to compare.</param>
-        /// <param name="right">The second matrix to compare.</param>
-        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Matrix5x4I<T> left, Matrix5x4I<T> right) => !(left == right);
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the addition.</returns>
-        public static Matrix5x4I<T> operator +(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
-            new(left.Row1 + right.Row1,
-                left.Row2 + right.Row2,
-                left.Row3 + right.Row3,
-                left.Row4 + right.Row4,
-                left.Row5 + right.Row5);
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static Matrix5x4I<T> operator -(Matrix5x4I<T> left, Matrix5x4I<T> right) =>
-            new(left.Row1 - right.Row1,
-                left.Row2 - right.Row2,
-                left.Row3 - right.Row3,
-                left.Row4 - right.Row4,
-                left.Row5 - right.Row5);
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix5x4I<T> operator -(Matrix5x4I<T> value) =>
-            new(-value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4,
-                -value.Row5);
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="left">The first source matrix.</param>
-        /// <param name="right">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static Matrix5x4I<T> operator *(Matrix5x4I<T> left, Matrix4x4I<T> right) =>
-            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
-                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
-                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
-                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
-                left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
-    }
-
-}
diff --git a/sources/Maths/Maths/Vector2D.cs b/sources/Maths/Maths/Vector2D.cs
new file mode 100644
index 0000000000..dd577a241c
--- /dev/null
+++ b/sources/Maths/Maths/Vector2D.cs
@@ -0,0 +1,78 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace Silk.NET.Maths
+{
+    /// <summary>A structure representing a 2D integer vector.</summary>
+    public partial struct Vector2D<T>
+    {
+        /// <summary> Computes the cross product of this vector with another vector. </summary>
+        public T Cross(Vector2D<T> other) => (X * other.Y) - (Y * other.X);
+
+        /// <summary> Computes the cross product of two vectors. </summary>
+        public static T Cross(Vector2D<T> left, Vector2D<T> right) => (left.X * right.Y) - (left.Y * right.X);
+
+        // Casts
+
+        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2D{T}"/>.</summary>
+        public static explicit operator Vector2D<T>(System.Numerics.Vector2 v) =>
+            new Vector2D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
+
+        /// <summary>Explicitly casts a <see cref="Vector2D{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
+        public static explicit operator System.Numerics.Vector2(Vector2D<T> v) =>
+            new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
+
+        public static (Vector2D<T> Quotient, Vector2D<T> Remainder) DivRem(Vector2D<T> left, Vector2D<T> right)
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            return (new Vector2D<T>(qX, qY), new Vector2D<T>(rX, rY));
+        }
+
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
+        public static Vector2D<T> LerpClamped(Vector2D<T> a, Vector2D<T> b, T t) =>
+            Vector2D.Lerp(a, b, T.Clamp(t, T.Zero, T.One));
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
+        public static Vector2D<T> LerpClamped(Vector2D<T> a, Vector2D<T> b, Vector2D<T> t) =>
+            new(
+                a.X + (b.X - a.X) * T.Clamp(t.X, T.Zero, T.One),
+                a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
+            );
+
+        // IFloatingPointIeee754
+
+        public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos(Vector2D<T> x) =>
+            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
+
+        public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi(Vector2D<T> x) =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
+
+        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, Vector2D<T> right, Vector2D<T> addend) =>
+            new(T.FusedMultiplyAdd(left.X, right.X, addend.X), T.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
+
+        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, Vector2D<T> right, T addend) =>
+            new(T.FusedMultiplyAdd(left.X, right.X, addend), T.FusedMultiplyAdd(left.Y, right.Y, addend));
+
+        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, T right, Vector2D<T> addend) =>
+            new(T.FusedMultiplyAdd(left.X, right, addend.X), T.FusedMultiplyAdd(left.Y, right, addend.Y));
+
+        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, T right, T addend) =>
+            new(T.FusedMultiplyAdd(left.X, right, addend), T.FusedMultiplyAdd(left.Y, right, addend));
+    }
+
+    public static partial class Vector2D
+    {
+        /// <summary> Computes the cross product of two vectors.</summary>
+        public static T Cross<T>(this Vector2D<T> left, Vector2D<T> right)
+            where T : IFloatingPointIeee754<T> => (left.X * right.Y) - (left.Y * right.X);
+    }
+}
diff --git a/sources/Maths/Maths/Vector2F.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
similarity index 73%
rename from sources/Maths/Maths/Vector2F.gen.cs
rename to sources/Maths/Maths/Vector2D.gen.cs
index 66d80f2855..3c9845a843 100644
--- a/sources/Maths/Maths/Vector2F.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -6,16 +6,16 @@ namespace Silk.NET.Maths
     using System.Runtime.InteropServices;
     using System.Text;
 
-    partial struct Vector2F<T> :
-        IEquatable<Vector2F<T>>,
+    public partial struct Vector2D<T> :
+        IEquatable<Vector2D<T>>,
         IReadOnlyList<T>,
         IFormattable,
-        IParsable<Vector2F<T>>,
+        IParsable<Vector2D<T>>,
         ISpanFormattable,
-        ISpanParsable<Vector2F<T>>,
+        ISpanParsable<Vector2D<T>>,
         IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2F<T>>
-        where T : IFloatingPointIeee754<T>
+        IUtf8SpanParsable<Vector2D<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -24,13 +24,13 @@ partial struct Vector2F<T> :
         public T Y;
 
         /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector2F(T value) => (X, Y) = (value, value);
+        public Vector2D(T value) => (X, Y) = (value, value);
 
         /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector2F(T x, T y) => (X, Y) = (x, y);
+        public Vector2D(T x, T y) => (X, Y) = (x, y);
 
         /// <summary>Initializes the vector from a span of 2 values.</summary>
-        public Vector2F(ReadOnlySpan<T> values)
+        public Vector2D(ReadOnlySpan<T> values)
         {
             if (values.Length != 2)
                 throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
@@ -40,19 +40,19 @@ public Vector2F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2F<T> One => new(T.One);
+        public static Vector2D<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2F<T> Zero => default;
+        public static Vector2D<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2F<T> UnitX => new(T.One, T.Zero);
+        public static Vector2D<T> UnitX => new(T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2F<T> UnitY => new(T.Zero, T.One);
+        public static Vector2D<T> UnitY => new(T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector2F.Dot(this, this);
+        public T LengthSquared => Vector2D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -127,14 +127,14 @@ public override string ToString() =>
         public string ToString(string? format, IFormatProvider? formatProvider) =>
             $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
 
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+        /// <summary>Parses a string to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static Vector2D<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        /// <summary>Parses a span to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static Vector2D<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
         {
             if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2F.");
+                throw new FormatException("Invalid format for Vector2D.");
 
             return result;
         }
@@ -213,8 +213,8 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        /// <summary>Tries to parse a span to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2D<T> result)
         {
             result = default;
 
@@ -234,15 +234,15 @@ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [Ma
             if (T.TryParse(xSpan, provider, out var x) &&
                 T.TryParse(ySpan, provider, out var y))
             {
-                result = new Vector2F<T>(x, y);
+                result = new Vector2D<T>(x, y);
                 return true;
             }
 
             return false;
         }
 
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static Vector2D<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -250,8 +250,8 @@ public static Vector2F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? pr
             return Parse(charBuffer, provider);
         }
 
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result)
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2D<T> result)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -259,31 +259,31 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
             return TryParse(charBuffer, provider, out result);
         }
 
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector2D{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2D<T> result) =>
             TryParse(s.AsSpan(), provider, out result);
 
-        /// <summary>Parses a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> ISpanParsable<Vector2F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+        /// <summary>Parses a span to a <see cref="Vector2D{T}"/> instance.</summary>
+        static Vector2D<T> ISpanParsable<Vector2D<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Parses a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static Vector2F<T> IParsable<Vector2F<T>>.Parse(string s, IFormatProvider? provider) =>
+        /// <summary>Parses a string to a <see cref="Vector2D{T}"/> instance.</summary>
+        static Vector2D<T> IParsable<Vector2D<T>>.Parse(string s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Tries to parse a span to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+        /// <summary>Tries to parse a span to a <see cref="Vector2D{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector2D<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2D<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary>Tries to parse a string to a <see cref="Vector2F{T}"/> instance.</summary>
-        static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector2D{T}"/> instance.</summary>
+        static bool IParsable<Vector2D<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2D<T> result) =>
             TryParse(s, provider, out result);
 
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector2F<T> left, Vector2F<T> right) =>
+        public static bool operator ==(Vector2D<T> left, Vector2D<T> right) =>
             left.X == right.X &&
             left.Y == right.Y;
 
@@ -291,13 +291,13 @@ static bool IParsable<Vector2F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector2F<T> left, Vector2F<T> right) => !(left == right);
+        public static bool operator !=(Vector2D<T> left, Vector2D<T> right) => !(left == right);
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector2F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Vector2D<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Vector2F<T> other) => this == other;
+        public bool Equals(Vector2D<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
@@ -311,252 +311,263 @@ public void Deconstruct(out T x, out T y)
             y = Y;
         }
 
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2F{T}"/>.</summary>
-        public static implicit operator Vector2F<T>((T X, T Y) v) =>
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector2D<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y));
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2D{T}"/>.</summary>
+        public static implicit operator Vector2D<T>((T X, T Y) v) =>
             new(v.X, v.Y);
 
-        /// <summary>Implicitly casts a <see cref="Vector2F{T}"/> to a <see cref="ValueTuple{T, T}"/>.</summary>
-        public static implicit operator (T X, T Y)(Vector2F<T> v) =>
+        /// <summary>Implicitly casts a <see cref="Vector2D{T}"/> to a <see cref="ValueTuple{T, T}"/>.</summary>
+        public static implicit operator (T X, T Y)(Vector2D<T> v) =>
             (v.X, v.Y);
 
-        public static Vector2F<T> operator +(Vector2F<T> vector) =>
+        public static Vector2D<T> operator +(Vector2D<T> vector) =>
             vector;
 
-        public static Vector2F<T> operator -(Vector2F<T> vector) =>
+        public static Vector2D<T> operator -(Vector2D<T> vector) =>
             new(-vector.X, -vector.Y);
 
-        public static Vector2F<T> operator +(Vector2F<T> left, Vector2F<T> right) =>
+        public static Vector2D<T> operator +(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X + right.X, left.Y + right.Y);
 
-        public static Vector2F<T> operator -(Vector2F<T> left, Vector2F<T> right) =>
+        public static Vector2D<T> operator -(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X - right.X, left.Y - right.Y);
 
-        public static Vector2F<T> operator *(Vector2F<T> left, Vector2F<T> right) =>
+        public static Vector2D<T> operator *(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X * right.X, left.Y * right.Y);
 
-        public static Vector2F<T> operator /(Vector2F<T> left, Vector2F<T> right) =>
+        public static Vector2D<T> operator /(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X / right.X, left.Y / right.Y);
 
-        public static Vector2F<T> operator %(Vector2F<T> left, Vector2F<T> right) =>
-            new(left.X % right.X, left.Y % right.Y);
-
-        public static Vector2F<T> operator +(Vector2F<T> vector, T scalar) =>
+        public static Vector2D<T> operator +(Vector2D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar);
 
-        public static Vector2F<T> operator -(Vector2F<T> vector, T scalar) =>
+        public static Vector2D<T> operator -(Vector2D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar);
 
-        public static Vector2F<T> operator *(Vector2F<T> vector, T scalar) =>
+        public static Vector2D<T> operator *(Vector2D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar);
 
-        public static Vector2F<T> operator *(T scalar, Vector2F<T> vector) =>
+        public static Vector2D<T> operator *(T scalar, Vector2D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y);
 
-        public static Vector2F<T> operator /(Vector2F<T> vector, T scalar) =>
+        public static Vector2D<T> operator /(Vector2D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar);
 
-        public static Vector2F<T> operator %(Vector2F<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar);
-
     }
 
-    static partial class Vector2F
+    public static partial class Vector2D
     {
         /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector2F<T> left, Vector2F<T> right)
-            where T : IFloatingPointIeee754<T> =>
+        public static T Dot<T>(this Vector2D<T> left, Vector2D<T> right)
+            where T : INumberBase<T> =>
             left.X * right.X + left.Y * right.Y;
 
         /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector2F<T> Reflect<T>(Vector2F<T> vector, Vector2F<T> normal)
-            where T : IFloatingPointIeee754<T>
+        public static Vector2D<T> Reflect<T>(Vector2D<T> vector, Vector2D<T> normal)
+            where T : INumberBase<T>
         {
             T dot = vector.Dot(normal);
             return vector - (normal * (dot + dot));
         }
 
         /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector2F<T> vector)
+        public static T GetLength<T>(this Vector2D<T> vector)
             where T : IFloatingPointIeee754<T> =>
             T.Sqrt(vector.LengthSquared);
 
         /// <summary>Normalizes a vector.</summary>
-        public static Vector2F<T> Normalize<T>(this Vector2F<T> vector)
+        public static Vector2D<T> Normalize<T>(this Vector2D<T> vector)
             where T : IFloatingPointIeee754<T>
         {
             T length = vector.GetLength();
-            return length != T.Zero ? vector / length : Vector2F<T>.Zero;
+            return length != T.Zero ? vector / length : Vector2D<T>.Zero;
         }
 
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector2I<int> Sign<TSelf>(this Vector2F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<int> Sign<TSelf>(this Vector2D<TSelf> value)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Sign(value.X), TSelf.Sign(value.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Max<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Max<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Max<TSelf>(this Vector2F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Max<TSelf>(this Vector2D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MaxNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MaxNumber<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MaxNumber<TSelf>(this Vector2F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MaxNumber<TSelf>(this Vector2D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Min<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Min<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Min<TSelf>(this Vector2F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Min<TSelf>(this Vector2D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MinNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MinNumber<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MinNumber<TSelf>(this Vector2F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MinNumber<TSelf>(this Vector2D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
         /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector2F<TSelf> Clamp<TSelf>(this Vector2F<TSelf> value, Vector2F<TSelf> min, Vector2F<TSelf> max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Clamp<TSelf>(this Vector2D<TSelf> value, Vector2D<TSelf> min, Vector2D<TSelf> max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A single value provided for <parameref name="min"/>.</param>
         /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector2F<TSelf> Clamp<TSelf>(this Vector2F<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Clamp<TSelf>(this Vector2D<TSelf> value, TSelf min, TSelf max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector2F<TSelf> CopySign<TSelf>(this Vector2F<TSelf> value, Vector2F<TSelf> sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> CopySign<TSelf>(this Vector2D<TSelf> value, Vector2D<TSelf> sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector2F<TSelf> CopySign<TSelf>(this Vector2F<TSelf> value, TSelf sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> CopySign<TSelf>(this Vector2D<TSelf> value, TSelf sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector2F<TSelf> Abs<TSelf>(this Vector2F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Abs<TSelf>(this Vector2D<TSelf> value)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.Abs(value.X), TSelf.Abs(value.Y));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MaxMagnitude<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MaxMagnitude<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MaxMagnitudeNumber<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MinMagnitude<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MinMagnitude<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> MinMagnitudeNumber<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> MinMagnitudeNumber<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.PopCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2D<TSelf> PopCount<TSelf>(this Vector2D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.PopCount(value.X), TSelf.PopCount(value.Y));
+
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.TrailingZeroCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector2D<TSelf> TrailingZeroCount<TSelf>(this Vector2D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.TrailingZeroCount(value.X), TSelf.TrailingZeroCount(value.Y));
+
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Ceiling<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Ceiling<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Floor<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Floor<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Floor(x.X), TSelf.Floor(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Round<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Round<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X), TSelf.Round(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
         /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
-        public static Vector2F<TSelf> Round<TSelf>(this Vector2F<TSelf> x, int digits, MidpointRounding mode)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Round<TSelf>(this Vector2D<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Truncate<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Truncate<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Atan2<TSelf>(this Vector2F<TSelf> y, Vector2F<TSelf> x)
+        public static Vector2D<TSelf> Atan2<TSelf>(this Vector2D<TSelf> y, Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Atan2Pi<TSelf>(this Vector2F<TSelf> y, Vector2F<TSelf> x)
+        public static Vector2D<TSelf> Atan2Pi<TSelf>(this Vector2D<TSelf> y, Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y));
 
@@ -564,19 +575,19 @@ public static Vector2F<TSelf> Atan2Pi<TSelf>(this Vector2F<TSelf> y, Vector2F<TS
         /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
         /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
         /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
-        public static Vector2F<TSelf> Lerp<TSelf>(this Vector2F<TSelf> value1, Vector2F<TSelf> value2, TSelf amount)
+        public static Vector2D<TSelf> Lerp<TSelf>(this Vector2D<TSelf> value1, Vector2D<TSelf> value2, TSelf amount)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> BitDecrement<TSelf>(this Vector2F<TSelf> x)
+        public static Vector2D<TSelf> BitDecrement<TSelf>(this Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> BitIncrement<TSelf>(this Vector2F<TSelf> x)
+        public static Vector2D<TSelf> BitIncrement<TSelf>(this Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y));
 
@@ -584,7 +595,7 @@ public static Vector2F<TSelf> BitIncrement<TSelf>(this Vector2F<TSelf> x)
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
-        public static Vector2F<TSelf> FusedMultiplyAdd<TSelf>(this Vector2F<TSelf> left, Vector2F<TSelf> right, Vector2F<TSelf> addend)
+        public static Vector2D<TSelf> FusedMultiplyAdd<TSelf>(this Vector2D<TSelf> left, Vector2D<TSelf> right, Vector2D<TSelf> addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
 
@@ -592,300 +603,300 @@ public static Vector2F<TSelf> FusedMultiplyAdd<TSelf>(this Vector2F<TSelf> left,
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
         /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
-        public static Vector2F<TSelf> FusedMultiplyAdd<TSelf>(this Vector2F<TSelf> left, TSelf right, TSelf addend)
+        public static Vector2D<TSelf> FusedMultiplyAdd<TSelf>(this Vector2D<TSelf> left, TSelf right, TSelf addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
-        public static Vector2F<TSelf> Ieee754Remainder<TSelf>(this Vector2F<TSelf> left, Vector2F<TSelf> right)
+        public static Vector2D<TSelf> Ieee754Remainder<TSelf>(this Vector2D<TSelf> left, Vector2D<TSelf> right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
-        public static Vector2F<TSelf> Ieee754Remainder<TSelf>(this Vector2F<TSelf> left, TSelf right)
+        public static Vector2D<TSelf> Ieee754Remainder<TSelf>(this Vector2D<TSelf> left, TSelf right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2I<int> ILogB<TSelf>(this Vector2F<TSelf> x)
+        public static Vector2D<int> ILogB<TSelf>(this Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> ReciprocalEstimate<TSelf>(this Vector2F<TSelf> x)
+        public static Vector2D<TSelf> ReciprocalEstimate<TSelf>(this Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector2F<TSelf> x)
+        public static Vector2D<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector2D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector2F<TSelf> ScaleB<TSelf>(this Vector2F<TSelf> x, Vector2I<int> n)
+        public static Vector2D<TSelf> ScaleB<TSelf>(this Vector2D<TSelf> x, Vector2D<int> n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector2F<TSelf> ScaleB<TSelf>(this Vector2F<TSelf> x, int n)
+        public static Vector2D<TSelf> ScaleB<TSelf>(this Vector2D<TSelf> x, int n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Pow<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Pow<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Pow<TSelf>(this Vector2F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Pow<TSelf>(this Vector2D<TSelf> x, TSelf y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Cbrt<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Cbrt<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Sqrt<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Sqrt<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector2F<TSelf> RootN<TSelf>(this Vector2F<TSelf> x, int n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> RootN<TSelf>(this Vector2D<TSelf> x, int n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector2F<TSelf> RootN<TSelf>(this Vector2F<TSelf> x, Vector2I<int> n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> RootN<TSelf>(this Vector2D<TSelf> x, Vector2D<int> n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2F<TSelf> Hypot<TSelf>(this Vector2F<TSelf> x, Vector2F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Hypot<TSelf>(this Vector2D<TSelf> x, Vector2D<TSelf> y)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
-        public static Vector2F<TSelf> Log<TSelf>(this Vector2F<TSelf> x, TSelf newBase)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log<TSelf>(this Vector2D<TSelf> x, TSelf newBase)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> LogP1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> LogP1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Log2<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log2<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Log2P1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log2P1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Log10<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log10<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Log10P1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Log10P1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Exp<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Exp<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> ExpM1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> ExpM1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Exp2<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Exp2<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Exp2M1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Exp2M1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Exp10<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Exp10<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Exp10M1<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Exp10M1<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Acos<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Acos<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Acos(x.X), TSelf.Acos(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> AcosPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> AcosPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Asin<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Asin<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Asin(x.X), TSelf.Asin(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> AsinPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> AsinPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Atan<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Atan<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Atan(x.X), TSelf.Atan(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> AtanPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> AtanPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Cos<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Cos<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Cos(x.X), TSelf.Cos(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> CosPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> CosPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Sin<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Sin<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Sin(x.X), TSelf.Sin(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> SinPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> SinPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Tan<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Tan<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Tan(x.X), TSelf.Tan(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> TanPi<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> TanPi<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
         /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
-        public static Vector2F<TSelf> DegreesToRadians<TSelf>(this Vector2F<TSelf> degrees)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> DegreesToRadians<TSelf>(this Vector2D<TSelf> degrees)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
         /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
-        public static Vector2F<TSelf> RadiansToDegrees<TSelf>(this Vector2F<TSelf> radians)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> RadiansToDegrees<TSelf>(this Vector2D<TSelf> radians)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Acosh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Acosh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Asinh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Asinh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Atanh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Atanh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Cosh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Cosh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Sinh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Sinh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector2F<TSelf> Tanh<TSelf>(this Vector2F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector2D<TSelf> Tanh<TSelf>(this Vector2D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y));
     }
 }
diff --git a/sources/Maths/Maths/Vector2F.cs b/sources/Maths/Maths/Vector2F.cs
deleted file mode 100644
index 70db4099f6..0000000000
--- a/sources/Maths/Maths/Vector2F.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-
-using System;
-using System.Collections;
-using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>A structure representing a 2D floating-point vector.</summary>
-    internal partial struct Vector2F<T>
-    {
-        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
-        public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, T t) =>
-            Vector2F.Lerp(a, b, T.Clamp(t, T.Zero, T.One));
-
-        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
-        public static Vector2F<T> LerpClamped(Vector2F<T> a, Vector2F<T> b, Vector2F<T> t) =>
-            new(
-                a.X + (b.X - a.X) * T.Clamp(t.X, T.Zero, T.One),
-                a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
-            );
-
-        // Casts
-
-        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2F{T}"/>.</summary>
-        public static explicit operator Vector2F<T>(System.Numerics.Vector2 v) =>
-            new((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
-
-        /// <summary>Explicitly casts a <see cref="Vector2F{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
-        public static explicit operator System.Numerics.Vector2(Vector2F<T> v) =>
-            new(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
-
-        // IFloatingPointIeee754
-
-        public static (Vector2F<T> Sin, Vector2F<T> Cos) SinCos(Vector2F<T> x) =>
-            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
-
-        public static (Vector2F<T> SinPi, Vector2F<T> CosPi) SinCosPi(Vector2F<T> x) =>
-            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
-
-        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, Vector2F<T> right, Vector2F<T> addend) =>
-            new(T.FusedMultiplyAdd(left.X, right.X, addend.X), T.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
-
-        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, Vector2F<T> right, T addend) =>
-            new(T.FusedMultiplyAdd(left.X, right.X, addend), T.FusedMultiplyAdd(left.Y, right.Y, addend));
-
-        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, Vector2F<T> addend) =>
-            new(T.FusedMultiplyAdd(left.X, right, addend.X), T.FusedMultiplyAdd(left.Y, right, addend.Y));
-
-        public static Vector2F<T> FusedMultiplyAdd(Vector2F<T> left, T right, T addend) =>
-            new(T.FusedMultiplyAdd(left.X, right, addend), T.FusedMultiplyAdd(left.Y, right, addend));
-    }
-
-    static partial class Vector2F
-    {
-        /// <summary> Computes the cross product of two vectors.</summary>
-        public static T Cross<T>(this Vector2F<T> left, Vector2F<T> right)
-            where T : IFloatingPointIeee754<T> => (left.X * right.Y) - (left.Y * right.X);
-    }
-}
diff --git a/sources/Maths/Maths/Vector2I.cs b/sources/Maths/Maths/Vector2I.cs
deleted file mode 100644
index 88adc7cb6e..0000000000
--- a/sources/Maths/Maths/Vector2I.cs
+++ /dev/null
@@ -1,40 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-
-using System.Collections;
-using System.Diagnostics.CodeAnalysis;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>A structure representing a 2D integer vector.</summary>
-    internal partial struct Vector2I<T>
-    {
-        /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public T Cross(Vector2I<T> other) => (X * other.Y) - (Y * other.X);
-
-        /// <summary> Computes the cross product of two vectors. </summary>
-        public static T Cross(Vector2I<T> left, Vector2I<T> right) => (left.X * right.Y) - (left.Y * right.X);
-
-        // Casts
-
-        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2I{T}"/>.</summary>
-        public static explicit operator Vector2I<T>(System.Numerics.Vector2 v) =>
-            new Vector2I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
-
-        /// <summary>Explicitly casts a <see cref="Vector2I{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
-        public static explicit operator System.Numerics.Vector2(Vector2I<T> v) =>
-            new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
-
-        public static (Vector2I<T> Quotient, Vector2I<T> Remainder) DivRem(Vector2I<T> left, Vector2I<T> right)
-        {
-            var (qX, rX) = T.DivRem(left.X, right.X);
-            var (qY, rY) = T.DivRem(left.Y, right.Y);
-            return (new Vector2I<T>(qX, qY), new Vector2I<T>(rX, rY));
-        }
-    }
-}
diff --git a/sources/Maths/Maths/Vector2I.gen.cs b/sources/Maths/Maths/Vector2I.gen.cs
deleted file mode 100644
index 5295369eb4..0000000000
--- a/sources/Maths/Maths/Vector2I.gen.cs
+++ /dev/null
@@ -1,542 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Collections;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-    using System.Runtime.InteropServices;
-    using System.Text;
-
-    partial struct Vector2I<T> :
-        IEquatable<Vector2I<T>>,
-        IReadOnlyList<T>,
-        IFormattable,
-        IParsable<Vector2I<T>>,
-        ISpanFormattable,
-        ISpanParsable<Vector2I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector2I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
-        /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector2I(T value) => (X, Y) = (value, value);
-
-        /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector2I(T x, T y) => (X, Y) = (x, y);
-
-        /// <summary>Initializes the vector from a span of 2 values.</summary>
-        public Vector2I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 2)
-                throw new ArgumentException("Input span must contain exactly 2 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-        }
-
-        /// <summary>Gets a vector whose 2 elements are equal to one.</summary>
-        public static Vector2I<T> One => new(T.One);
-
-        /// <summary>Returns a vector whose 2 elements are equal to zero.</summary>
-        public static Vector2I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0).</summary>
-        public static Vector2I<T> UnitX => new(T.One, T.Zero);
-
-        /// <summary>Gets the vector (0, 1).</summary>
-        public static Vector2I<T> UnitY => new(T.Zero, T.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector2I<T> AllBitsSet => new Vector2I<T>(T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector2I.Dot(this, this);
-
-        /// <inheritdoc/>
-        T IReadOnlyList<T>.this[int index] => this[index];
-
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y. </summary>
-        [UnscopedRef]
-        public ref T this[int index]
-        {
-            get
-            {
-                switch (index)
-                {
-                    case 0:
-                        return ref X;
-                    case 1:
-                        return ref Y;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-        }
-
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 2;
-
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 2 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 2 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-        }
-
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 2);
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() =>
-            $"<{X}, {Y}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}>";
-
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector2I.");
-
-            return result;
-        }
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int requiredLength = 1 + xChars + 2 + yChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 4 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaX = s.IndexOf(',');
-            if (commaX < 0)
-                return false;
-
-            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaX + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y))
-            {
-                result = new Vector2I<T>(x, y);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static Vector2I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> ISpanParsable<Vector2I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static Vector2I<T> IParsable<Vector2I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector2I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector2I{T}"/> instance.</summary>
-        static bool IParsable<Vector2I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector2I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector2I<T> left, Vector2I<T> right) =>
-            left.X == right.X &&
-            left.Y == right.Y;
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector2I<T> left, Vector2I<T> right) => !(left == right);
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector2I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Vector2I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(X, Y);
-
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        public void Deconstruct(out T x, out T y)
-        {
-            x = X;
-            y = Y;
-        }
-
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2I{T}"/>.</summary>
-        public static implicit operator Vector2I<T>((T X, T Y) v) =>
-            new(v.X, v.Y);
-
-        /// <summary>Implicitly casts a <see cref="Vector2I{T}"/> to a <see cref="ValueTuple{T, T}"/>.</summary>
-        public static implicit operator (T X, T Y)(Vector2I<T> v) =>
-            (v.X, v.Y);
-
-        public static Vector2I<T> operator +(Vector2I<T> vector) =>
-            vector;
-
-        public static Vector2I<T> operator -(Vector2I<T> vector) =>
-            new(-vector.X, -vector.Y);
-
-        public static Vector2I<T> operator +(Vector2I<T> left, Vector2I<T> right) =>
-            new(left.X + right.X, left.Y + right.Y);
-
-        public static Vector2I<T> operator -(Vector2I<T> left, Vector2I<T> right) =>
-            new(left.X - right.X, left.Y - right.Y);
-
-        public static Vector2I<T> operator *(Vector2I<T> left, Vector2I<T> right) =>
-            new(left.X * right.X, left.Y * right.Y);
-
-        public static Vector2I<T> operator /(Vector2I<T> left, Vector2I<T> right) =>
-            new(left.X / right.X, left.Y / right.Y);
-
-        public static Vector2I<T> operator %(Vector2I<T> left, Vector2I<T> right) =>
-            new(left.X % right.X, left.Y % right.Y);
-
-        public static Vector2I<T> operator +(Vector2I<T> vector, T scalar) =>
-            new(vector.X + scalar, vector.Y + scalar);
-
-        public static Vector2I<T> operator -(Vector2I<T> vector, T scalar) =>
-            new(vector.X - scalar, vector.Y - scalar);
-
-        public static Vector2I<T> operator *(Vector2I<T> vector, T scalar) =>
-            new(vector.X * scalar, vector.Y * scalar);
-
-        public static Vector2I<T> operator *(T scalar, Vector2I<T> vector) =>
-            new(scalar * vector.X, scalar * vector.Y);
-
-        public static Vector2I<T> operator /(Vector2I<T> vector, T scalar) =>
-            new(vector.X / scalar, vector.Y / scalar);
-
-        public static Vector2I<T> operator %(Vector2I<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar);
-
-        public static Vector2I<T> operator ~(Vector2I<T> vector) =>
-            new Vector2I<T>(~vector.X, ~vector.Y);
-
-        public static Vector2I<T> operator &(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X & right.X, left.Y & right.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X | right.X, left.Y | right.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> left, Vector2I<T> right) =>
-            new Vector2I<T>(left.X ^ right.X, left.Y ^ right.Y);
-
-        public static Vector2I<T> operator &(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X & scalar, vector.Y & scalar);
-
-        public static Vector2I<T> operator &(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar & vector.X, scalar & vector.Y);
-
-        public static Vector2I<T> operator |(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X | scalar, vector.Y | scalar);
-
-        public static Vector2I<T> operator |(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar | vector.X, scalar | vector.Y);
-
-        public static Vector2I<T> operator ^(Vector2I<T> vector, T scalar) =>
-            new Vector2I<T>(vector.X ^ scalar, vector.Y ^ scalar);
-
-        public static Vector2I<T> operator ^(T scalar, Vector2I<T> vector) =>
-            new Vector2I<T>(scalar ^ vector.X, scalar ^ vector.Y);
-    }
-
-    static partial class Vector2I
-    {
-        /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector2I<T> left, Vector2I<T> right)
-            where T : IBinaryInteger<T> =>
-            left.X * right.X + left.Y * right.Y;
-
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector2I<T> Reflect<T>(Vector2I<T> vector, Vector2I<T> normal)
-            where T : IBinaryInteger<T>
-        {
-            T dot = vector.Dot(normal);
-            return vector - (normal * (dot + dot));
-        }
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector2I<int> Sign<TSelf>(this Vector2I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Sign(value.X), TSelf.Sign(value.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> Max<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> Max<TSelf>(this Vector2I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MaxNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MaxNumber<TSelf>(this Vector2I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> Min<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> Min<TSelf>(this Vector2I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MinNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MinNumber<TSelf>(this Vector2I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
-        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector2I<TSelf> Clamp<TSelf>(this Vector2I<TSelf> value, Vector2I<TSelf> min, Vector2I<TSelf> max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
-        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector2I<TSelf> Clamp<TSelf>(this Vector2I<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector2I<TSelf> CopySign<TSelf>(this Vector2I<TSelf> value, Vector2I<TSelf> sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector2I<TSelf> CopySign<TSelf>(this Vector2I<TSelf> value, TSelf sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector2I<TSelf> Abs<TSelf>(this Vector2I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Abs(value.X), TSelf.Abs(value.Y));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MaxMagnitude<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MinMagnitude<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector2I<TSelf> MinMagnitudeNumber<TSelf>(this Vector2I<TSelf> x, Vector2I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y));
-
-        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector2I<TSelf> Log2<TSelf>(this Vector2I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Log2(value.X), TSelf.Log2(value.Y));
-    }
-}
diff --git a/sources/Maths/Maths/Vector3I.cs b/sources/Maths/Maths/Vector3D.cs
similarity index 69%
rename from sources/Maths/Maths/Vector3I.cs
rename to sources/Maths/Maths/Vector3D.cs
index 4141292c52..d1a2cdb784 100644
--- a/sources/Maths/Maths/Vector3I.cs
+++ b/sources/Maths/Maths/Vector3D.cs
@@ -12,19 +12,19 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
-    internal partial struct Vector3I<T>
+    public partial struct Vector3D<T>
     {
         /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public Vector3I<T> Cross(Vector3I<T> other) =>
-            new Vector3I<T>(
+        public Vector3D<T> Cross(Vector3D<T> other) =>
+            new Vector3D<T>(
                 (Y * other.Z) - (Z * other.Y),
                 (Z * other.X) - (X * other.Z),
                 (X * other.Y) - (Y * other.X)
             );
 
         /// <summary> Computes the cross product of two vectors. </summary>
-        public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(
+        public static Vector3D<T> Cross(Vector3D<T> left, Vector3D<T> right) =>
+            new Vector3D<T>(
                 (left.Y * right.Z) - (left.Z * right.Y),
                 (left.Z * right.X) - (left.X * right.Z),
                 (left.X * right.Y) - (left.Y * right.X)
@@ -32,20 +32,20 @@ public static Vector3I<T> Cross(Vector3I<T> left, Vector3I<T> right) =>
 
         // Casts
 
-        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3I{T}"/>.</summary>
-        public static explicit operator Vector3I<T>(System.Numerics.Vector3 v) =>
-            new Vector3I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
+        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3D{T}"/>.</summary>
+        public static explicit operator Vector3D<T>(System.Numerics.Vector3 v) =>
+            new Vector3D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
 
-        /// <summary>Explicitly casts a <see cref="Vector3I{T}"/> to <see cref="System.Numerics.Vector3"/>.</summary>
-        public static explicit operator System.Numerics.Vector3(Vector3I<T> v) =>
+        /// <summary>Explicitly casts a <see cref="Vector3D{T}"/> to <see cref="System.Numerics.Vector3"/>.</summary>
+        public static explicit operator System.Numerics.Vector3(Vector3D<T> v) =>
             new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
 
-        public static (Vector3I<T> Quotient, Vector3I<T> Remainder) DivRem(Vector3I<T> left, Vector3I<T> right)
+        public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem(Vector3D<T> left, Vector3D<T> right)
         {
             var (qX, rX) = T.DivRem(left.X, right.X);
             var (qY, rY) = T.DivRem(left.Y, right.Y);
             var (qZ, rZ) = T.DivRem(left.Z, right.Z);
-            return (new Vector3I<T>(qX, qY, qZ), new Vector3I<T>(rX, rY, rZ));
+            return (new Vector3D<T>(qX, qY, qZ), new Vector3D<T>(rX, rY, rZ));
         }
     }
 }
diff --git a/sources/Maths/Maths/Vector3F.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
similarity index 75%
rename from sources/Maths/Maths/Vector3F.gen.cs
rename to sources/Maths/Maths/Vector3D.gen.cs
index 2c0d24db9c..e894afc9a1 100644
--- a/sources/Maths/Maths/Vector3F.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -6,16 +6,16 @@ namespace Silk.NET.Maths
     using System.Runtime.InteropServices;
     using System.Text;
 
-    partial struct Vector3F<T> :
-        IEquatable<Vector3F<T>>,
+    public partial struct Vector3D<T> :
+        IEquatable<Vector3D<T>>,
         IReadOnlyList<T>,
         IFormattable,
-        IParsable<Vector3F<T>>,
+        IParsable<Vector3D<T>>,
         ISpanFormattable,
-        ISpanParsable<Vector3F<T>>,
+        ISpanParsable<Vector3D<T>>,
         IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector3F<T>>
-        where T : IFloatingPointIeee754<T>
+        IUtf8SpanParsable<Vector3D<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -27,16 +27,16 @@ partial struct Vector3F<T> :
         public T Z;
 
         /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector3F(T value) => (X, Y, Z) = (value, value, value);
+        public Vector3D(T value) => (X, Y, Z) = (value, value, value);
 
         /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector3F(T x, T y, T z) => (X, Y, Z) = (x, y, z);
+        public Vector3D(T x, T y, T z) => (X, Y, Z) = (x, y, z);
 
-        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
-        public Vector3F(Vector2F<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
+        /// <summary> Initializes the vector using a <see cref="Vector2D{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector3D(Vector2D<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
 
         /// <summary>Initializes the vector from a span of 3 values.</summary>
-        public Vector3F(ReadOnlySpan<T> values)
+        public Vector3D(ReadOnlySpan<T> values)
         {
             if (values.Length != 3)
                 throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
@@ -47,22 +47,22 @@ public Vector3F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3F<T> One => new(T.One);
+        public static Vector3D<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
-        public static Vector3F<T> Zero => default;
+        public static Vector3D<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3F<T> UnitX => new(T.One, T.Zero, T.Zero);
+        public static Vector3D<T> UnitX => new(T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3F<T> UnitY => new(T.Zero, T.One, T.Zero);
+        public static Vector3D<T> UnitY => new(T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3F<T> UnitZ => new(T.Zero, T.Zero, T.One);
+        public static Vector3D<T> UnitZ => new(T.Zero, T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector3F.Dot(this, this);
+        public T LengthSquared => Vector3D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -142,14 +142,14 @@ public override string ToString() =>
         public string ToString(string? format, IFormatProvider? formatProvider) =>
             $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
 
-        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static Vector3F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+        /// <summary>Parses a string to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static Vector3D<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
-        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static Vector3F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        /// <summary>Parses a span to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static Vector3D<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
         {
             if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector3F.");
+                throw new FormatException("Invalid format for Vector3D.");
 
             return result;
         }
@@ -241,8 +241,8 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
-        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        /// <summary>Tries to parse a span to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3D<T> result)
         {
             result = default;
 
@@ -270,15 +270,15 @@ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [Ma
                 T.TryParse(ySpan, provider, out var y) &&
                 T.TryParse(zSpan, provider, out var z))
             {
-                result = new Vector3F<T>(x, y, z);
+                result = new Vector3D<T>(x, y, z);
                 return true;
             }
 
             return false;
         }
 
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static Vector3F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static Vector3D<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -286,8 +286,8 @@ public static Vector3F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? pr
             return Parse(charBuffer, provider);
         }
 
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result)
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3D<T> result)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -295,31 +295,31 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
             return TryParse(charBuffer, provider, out result);
         }
 
-        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector3D{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3D<T> result) =>
             TryParse(s.AsSpan(), provider, out result);
 
-        /// <summary>Parses a span to a <see cref="Vector3F{T}"/> instance.</summary>
-        static Vector3F<T> ISpanParsable<Vector3F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+        /// <summary>Parses a span to a <see cref="Vector3D{T}"/> instance.</summary>
+        static Vector3D<T> ISpanParsable<Vector3D<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Parses a string to a <see cref="Vector3F{T}"/> instance.</summary>
-        static Vector3F<T> IParsable<Vector3F<T>>.Parse(string s, IFormatProvider? provider) =>
+        /// <summary>Parses a string to a <see cref="Vector3D{T}"/> instance.</summary>
+        static Vector3D<T> IParsable<Vector3D<T>>.Parse(string s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Tries to parse a span to a <see cref="Vector3F{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector3F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+        /// <summary>Tries to parse a span to a <see cref="Vector3D{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector3D<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3D<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary>Tries to parse a string to a <see cref="Vector3F{T}"/> instance.</summary>
-        static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector3D{T}"/> instance.</summary>
+        static bool IParsable<Vector3D<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3D<T> result) =>
             TryParse(s, provider, out result);
 
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector3F<T> left, Vector3F<T> right) =>
+        public static bool operator ==(Vector3D<T> left, Vector3D<T> right) =>
             left.X == right.X &&
             left.Y == right.Y &&
             left.Z == right.Z;
@@ -328,13 +328,13 @@ static bool IParsable<Vector3F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector3F<T> left, Vector3F<T> right) => !(left == right);
+        public static bool operator !=(Vector3D<T> left, Vector3D<T> right) => !(left == right);
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector3F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Vector3D<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Vector3F<T> other) => this == other;
+        public bool Equals(Vector3D<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
@@ -350,252 +350,263 @@ public void Deconstruct(out T x, out T y, out T z)
             z = Z;
         }
 
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3F{T}"/>.</summary>
-        public static implicit operator Vector3F<T>((T X, T Y, T Z) v) =>
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector3D<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y), TOther.CreateSaturating(Z));
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3D{T}"/>.</summary>
+        public static implicit operator Vector3D<T>((T X, T Y, T Z) v) =>
             new(v.X, v.Y, v.Z);
 
-        /// <summary>Implicitly casts a <see cref="Vector3F{T}"/> to a <see cref="ValueTuple{T, T, T}"/>.</summary>
-        public static implicit operator (T X, T Y, T Z)(Vector3F<T> v) =>
+        /// <summary>Implicitly casts a <see cref="Vector3D{T}"/> to a <see cref="ValueTuple{T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z)(Vector3D<T> v) =>
             (v.X, v.Y, v.Z);
 
-        public static Vector3F<T> operator +(Vector3F<T> vector) =>
+        public static Vector3D<T> operator +(Vector3D<T> vector) =>
             vector;
 
-        public static Vector3F<T> operator -(Vector3F<T> vector) =>
+        public static Vector3D<T> operator -(Vector3D<T> vector) =>
             new(-vector.X, -vector.Y, -vector.Z);
 
-        public static Vector3F<T> operator +(Vector3F<T> left, Vector3F<T> right) =>
+        public static Vector3D<T> operator +(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
 
-        public static Vector3F<T> operator -(Vector3F<T> left, Vector3F<T> right) =>
+        public static Vector3D<T> operator -(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
 
-        public static Vector3F<T> operator *(Vector3F<T> left, Vector3F<T> right) =>
+        public static Vector3D<T> operator *(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
 
-        public static Vector3F<T> operator /(Vector3F<T> left, Vector3F<T> right) =>
+        public static Vector3D<T> operator /(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
 
-        public static Vector3F<T> operator %(Vector3F<T> left, Vector3F<T> right) =>
-            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
-
-        public static Vector3F<T> operator +(Vector3F<T> vector, T scalar) =>
+        public static Vector3D<T> operator +(Vector3D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
 
-        public static Vector3F<T> operator -(Vector3F<T> vector, T scalar) =>
+        public static Vector3D<T> operator -(Vector3D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
 
-        public static Vector3F<T> operator *(Vector3F<T> vector, T scalar) =>
+        public static Vector3D<T> operator *(Vector3D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
 
-        public static Vector3F<T> operator *(T scalar, Vector3F<T> vector) =>
+        public static Vector3D<T> operator *(T scalar, Vector3D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
 
-        public static Vector3F<T> operator /(Vector3F<T> vector, T scalar) =>
+        public static Vector3D<T> operator /(Vector3D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
 
-        public static Vector3F<T> operator %(Vector3F<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
-
     }
 
-    static partial class Vector3F
+    public static partial class Vector3D
     {
         /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector3F<T> left, Vector3F<T> right)
-            where T : IFloatingPointIeee754<T> =>
+        public static T Dot<T>(this Vector3D<T> left, Vector3D<T> right)
+            where T : INumberBase<T> =>
             left.X * right.X + left.Y * right.Y + left.Z * right.Z;
 
         /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector3F<T> Reflect<T>(Vector3F<T> vector, Vector3F<T> normal)
-            where T : IFloatingPointIeee754<T>
+        public static Vector3D<T> Reflect<T>(Vector3D<T> vector, Vector3D<T> normal)
+            where T : INumberBase<T>
         {
             T dot = vector.Dot(normal);
             return vector - (normal * (dot + dot));
         }
 
         /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector3F<T> vector)
+        public static T GetLength<T>(this Vector3D<T> vector)
             where T : IFloatingPointIeee754<T> =>
             T.Sqrt(vector.LengthSquared);
 
         /// <summary>Normalizes a vector.</summary>
-        public static Vector3F<T> Normalize<T>(this Vector3F<T> vector)
+        public static Vector3D<T> Normalize<T>(this Vector3D<T> vector)
             where T : IFloatingPointIeee754<T>
         {
             T length = vector.GetLength();
-            return length != T.Zero ? vector / length : Vector3F<T>.Zero;
+            return length != T.Zero ? vector / length : Vector3D<T>.Zero;
         }
 
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector3I<int> Sign<TSelf>(this Vector3F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<int> Sign<TSelf>(this Vector3D<TSelf> value)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Max<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Max<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Max<TSelf>(this Vector3F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Max<TSelf>(this Vector3D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MaxNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MaxNumber<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MaxNumber<TSelf>(this Vector3F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MaxNumber<TSelf>(this Vector3D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Min<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Min<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Min<TSelf>(this Vector3F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Min<TSelf>(this Vector3D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MinNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MinNumber<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MinNumber<TSelf>(this Vector3F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MinNumber<TSelf>(this Vector3D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
         /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector3F<TSelf> Clamp<TSelf>(this Vector3F<TSelf> value, Vector3F<TSelf> min, Vector3F<TSelf> max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Clamp<TSelf>(this Vector3D<TSelf> value, Vector3D<TSelf> min, Vector3D<TSelf> max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A single value provided for <parameref name="min"/>.</param>
         /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector3F<TSelf> Clamp<TSelf>(this Vector3F<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Clamp<TSelf>(this Vector3D<TSelf> value, TSelf min, TSelf max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector3F<TSelf> CopySign<TSelf>(this Vector3F<TSelf> value, Vector3F<TSelf> sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> CopySign<TSelf>(this Vector3D<TSelf> value, Vector3D<TSelf> sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector3F<TSelf> CopySign<TSelf>(this Vector3F<TSelf> value, TSelf sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> CopySign<TSelf>(this Vector3D<TSelf> value, TSelf sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector3F<TSelf> Abs<TSelf>(this Vector3F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Abs<TSelf>(this Vector3D<TSelf> value)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MaxMagnitude<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MaxMagnitude<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MaxMagnitudeNumber<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MinMagnitude<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MinMagnitude<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> MinMagnitudeNumber<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> MinMagnitudeNumber<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.PopCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3D<TSelf> PopCount<TSelf>(this Vector3D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.PopCount(value.X), TSelf.PopCount(value.Y), TSelf.PopCount(value.Z));
+
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.TrailingZeroCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector3D<TSelf> TrailingZeroCount<TSelf>(this Vector3D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.TrailingZeroCount(value.X), TSelf.TrailingZeroCount(value.Y), TSelf.TrailingZeroCount(value.Z));
+
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Ceiling<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Ceiling<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y), TSelf.Ceiling(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Floor<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Floor<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Floor(x.X), TSelf.Floor(x.Y), TSelf.Floor(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Round<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Round<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X), TSelf.Round(x.Y), TSelf.Round(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
         /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
-        public static Vector3F<TSelf> Round<TSelf>(this Vector3F<TSelf> x, int digits, MidpointRounding mode)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Round<TSelf>(this Vector3D<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode), TSelf.Round(x.Z, digits, mode));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Truncate<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Truncate<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y), TSelf.Truncate(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Atan2<TSelf>(this Vector3F<TSelf> y, Vector3F<TSelf> x)
+        public static Vector3D<TSelf> Atan2<TSelf>(this Vector3D<TSelf> y, Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y), TSelf.Atan2(y.Z, x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Atan2Pi<TSelf>(this Vector3F<TSelf> y, Vector3F<TSelf> x)
+        public static Vector3D<TSelf> Atan2Pi<TSelf>(this Vector3D<TSelf> y, Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y), TSelf.Atan2Pi(y.Z, x.Z));
 
@@ -603,19 +614,19 @@ public static Vector3F<TSelf> Atan2Pi<TSelf>(this Vector3F<TSelf> y, Vector3F<TS
         /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
         /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
         /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
-        public static Vector3F<TSelf> Lerp<TSelf>(this Vector3F<TSelf> value1, Vector3F<TSelf> value2, TSelf amount)
+        public static Vector3D<TSelf> Lerp<TSelf>(this Vector3D<TSelf> value1, Vector3D<TSelf> value2, TSelf amount)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount), TSelf.Lerp(value1.Z, value2.Z, amount));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> BitDecrement<TSelf>(this Vector3F<TSelf> x)
+        public static Vector3D<TSelf> BitDecrement<TSelf>(this Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y), TSelf.BitDecrement(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> BitIncrement<TSelf>(this Vector3F<TSelf> x)
+        public static Vector3D<TSelf> BitIncrement<TSelf>(this Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y), TSelf.BitIncrement(x.Z));
 
@@ -623,7 +634,7 @@ public static Vector3F<TSelf> BitIncrement<TSelf>(this Vector3F<TSelf> x)
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
-        public static Vector3F<TSelf> FusedMultiplyAdd<TSelf>(this Vector3F<TSelf> left, Vector3F<TSelf> right, Vector3F<TSelf> addend)
+        public static Vector3D<TSelf> FusedMultiplyAdd<TSelf>(this Vector3D<TSelf> left, Vector3D<TSelf> right, Vector3D<TSelf> addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y), TSelf.FusedMultiplyAdd(left.Z, right.Z, addend.Z));
 
@@ -631,300 +642,300 @@ public static Vector3F<TSelf> FusedMultiplyAdd<TSelf>(this Vector3F<TSelf> left,
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
         /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
-        public static Vector3F<TSelf> FusedMultiplyAdd<TSelf>(this Vector3F<TSelf> left, TSelf right, TSelf addend)
+        public static Vector3D<TSelf> FusedMultiplyAdd<TSelf>(this Vector3D<TSelf> left, TSelf right, TSelf addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend), TSelf.FusedMultiplyAdd(left.Z, right, addend));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
-        public static Vector3F<TSelf> Ieee754Remainder<TSelf>(this Vector3F<TSelf> left, Vector3F<TSelf> right)
+        public static Vector3D<TSelf> Ieee754Remainder<TSelf>(this Vector3D<TSelf> left, Vector3D<TSelf> right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y), TSelf.Ieee754Remainder(left.Z, right.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
-        public static Vector3F<TSelf> Ieee754Remainder<TSelf>(this Vector3F<TSelf> left, TSelf right)
+        public static Vector3D<TSelf> Ieee754Remainder<TSelf>(this Vector3D<TSelf> left, TSelf right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right), TSelf.Ieee754Remainder(left.Z, right));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3I<int> ILogB<TSelf>(this Vector3F<TSelf> x)
+        public static Vector3D<int> ILogB<TSelf>(this Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y), TSelf.ILogB(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> ReciprocalEstimate<TSelf>(this Vector3F<TSelf> x)
+        public static Vector3D<TSelf> ReciprocalEstimate<TSelf>(this Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y), TSelf.ReciprocalEstimate(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector3F<TSelf> x)
+        public static Vector3D<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector3D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y), TSelf.ReciprocalSqrtEstimate(x.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector3F<TSelf> ScaleB<TSelf>(this Vector3F<TSelf> x, Vector3I<int> n)
+        public static Vector3D<TSelf> ScaleB<TSelf>(this Vector3D<TSelf> x, Vector3D<int> n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y), TSelf.ScaleB(x.Z, n.Z));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector3F<TSelf> ScaleB<TSelf>(this Vector3F<TSelf> x, int n)
+        public static Vector3D<TSelf> ScaleB<TSelf>(this Vector3D<TSelf> x, int n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n), TSelf.ScaleB(x.Z, n));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Pow<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Pow<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y), TSelf.Pow(x.Z, y.Z));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Pow<TSelf>(this Vector3F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Pow<TSelf>(this Vector3D<TSelf> x, TSelf y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y), TSelf.Pow(x.Z, y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Cbrt<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Cbrt<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y), TSelf.Cbrt(x.Z));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Sqrt<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Sqrt<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y), TSelf.Sqrt(x.Z));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector3F<TSelf> RootN<TSelf>(this Vector3F<TSelf> x, int n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> RootN<TSelf>(this Vector3D<TSelf> x, int n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n), TSelf.RootN(x.Z, n));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector3F<TSelf> RootN<TSelf>(this Vector3F<TSelf> x, Vector3I<int> n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> RootN<TSelf>(this Vector3D<TSelf> x, Vector3D<int> n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y), TSelf.RootN(x.Z, n.Z));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3F<TSelf> Hypot<TSelf>(this Vector3F<TSelf> x, Vector3F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Hypot<TSelf>(this Vector3D<TSelf> x, Vector3D<TSelf> y)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y), TSelf.Hypot(x.Z, y.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
-        public static Vector3F<TSelf> Log<TSelf>(this Vector3F<TSelf> x, TSelf newBase)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log<TSelf>(this Vector3D<TSelf> x, TSelf newBase)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase), TSelf.Log(x.Z, newBase));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> LogP1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> LogP1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Log2<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log2<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Log2P1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log2P1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Log10<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log10<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Log10P1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Log10P1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Exp<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Exp<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> ExpM1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> ExpM1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Exp2<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Exp2<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Exp2M1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Exp2M1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Exp10<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Exp10<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Exp10M1<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Exp10M1<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Acos<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Acos<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Acos(x.X), TSelf.Acos(x.Y), TSelf.Acos(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> AcosPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> AcosPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y), TSelf.AcosPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Asin<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Asin<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Asin(x.X), TSelf.Asin(x.Y), TSelf.Asin(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> AsinPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> AsinPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y), TSelf.AsinPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Atan<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Atan<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Atan(x.X), TSelf.Atan(x.Y), TSelf.Atan(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> AtanPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> AtanPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y), TSelf.AtanPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Cos<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Cos<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Cos(x.X), TSelf.Cos(x.Y), TSelf.Cos(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> CosPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> CosPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y), TSelf.CosPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Sin<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Sin<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Sin(x.X), TSelf.Sin(x.Y), TSelf.Sin(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> SinPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> SinPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y), TSelf.SinPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Tan<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Tan<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Tan(x.X), TSelf.Tan(x.Y), TSelf.Tan(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> TanPi<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> TanPi<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y), TSelf.TanPi(x.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
         /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
-        public static Vector3F<TSelf> DegreesToRadians<TSelf>(this Vector3F<TSelf> degrees)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> DegreesToRadians<TSelf>(this Vector3D<TSelf> degrees)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y), TSelf.DegreesToRadians(degrees.Z));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
         /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
-        public static Vector3F<TSelf> RadiansToDegrees<TSelf>(this Vector3F<TSelf> radians)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> RadiansToDegrees<TSelf>(this Vector3D<TSelf> radians)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y), TSelf.RadiansToDegrees(radians.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Acosh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Acosh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y), TSelf.Acosh(x.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Asinh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Asinh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y), TSelf.Asinh(x.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Atanh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Atanh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y), TSelf.Atanh(x.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Cosh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Cosh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y), TSelf.Cosh(x.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Sinh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Sinh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y), TSelf.Sinh(x.Z));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector3F<TSelf> Tanh<TSelf>(this Vector3F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector3D<TSelf> Tanh<TSelf>(this Vector3D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y), TSelf.Tanh(x.Z));
     }
 }
diff --git a/sources/Maths/Maths/Vector3I.gen.cs b/sources/Maths/Maths/Vector3I.gen.cs
deleted file mode 100644
index 197cb262d2..0000000000
--- a/sources/Maths/Maths/Vector3I.gen.cs
+++ /dev/null
@@ -1,581 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Collections;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-    using System.Runtime.InteropServices;
-    using System.Text;
-
-    partial struct Vector3I<T> :
-        IEquatable<Vector3I<T>>,
-        IReadOnlyList<T>,
-        IFormattable,
-        IParsable<Vector3I<T>>,
-        ISpanFormattable,
-        ISpanParsable<Vector3I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector3I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        public T Z;
-
-        /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector3I(T value) => (X, Y, Z) = (value, value, value);
-
-        /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector3I(T x, T y, T z) => (X, Y, Z) = (x, y, z);
-
-        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
-        public Vector3I(Vector2I<T> other, T z) => (X, Y, Z) = (other.X, other.Y, z);
-
-        /// <summary>Initializes the vector from a span of 3 values.</summary>
-        public Vector3I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 3)
-                throw new ArgumentException("Input span must contain exactly 3 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-        }
-
-        /// <summary>Gets a vector whose 3 elements are equal to one.</summary>
-        public static Vector3I<T> One => new(T.One);
-
-        /// <summary>Returns a vector whose 3 elements are equal to zero.</summary>
-        public static Vector3I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0).</summary>
-        public static Vector3I<T> UnitX => new(T.One, T.Zero, T.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0).</summary>
-        public static Vector3I<T> UnitY => new(T.Zero, T.One, T.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1).</summary>
-        public static Vector3I<T> UnitZ => new(T.Zero, T.Zero, T.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector3I<T> AllBitsSet => new Vector3I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector3I.Dot(this, this);
-
-        /// <inheritdoc/>
-        T IReadOnlyList<T>.this[int index] => this[index];
-
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z. </summary>
-        [UnscopedRef]
-        public ref T this[int index]
-        {
-            get
-            {
-                switch (index)
-                {
-                    case 0:
-                        return ref X;
-                    case 1:
-                        return ref Y;
-                    case 2:
-                        return ref Z;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-        }
-
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 3;
-
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-            yield return Z;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 3 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 3 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-        }
-
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 3);
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() =>
-            $"<{X}, {Y}, {Z}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}>";
-
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector3I.");
-
-            return result;
-        }
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 6 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaX = s.IndexOf(',');
-            if (commaX < 0)
-                return false;
-
-            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
-            int commaYRelative = remainder1.IndexOf(',');
-            if (commaYRelative < 0)
-                return false;
-            int commaY = commaX + 1 + commaYRelative;
-
-            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
-            ReadOnlySpan<char> zSpan = s[(commaY + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z))
-            {
-                result = new Vector3I<T>(x, y, z);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static Vector3I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> ISpanParsable<Vector3I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static Vector3I<T> IParsable<Vector3I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector3I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector3I{T}"/> instance.</summary>
-        static bool IParsable<Vector3I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector3I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector3I<T> left, Vector3I<T> right) =>
-            left.X == right.X &&
-            left.Y == right.Y &&
-            left.Z == right.Z;
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector3I<T> left, Vector3I<T> right) => !(left == right);
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector3I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Vector3I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(X, Y, Z);
-
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        /// <param name="z">The Z component.</param>
-        public void Deconstruct(out T x, out T y, out T z)
-        {
-            x = X;
-            y = Y;
-            z = Z;
-        }
-
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3I{T}"/>.</summary>
-        public static implicit operator Vector3I<T>((T X, T Y, T Z) v) =>
-            new(v.X, v.Y, v.Z);
-
-        /// <summary>Implicitly casts a <see cref="Vector3I{T}"/> to a <see cref="ValueTuple{T, T, T}"/>.</summary>
-        public static implicit operator (T X, T Y, T Z)(Vector3I<T> v) =>
-            (v.X, v.Y, v.Z);
-
-        public static Vector3I<T> operator +(Vector3I<T> vector) =>
-            vector;
-
-        public static Vector3I<T> operator -(Vector3I<T> vector) =>
-            new(-vector.X, -vector.Y, -vector.Z);
-
-        public static Vector3I<T> operator +(Vector3I<T> left, Vector3I<T> right) =>
-            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
-
-        public static Vector3I<T> operator -(Vector3I<T> left, Vector3I<T> right) =>
-            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
-
-        public static Vector3I<T> operator *(Vector3I<T> left, Vector3I<T> right) =>
-            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
-
-        public static Vector3I<T> operator /(Vector3I<T> left, Vector3I<T> right) =>
-            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
-
-        public static Vector3I<T> operator %(Vector3I<T> left, Vector3I<T> right) =>
-            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z);
-
-        public static Vector3I<T> operator +(Vector3I<T> vector, T scalar) =>
-            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
-
-        public static Vector3I<T> operator -(Vector3I<T> vector, T scalar) =>
-            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
-
-        public static Vector3I<T> operator *(Vector3I<T> vector, T scalar) =>
-            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
-
-        public static Vector3I<T> operator *(T scalar, Vector3I<T> vector) =>
-            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
-
-        public static Vector3I<T> operator /(Vector3I<T> vector, T scalar) =>
-            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
-
-        public static Vector3I<T> operator %(Vector3I<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar);
-
-        public static Vector3I<T> operator ~(Vector3I<T> vector) =>
-            new Vector3I<T>(~vector.X, ~vector.Y, ~vector.Z);
-
-        public static Vector3I<T> operator &(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> left, Vector3I<T> right) =>
-            new Vector3I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z);
-
-        public static Vector3I<T> operator &(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar);
-
-        public static Vector3I<T> operator &(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z);
-
-        public static Vector3I<T> operator |(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar);
-
-        public static Vector3I<T> operator |(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z);
-
-        public static Vector3I<T> operator ^(Vector3I<T> vector, T scalar) =>
-            new Vector3I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar);
-
-        public static Vector3I<T> operator ^(T scalar, Vector3I<T> vector) =>
-            new Vector3I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z);
-    }
-
-    static partial class Vector3I
-    {
-        /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector3I<T> left, Vector3I<T> right)
-            where T : IBinaryInteger<T> =>
-            left.X * right.X + left.Y * right.Y + left.Z * right.Z;
-
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector3I<T> Reflect<T>(Vector3I<T> vector, Vector3I<T> normal)
-            where T : IBinaryInteger<T>
-        {
-            T dot = vector.Dot(normal);
-            return vector - (normal * (dot + dot));
-        }
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector3I<int> Sign<TSelf>(this Vector3I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> Max<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> Max<TSelf>(this Vector3I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MaxNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MaxNumber<TSelf>(this Vector3I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> Min<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> Min<TSelf>(this Vector3I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MinNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MinNumber<TSelf>(this Vector3I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
-        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector3I<TSelf> Clamp<TSelf>(this Vector3I<TSelf> value, Vector3I<TSelf> min, Vector3I<TSelf> max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
-        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector3I<TSelf> Clamp<TSelf>(this Vector3I<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector3I<TSelf> CopySign<TSelf>(this Vector3I<TSelf> value, Vector3I<TSelf> sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector3I<TSelf> CopySign<TSelf>(this Vector3I<TSelf> value, TSelf sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector3I<TSelf> Abs<TSelf>(this Vector3I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MaxMagnitude<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MinMagnitude<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector3I<TSelf> MinMagnitudeNumber<TSelf>(this Vector3I<TSelf> x, Vector3I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z));
-
-        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector3I<TSelf> Log2<TSelf>(this Vector3I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Log2(value.X), TSelf.Log2(value.Y), TSelf.Log2(value.Z));
-    }
-}
diff --git a/sources/Maths/Maths/Vector4I.cs b/sources/Maths/Maths/Vector4D.cs
similarity index 69%
rename from sources/Maths/Maths/Vector4I.cs
rename to sources/Maths/Maths/Vector4D.cs
index 3b7442adbc..a50f79549d 100644
--- a/sources/Maths/Maths/Vector4I.cs
+++ b/sources/Maths/Maths/Vector4D.cs
@@ -11,25 +11,25 @@
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
-    internal partial struct Vector4I<T>
+    public partial struct Vector4D<T>
     {
         // Casts
 
-        /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4I.</summary>
-        public static explicit operator Vector4I<T>(System.Numerics.Vector4 v) =>
-            new Vector4I<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)), (T)Convert.ChangeType(v.W, typeof(T)));
+        /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4D.</summary>
+        public static explicit operator Vector4D<T>(System.Numerics.Vector4 v) =>
+            new Vector4D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)), (T)Convert.ChangeType(v.W, typeof(T)));
 
-        /// <summary>Explicitly casts a Vector4I to System.Numerics.Vector4.</summary>
-        public static explicit operator System.Numerics.Vector4(Vector4I<T> v) =>
+        /// <summary>Explicitly casts a Vector4D to System.Numerics.Vector4.</summary>
+        public static explicit operator System.Numerics.Vector4(Vector4D<T> v) =>
             new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
 
-        public static (Vector4I<T> Quotient, Vector4I<T> Remainder) DivRem(Vector4I<T> left, Vector4I<T> right)
+        public static (Vector4D<T> Quotient, Vector4D<T> Remainder) DivRem(Vector4D<T> left, Vector4D<T> right)
         {
             var (qX, rX) = T.DivRem(left.X, right.X);
             var (qY, rY) = T.DivRem(left.Y, right.Y);
             var (qZ, rZ) = T.DivRem(left.Z, right.Z);
             var (qW, rW) = T.DivRem(left.W, right.W);
-            return (new Vector4I<T>(qX, qY, qZ, qW), new Vector4I<T>(rX, rY, rZ, rW));
+            return (new Vector4D<T>(qX, qY, qZ, qW), new Vector4D<T>(rX, rY, rZ, rW));
         }
     }
 }
diff --git a/sources/Maths/Maths/Vector4F.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
similarity index 76%
rename from sources/Maths/Maths/Vector4F.gen.cs
rename to sources/Maths/Maths/Vector4D.gen.cs
index cd0dd8a87d..1cecb3c459 100644
--- a/sources/Maths/Maths/Vector4F.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -6,16 +6,16 @@ namespace Silk.NET.Maths
     using System.Runtime.InteropServices;
     using System.Text;
 
-    partial struct Vector4F<T> :
-        IEquatable<Vector4F<T>>,
+    public partial struct Vector4D<T> :
+        IEquatable<Vector4D<T>>,
         IReadOnlyList<T>,
         IFormattable,
-        IParsable<Vector4F<T>>,
+        IParsable<Vector4D<T>>,
         ISpanFormattable,
-        ISpanParsable<Vector4F<T>>,
+        ISpanParsable<Vector4D<T>>,
         IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector4F<T>>
-        where T : IFloatingPointIeee754<T>
+        IUtf8SpanParsable<Vector4D<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The X component of the vector.</summary>
         public T X;
@@ -30,19 +30,19 @@ partial struct Vector4F<T> :
         public T W;
 
         /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector4F(T value) => (X, Y, Z, W) = (value, value, value, value);
+        public Vector4D(T value) => (X, Y, Z, W) = (value, value, value, value);
 
         /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector4F(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
+        public Vector4D(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
 
-        /// <summary> Initializes the vector using a <see cref="Vector2F{T}"/> for the initial elements, and the specified components for the remainder. </summary>
-        public Vector4F(Vector2F<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
+        /// <summary> Initializes the vector using a <see cref="Vector2D{T}"/> for the initial elements, and the specified components for the remainder. </summary>
+        public Vector4D(Vector2D<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
 
-        /// <summary> Initializes the vector using a <see cref="Vector3F{T}"/> for the initial elements, and the specified component for the remainder. </summary>
-        public Vector4F(Vector3F<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
+        /// <summary> Initializes the vector using a <see cref="Vector3D{T}"/> for the initial elements, and the specified component for the remainder. </summary>
+        public Vector4D(Vector3D<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
 
         /// <summary>Initializes the vector from a span of 4 values.</summary>
-        public Vector4F(ReadOnlySpan<T> values)
+        public Vector4D(ReadOnlySpan<T> values)
         {
             if (values.Length != 4)
                 throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
@@ -54,25 +54,25 @@ public Vector4F(ReadOnlySpan<T> values)
         }
 
         /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4F<T> One => new(T.One);
+        public static Vector4D<T> One => new(T.One);
 
         /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
-        public static Vector4F<T> Zero => default;
+        public static Vector4D<T> Zero => default;
 
         /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4F<T> UnitX => new(T.One, T.Zero, T.Zero, T.Zero);
+        public static Vector4D<T> UnitX => new(T.One, T.Zero, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4F<T> UnitY => new(T.Zero, T.One, T.Zero, T.Zero);
+        public static Vector4D<T> UnitY => new(T.Zero, T.One, T.Zero, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4F<T> UnitZ => new(T.Zero, T.Zero, T.One, T.Zero);
+        public static Vector4D<T> UnitZ => new(T.Zero, T.Zero, T.One, T.Zero);
 
         /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4F<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
+        public static Vector4D<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
 
         /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector4F.Dot(this, this);
+        public T LengthSquared => Vector4D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -157,14 +157,14 @@ public override string ToString() =>
         public string ToString(string? format, IFormatProvider? formatProvider) =>
             $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
 
-        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static Vector4F<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
+        /// <summary>Parses a string to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static Vector4D<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
 
-        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static Vector4F<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
+        /// <summary>Parses a span to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static Vector4D<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
         {
             if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector4F.");
+                throw new FormatException("Invalid format for Vector4D.");
 
             return result;
         }
@@ -269,8 +269,8 @@ public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan
             return true;
         }
 
-        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        /// <summary>Tries to parse a span to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4D<T> result)
         {
             result = default;
 
@@ -306,15 +306,15 @@ public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [Ma
                 T.TryParse(zSpan, provider, out var z) &&
                 T.TryParse(wSpan, provider, out var w))
             {
-                result = new Vector4F<T>(x, y, z, w);
+                result = new Vector4D<T>(x, y, z, w);
                 return true;
             }
 
             return false;
         }
 
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static Vector4F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
+        /// <summary>Parses a UTF-8 span to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static Vector4D<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -322,8 +322,8 @@ public static Vector4F<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? pr
             return Parse(charBuffer, provider);
         }
 
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result)
+        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4D<T> result)
         {
             int charCount = Encoding.UTF8.GetCharCount(utf8Text);
             Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
@@ -331,31 +331,31 @@ public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provid
             return TryParse(charBuffer, provider, out result);
         }
 
-        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector4D{T}"/> instance.</summary>
+        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4D<T> result) =>
             TryParse(s.AsSpan(), provider, out result);
 
-        /// <summary>Parses a span to a <see cref="Vector4F{T}"/> instance.</summary>
-        static Vector4F<T> ISpanParsable<Vector4F<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
+        /// <summary>Parses a span to a <see cref="Vector4D{T}"/> instance.</summary>
+        static Vector4D<T> ISpanParsable<Vector4D<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Parses a string to a <see cref="Vector4F{T}"/> instance.</summary>
-        static Vector4F<T> IParsable<Vector4F<T>>.Parse(string s, IFormatProvider? provider) =>
+        /// <summary>Parses a string to a <see cref="Vector4D{T}"/> instance.</summary>
+        static Vector4D<T> IParsable<Vector4D<T>>.Parse(string s, IFormatProvider? provider) =>
             Parse(s, provider);
 
-        /// <summary>Tries to parse a span to a <see cref="Vector4F{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector4F<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+        /// <summary>Tries to parse a span to a <see cref="Vector4D{T}"/> instance.</summary>
+        static bool ISpanParsable<Vector4D<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4D<T> result) =>
             TryParse(s, provider, out result);
 
-        /// <summary>Tries to parse a string to a <see cref="Vector4F{T}"/> instance.</summary>
-        static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4F<T> result) =>
+        /// <summary>Tries to parse a string to a <see cref="Vector4D{T}"/> instance.</summary>
+        static bool IParsable<Vector4D<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4D<T> result) =>
             TryParse(s, provider, out result);
 
         /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector4F<T> left, Vector4F<T> right) =>
+        public static bool operator ==(Vector4D<T> left, Vector4D<T> right) =>
             left.X == right.X &&
             left.Y == right.Y &&
             left.Z == right.Z &&
@@ -365,13 +365,13 @@ static bool IParsable<Vector4F<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <param name="left">The first vector to compare.</param>
         /// <param name="right">The second vector to compare.</param>
         /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector4F<T> left, Vector4F<T> right) => !(left == right);
+        public static bool operator !=(Vector4D<T> left, Vector4D<T> right) => !(left == right);
 
         /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector4F<T> other && Equals(other);
+        public override bool Equals(object? obj) => obj is Vector4D<T> other && Equals(other);
 
         /// <inheridoc/>
-        public bool Equals(Vector4F<T> other) => this == other;
+        public bool Equals(Vector4D<T> other) => this == other;
 
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
@@ -389,252 +389,263 @@ public void Deconstruct(out T x, out T y, out T z, out T w)
             w = W;
         }
 
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4F{T}"/>.</summary>
-        public static implicit operator Vector4F<T>((T X, T Y, T Z, T W) v) =>
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector4D<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y), TOther.CreateSaturating(Z), TOther.CreateSaturating(W));
+
+        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4D{T}"/>.</summary>
+        public static implicit operator Vector4D<T>((T X, T Y, T Z, T W) v) =>
             new(v.X, v.Y, v.Z, v.W);
 
-        /// <summary>Implicitly casts a <see cref="Vector4F{T}"/> to a <see cref="ValueTuple{T, T, T, T}"/>.</summary>
-        public static implicit operator (T X, T Y, T Z, T W)(Vector4F<T> v) =>
+        /// <summary>Implicitly casts a <see cref="Vector4D{T}"/> to a <see cref="ValueTuple{T, T, T, T}"/>.</summary>
+        public static implicit operator (T X, T Y, T Z, T W)(Vector4D<T> v) =>
             (v.X, v.Y, v.Z, v.W);
 
-        public static Vector4F<T> operator +(Vector4F<T> vector) =>
+        public static Vector4D<T> operator +(Vector4D<T> vector) =>
             vector;
 
-        public static Vector4F<T> operator -(Vector4F<T> vector) =>
+        public static Vector4D<T> operator -(Vector4D<T> vector) =>
             new(-vector.X, -vector.Y, -vector.Z, -vector.W);
 
-        public static Vector4F<T> operator +(Vector4F<T> left, Vector4F<T> right) =>
+        public static Vector4D<T> operator +(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
 
-        public static Vector4F<T> operator -(Vector4F<T> left, Vector4F<T> right) =>
+        public static Vector4D<T> operator -(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
 
-        public static Vector4F<T> operator *(Vector4F<T> left, Vector4F<T> right) =>
+        public static Vector4D<T> operator *(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
 
-        public static Vector4F<T> operator /(Vector4F<T> left, Vector4F<T> right) =>
+        public static Vector4D<T> operator /(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
 
-        public static Vector4F<T> operator %(Vector4F<T> left, Vector4F<T> right) =>
-            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
-
-        public static Vector4F<T> operator +(Vector4F<T> vector, T scalar) =>
+        public static Vector4D<T> operator +(Vector4D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
 
-        public static Vector4F<T> operator -(Vector4F<T> vector, T scalar) =>
+        public static Vector4D<T> operator -(Vector4D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
 
-        public static Vector4F<T> operator *(Vector4F<T> vector, T scalar) =>
+        public static Vector4D<T> operator *(Vector4D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
 
-        public static Vector4F<T> operator *(T scalar, Vector4F<T> vector) =>
+        public static Vector4D<T> operator *(T scalar, Vector4D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
 
-        public static Vector4F<T> operator /(Vector4F<T> vector, T scalar) =>
+        public static Vector4D<T> operator /(Vector4D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
 
-        public static Vector4F<T> operator %(Vector4F<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
-
     }
 
-    static partial class Vector4F
+    public static partial class Vector4D
     {
         /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector4F<T> left, Vector4F<T> right)
-            where T : IFloatingPointIeee754<T> =>
+        public static T Dot<T>(this Vector4D<T> left, Vector4D<T> right)
+            where T : INumberBase<T> =>
             left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
 
         /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector4F<T> Reflect<T>(Vector4F<T> vector, Vector4F<T> normal)
-            where T : IFloatingPointIeee754<T>
+        public static Vector4D<T> Reflect<T>(Vector4D<T> vector, Vector4D<T> normal)
+            where T : INumberBase<T>
         {
             T dot = vector.Dot(normal);
             return vector - (normal * (dot + dot));
         }
 
         /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector4F<T> vector)
+        public static T GetLength<T>(this Vector4D<T> vector)
             where T : IFloatingPointIeee754<T> =>
             T.Sqrt(vector.LengthSquared);
 
         /// <summary>Normalizes a vector.</summary>
-        public static Vector4F<T> Normalize<T>(this Vector4F<T> vector)
+        public static Vector4D<T> Normalize<T>(this Vector4D<T> vector)
             where T : IFloatingPointIeee754<T>
         {
             T length = vector.GetLength();
-            return length != T.Zero ? vector / length : Vector4F<T>.Zero;
+            return length != T.Zero ? vector / length : Vector4D<T>.Zero;
         }
 
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector4I<int> Sign<TSelf>(this Vector4F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<int> Sign<TSelf>(this Vector4D<TSelf> value)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z), TSelf.Sign(value.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Max<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Max<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z), TSelf.Max(x.W, y.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Max<TSelf>(this Vector4F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Max<TSelf>(this Vector4D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y), TSelf.Max(x.W, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MaxNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MaxNumber<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z), TSelf.MaxNumber(x.W, y.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MaxNumber<TSelf>(this Vector4F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MaxNumber<TSelf>(this Vector4D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y), TSelf.MaxNumber(x.W, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Min<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Min<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z), TSelf.Min(x.W, y.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Min<TSelf>(this Vector4F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Min<TSelf>(this Vector4D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y), TSelf.Min(x.W, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MinNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MinNumber<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z), TSelf.MinNumber(x.W, y.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MinNumber<TSelf>(this Vector4F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MinNumber<TSelf>(this Vector4D<TSelf> x, TSelf y)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y), TSelf.MinNumber(x.W, y));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
         /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector4F<TSelf> Clamp<TSelf>(this Vector4F<TSelf> value, Vector4F<TSelf> min, Vector4F<TSelf> max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Clamp<TSelf>(this Vector4D<TSelf> value, Vector4D<TSelf> min, Vector4D<TSelf> max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z), TSelf.Clamp(value.W, min.W, max.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="min">A single value provided for <parameref name="min"/>.</param>
         /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector4F<TSelf> Clamp<TSelf>(this Vector4F<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Clamp<TSelf>(this Vector4D<TSelf> value, TSelf min, TSelf max)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max), TSelf.Clamp(value.W, min, max));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector4F<TSelf> CopySign<TSelf>(this Vector4F<TSelf> value, Vector4F<TSelf> sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> CopySign<TSelf>(this Vector4D<TSelf> value, Vector4D<TSelf> sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z), TSelf.CopySign(value.W, sign.W));
 
         /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector4F<TSelf> CopySign<TSelf>(this Vector4F<TSelf> value, TSelf sign)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> CopySign<TSelf>(this Vector4D<TSelf> value, TSelf sign)
+            where TSelf : INumber<TSelf> =>
             new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign), TSelf.CopySign(value.W, sign));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector4F<TSelf> Abs<TSelf>(this Vector4F<TSelf> value)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Abs<TSelf>(this Vector4D<TSelf> value)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z), TSelf.Abs(value.W));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MaxMagnitude<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MaxMagnitude<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z), TSelf.MaxMagnitude(x.W, y.W));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MaxMagnitudeNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MaxMagnitudeNumber<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z), TSelf.MaxMagnitudeNumber(x.W, y.W));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MinMagnitude<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MinMagnitude<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z), TSelf.MinMagnitude(x.W, y.W));
 
         /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> MinMagnitudeNumber<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> MinMagnitudeNumber<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : INumberBase<TSelf> =>
             new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z), TSelf.MinMagnitudeNumber(x.W, y.W));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.PopCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4D<TSelf> PopCount<TSelf>(this Vector4D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.PopCount(value.X), TSelf.PopCount(value.Y), TSelf.PopCount(value.Z), TSelf.PopCount(value.W));
+
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.TrailingZeroCount(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
+        public static Vector4D<TSelf> TrailingZeroCount<TSelf>(this Vector4D<TSelf> value)
+            where TSelf : IBinaryInteger<TSelf> =>
+            new(TSelf.TrailingZeroCount(value.X), TSelf.TrailingZeroCount(value.Y), TSelf.TrailingZeroCount(value.Z), TSelf.TrailingZeroCount(value.W));
+
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Ceiling(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Ceiling<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Ceiling<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Ceiling(x.X), TSelf.Ceiling(x.Y), TSelf.Ceiling(x.Z), TSelf.Ceiling(x.W));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Floor(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Floor<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Floor<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Floor(x.X), TSelf.Floor(x.Y), TSelf.Floor(x.Z), TSelf.Floor(x.W));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Round<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Round<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X), TSelf.Round(x.Y), TSelf.Round(x.Z), TSelf.Round(x.W));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Round(TSelf, int, MidpointRounding)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="digits">A single value provided for <parameref name="digits"/>.</param>
         /// <param name="mode">A single value provided for <parameref name="mode"/>.</param>
-        public static Vector4F<TSelf> Round<TSelf>(this Vector4F<TSelf> x, int digits, MidpointRounding mode)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Round<TSelf>(this Vector4D<TSelf> x, int digits, MidpointRounding mode)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Round(x.X, digits, mode), TSelf.Round(x.Y, digits, mode), TSelf.Round(x.Z, digits, mode), TSelf.Round(x.W, digits, mode));
 
         /// <summary>Applies <see cref="IFloatingPoint{TSelf}.Truncate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Truncate<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Truncate<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IFloatingPoint<TSelf> =>
             new(TSelf.Truncate(x.X), TSelf.Truncate(x.Y), TSelf.Truncate(x.Z), TSelf.Truncate(x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Atan2<TSelf>(this Vector4F<TSelf> y, Vector4F<TSelf> x)
+        public static Vector4D<TSelf> Atan2<TSelf>(this Vector4D<TSelf> y, Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2(y.X, x.X), TSelf.Atan2(y.Y, x.Y), TSelf.Atan2(y.Z, x.Z), TSelf.Atan2(y.W, x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Atan2Pi(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Atan2Pi<TSelf>(this Vector4F<TSelf> y, Vector4F<TSelf> x)
+        public static Vector4D<TSelf> Atan2Pi<TSelf>(this Vector4D<TSelf> y, Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Atan2Pi(y.X, x.X), TSelf.Atan2Pi(y.Y, x.Y), TSelf.Atan2Pi(y.Z, x.Z), TSelf.Atan2Pi(y.W, x.W));
 
@@ -642,19 +653,19 @@ public static Vector4F<TSelf> Atan2Pi<TSelf>(this Vector4F<TSelf> y, Vector4F<TS
         /// <param name="value1">A vector whose members will be provided for <parameref name="value1"/>.</param>
         /// <param name="value2">A vector whose members will be provided for <parameref name="value2"/>.</param>
         /// <param name="amount">A single value provided for <parameref name="amount"/>.</param>
-        public static Vector4F<TSelf> Lerp<TSelf>(this Vector4F<TSelf> value1, Vector4F<TSelf> value2, TSelf amount)
+        public static Vector4D<TSelf> Lerp<TSelf>(this Vector4D<TSelf> value1, Vector4D<TSelf> value2, TSelf amount)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Lerp(value1.X, value2.X, amount), TSelf.Lerp(value1.Y, value2.Y, amount), TSelf.Lerp(value1.Z, value2.Z, amount), TSelf.Lerp(value1.W, value2.W, amount));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitDecrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> BitDecrement<TSelf>(this Vector4F<TSelf> x)
+        public static Vector4D<TSelf> BitDecrement<TSelf>(this Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitDecrement(x.X), TSelf.BitDecrement(x.Y), TSelf.BitDecrement(x.Z), TSelf.BitDecrement(x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.BitIncrement(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> BitIncrement<TSelf>(this Vector4F<TSelf> x)
+        public static Vector4D<TSelf> BitIncrement<TSelf>(this Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.BitIncrement(x.X), TSelf.BitIncrement(x.Y), TSelf.BitIncrement(x.Z), TSelf.BitIncrement(x.W));
 
@@ -662,7 +673,7 @@ public static Vector4F<TSelf> BitIncrement<TSelf>(this Vector4F<TSelf> x)
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         /// <param name="addend">A vector whose members will be provided for <parameref name="addend"/>.</param>
-        public static Vector4F<TSelf> FusedMultiplyAdd<TSelf>(this Vector4F<TSelf> left, Vector4F<TSelf> right, Vector4F<TSelf> addend)
+        public static Vector4D<TSelf> FusedMultiplyAdd<TSelf>(this Vector4D<TSelf> left, Vector4D<TSelf> right, Vector4D<TSelf> addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right.X, addend.X), TSelf.FusedMultiplyAdd(left.Y, right.Y, addend.Y), TSelf.FusedMultiplyAdd(left.Z, right.Z, addend.Z), TSelf.FusedMultiplyAdd(left.W, right.W, addend.W));
 
@@ -670,300 +681,300 @@ public static Vector4F<TSelf> FusedMultiplyAdd<TSelf>(this Vector4F<TSelf> left,
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
         /// <param name="addend">A single value provided for <parameref name="addend"/>.</param>
-        public static Vector4F<TSelf> FusedMultiplyAdd<TSelf>(this Vector4F<TSelf> left, TSelf right, TSelf addend)
+        public static Vector4D<TSelf> FusedMultiplyAdd<TSelf>(this Vector4D<TSelf> left, TSelf right, TSelf addend)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.FusedMultiplyAdd(left.X, right, addend), TSelf.FusedMultiplyAdd(left.Y, right, addend), TSelf.FusedMultiplyAdd(left.Z, right, addend), TSelf.FusedMultiplyAdd(left.W, right, addend));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
-        public static Vector4F<TSelf> Ieee754Remainder<TSelf>(this Vector4F<TSelf> left, Vector4F<TSelf> right)
+        public static Vector4D<TSelf> Ieee754Remainder<TSelf>(this Vector4D<TSelf> left, Vector4D<TSelf> right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right.X), TSelf.Ieee754Remainder(left.Y, right.Y), TSelf.Ieee754Remainder(left.Z, right.Z), TSelf.Ieee754Remainder(left.W, right.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.Ieee754Remainder(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
         /// <param name="right">A single value provided for <parameref name="right"/>.</param>
-        public static Vector4F<TSelf> Ieee754Remainder<TSelf>(this Vector4F<TSelf> left, TSelf right)
+        public static Vector4D<TSelf> Ieee754Remainder<TSelf>(this Vector4D<TSelf> left, TSelf right)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.Ieee754Remainder(left.X, right), TSelf.Ieee754Remainder(left.Y, right), TSelf.Ieee754Remainder(left.Z, right), TSelf.Ieee754Remainder(left.W, right));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ILogB(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4I<int> ILogB<TSelf>(this Vector4F<TSelf> x)
+        public static Vector4D<int> ILogB<TSelf>(this Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ILogB(x.X), TSelf.ILogB(x.Y), TSelf.ILogB(x.Z), TSelf.ILogB(x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> ReciprocalEstimate<TSelf>(this Vector4F<TSelf> x)
+        public static Vector4D<TSelf> ReciprocalEstimate<TSelf>(this Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalEstimate(x.X), TSelf.ReciprocalEstimate(x.Y), TSelf.ReciprocalEstimate(x.Z), TSelf.ReciprocalEstimate(x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ReciprocalSqrtEstimate(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector4F<TSelf> x)
+        public static Vector4D<TSelf> ReciprocalSqrtEstimate<TSelf>(this Vector4D<TSelf> x)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ReciprocalSqrtEstimate(x.X), TSelf.ReciprocalSqrtEstimate(x.Y), TSelf.ReciprocalSqrtEstimate(x.Z), TSelf.ReciprocalSqrtEstimate(x.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector4F<TSelf> ScaleB<TSelf>(this Vector4F<TSelf> x, Vector4I<int> n)
+        public static Vector4D<TSelf> ScaleB<TSelf>(this Vector4D<TSelf> x, Vector4D<int> n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n.X), TSelf.ScaleB(x.Y, n.Y), TSelf.ScaleB(x.Z, n.Z), TSelf.ScaleB(x.W, n.W));
 
         /// <summary>Applies <see cref="IFloatingPointIeee754{TSelf}.ScaleB(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector4F<TSelf> ScaleB<TSelf>(this Vector4F<TSelf> x, int n)
+        public static Vector4D<TSelf> ScaleB<TSelf>(this Vector4D<TSelf> x, int n)
             where TSelf : IFloatingPointIeee754<TSelf> =>
             new(TSelf.ScaleB(x.X, n), TSelf.ScaleB(x.Y, n), TSelf.ScaleB(x.Z, n), TSelf.ScaleB(x.W, n));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Pow<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Pow<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y.X), TSelf.Pow(x.Y, y.Y), TSelf.Pow(x.Z, y.Z), TSelf.Pow(x.W, y.W));
 
         /// <summary>Applies <see cref="IPowerFunctions{TSelf}.Pow(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Pow<TSelf>(this Vector4F<TSelf> x, TSelf y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Pow<TSelf>(this Vector4D<TSelf> x, TSelf y)
+            where TSelf : IPowerFunctions<TSelf> =>
             new(TSelf.Pow(x.X, y), TSelf.Pow(x.Y, y), TSelf.Pow(x.Z, y), TSelf.Pow(x.W, y));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Cbrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Cbrt<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Cbrt<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Cbrt(x.X), TSelf.Cbrt(x.Y), TSelf.Cbrt(x.Z), TSelf.Cbrt(x.W));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Sqrt(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Sqrt<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Sqrt<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Sqrt(x.X), TSelf.Sqrt(x.Y), TSelf.Sqrt(x.Z), TSelf.Sqrt(x.W));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A single value provided for <parameref name="n"/>.</param>
-        public static Vector4F<TSelf> RootN<TSelf>(this Vector4F<TSelf> x, int n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> RootN<TSelf>(this Vector4D<TSelf> x, int n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n), TSelf.RootN(x.Y, n), TSelf.RootN(x.Z, n), TSelf.RootN(x.W, n));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.RootN(TSelf, int)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="n">A vector whose members will be provided for <parameref name="n"/>.</param>
-        public static Vector4F<TSelf> RootN<TSelf>(this Vector4F<TSelf> x, Vector4I<int> n)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> RootN<TSelf>(this Vector4D<TSelf> x, Vector4D<int> n)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.RootN(x.X, n.X), TSelf.RootN(x.Y, n.Y), TSelf.RootN(x.Z, n.Z), TSelf.RootN(x.W, n.W));
 
         /// <summary>Applies <see cref="IRootFunctions{TSelf}.Hypot(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4F<TSelf> Hypot<TSelf>(this Vector4F<TSelf> x, Vector4F<TSelf> y)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Hypot<TSelf>(this Vector4D<TSelf> x, Vector4D<TSelf> y)
+            where TSelf : IRootFunctions<TSelf> =>
             new(TSelf.Hypot(x.X, y.X), TSelf.Hypot(x.Y, y.Y), TSelf.Hypot(x.Z, y.Z), TSelf.Hypot(x.W, y.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X), TSelf.Log(x.Y), TSelf.Log(x.Z), TSelf.Log(x.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log(TSelf, TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         /// <param name="newBase">A single value provided for <parameref name="newBase"/>.</param>
-        public static Vector4F<TSelf> Log<TSelf>(this Vector4F<TSelf> x, TSelf newBase)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log<TSelf>(this Vector4D<TSelf> x, TSelf newBase)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log(x.X, newBase), TSelf.Log(x.Y, newBase), TSelf.Log(x.Z, newBase), TSelf.Log(x.W, newBase));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.LogP1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> LogP1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> LogP1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.LogP1(x.X), TSelf.LogP1(x.Y), TSelf.LogP1(x.Z), TSelf.LogP1(x.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Log2<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log2<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2(x.X), TSelf.Log2(x.Y), TSelf.Log2(x.Z), TSelf.Log2(x.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log2P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Log2P1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log2P1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log2P1(x.X), TSelf.Log2P1(x.Y), TSelf.Log2P1(x.Z), TSelf.Log2P1(x.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Log10<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log10<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10(x.X), TSelf.Log10(x.Y), TSelf.Log10(x.Z), TSelf.Log10(x.W));
 
         /// <summary>Applies <see cref="ILogarithmicFunctions{TSelf}.Log10P1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Log10P1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Log10P1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ILogarithmicFunctions<TSelf> =>
             new(TSelf.Log10P1(x.X), TSelf.Log10P1(x.Y), TSelf.Log10P1(x.Z), TSelf.Log10P1(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Exp<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Exp<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp(x.X), TSelf.Exp(x.Y), TSelf.Exp(x.Z), TSelf.Exp(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.ExpM1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> ExpM1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> ExpM1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.ExpM1(x.X), TSelf.ExpM1(x.Y), TSelf.ExpM1(x.Z), TSelf.ExpM1(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Exp2<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Exp2<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2(x.X), TSelf.Exp2(x.Y), TSelf.Exp2(x.Z), TSelf.Exp2(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp2M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Exp2M1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Exp2M1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp2M1(x.X), TSelf.Exp2M1(x.Y), TSelf.Exp2M1(x.Z), TSelf.Exp2M1(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Exp10<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Exp10<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10(x.X), TSelf.Exp10(x.Y), TSelf.Exp10(x.Z), TSelf.Exp10(x.W));
 
         /// <summary>Applies <see cref="IExponentialFunctions{TSelf}.Exp10M1(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Exp10M1<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Exp10M1<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IExponentialFunctions<TSelf> =>
             new(TSelf.Exp10M1(x.X), TSelf.Exp10M1(x.Y), TSelf.Exp10M1(x.Z), TSelf.Exp10M1(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Acos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Acos<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Acos<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Acos(x.X), TSelf.Acos(x.Y), TSelf.Acos(x.Z), TSelf.Acos(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AcosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> AcosPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> AcosPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AcosPi(x.X), TSelf.AcosPi(x.Y), TSelf.AcosPi(x.Z), TSelf.AcosPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Asin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Asin<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Asin<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Asin(x.X), TSelf.Asin(x.Y), TSelf.Asin(x.Z), TSelf.Asin(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AsinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> AsinPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> AsinPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AsinPi(x.X), TSelf.AsinPi(x.Y), TSelf.AsinPi(x.Z), TSelf.AsinPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Atan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Atan<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Atan<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Atan(x.X), TSelf.Atan(x.Y), TSelf.Atan(x.Z), TSelf.Atan(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.AtanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> AtanPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> AtanPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.AtanPi(x.X), TSelf.AtanPi(x.Y), TSelf.AtanPi(x.Z), TSelf.AtanPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Cos(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Cos<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Cos<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Cos(x.X), TSelf.Cos(x.Y), TSelf.Cos(x.Z), TSelf.Cos(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.CosPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> CosPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> CosPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.CosPi(x.X), TSelf.CosPi(x.Y), TSelf.CosPi(x.Z), TSelf.CosPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Sin(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Sin<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Sin<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Sin(x.X), TSelf.Sin(x.Y), TSelf.Sin(x.Z), TSelf.Sin(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> SinPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> SinPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.SinPi(x.X), TSelf.SinPi(x.Y), TSelf.SinPi(x.Z), TSelf.SinPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.Tan(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Tan<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Tan<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.Tan(x.X), TSelf.Tan(x.Y), TSelf.Tan(x.Z), TSelf.Tan(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.TanPi(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> TanPi<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> TanPi<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.TanPi(x.X), TSelf.TanPi(x.Y), TSelf.TanPi(x.Z), TSelf.TanPi(x.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.DegreesToRadians(TSelf)"/> to the provided arguments.</summary>
         /// <param name="degrees">A vector whose members will be provided for <parameref name="degrees"/>.</param>
-        public static Vector4F<TSelf> DegreesToRadians<TSelf>(this Vector4F<TSelf> degrees)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> DegreesToRadians<TSelf>(this Vector4D<TSelf> degrees)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.DegreesToRadians(degrees.X), TSelf.DegreesToRadians(degrees.Y), TSelf.DegreesToRadians(degrees.Z), TSelf.DegreesToRadians(degrees.W));
 
         /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.RadiansToDegrees(TSelf)"/> to the provided arguments.</summary>
         /// <param name="radians">A vector whose members will be provided for <parameref name="radians"/>.</param>
-        public static Vector4F<TSelf> RadiansToDegrees<TSelf>(this Vector4F<TSelf> radians)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> RadiansToDegrees<TSelf>(this Vector4D<TSelf> radians)
+            where TSelf : ITrigonometricFunctions<TSelf> =>
             new(TSelf.RadiansToDegrees(radians.X), TSelf.RadiansToDegrees(radians.Y), TSelf.RadiansToDegrees(radians.Z), TSelf.RadiansToDegrees(radians.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Acosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Acosh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Acosh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Acosh(x.X), TSelf.Acosh(x.Y), TSelf.Acosh(x.Z), TSelf.Acosh(x.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Asinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Asinh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Asinh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Asinh(x.X), TSelf.Asinh(x.Y), TSelf.Asinh(x.Z), TSelf.Asinh(x.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Atanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Atanh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Atanh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Atanh(x.X), TSelf.Atanh(x.Y), TSelf.Atanh(x.Z), TSelf.Atanh(x.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Cosh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Cosh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Cosh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Cosh(x.X), TSelf.Cosh(x.Y), TSelf.Cosh(x.Z), TSelf.Cosh(x.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Sinh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Sinh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Sinh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Sinh(x.X), TSelf.Sinh(x.Y), TSelf.Sinh(x.Z), TSelf.Sinh(x.W));
 
         /// <summary>Applies <see cref="IHyperbolicFunctions{TSelf}.Tanh(TSelf)"/> to the provided arguments.</summary>
         /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        public static Vector4F<TSelf> Tanh<TSelf>(this Vector4F<TSelf> x)
-            where TSelf : IFloatingPointIeee754<TSelf> =>
+        public static Vector4D<TSelf> Tanh<TSelf>(this Vector4D<TSelf> x)
+            where TSelf : IHyperbolicFunctions<TSelf> =>
             new(TSelf.Tanh(x.X), TSelf.Tanh(x.Y), TSelf.Tanh(x.Z), TSelf.Tanh(x.W));
     }
 }
diff --git a/sources/Maths/Maths/Vector4I.gen.cs b/sources/Maths/Maths/Vector4I.gen.cs
deleted file mode 100644
index b87494d968..0000000000
--- a/sources/Maths/Maths/Vector4I.gen.cs
+++ /dev/null
@@ -1,620 +0,0 @@
-namespace Silk.NET.Maths
-{
-    using System.Collections;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Numerics;
-    using System.Runtime.InteropServices;
-    using System.Text;
-
-    partial struct Vector4I<T> :
-        IEquatable<Vector4I<T>>,
-        IReadOnlyList<T>,
-        IFormattable,
-        IParsable<Vector4I<T>>,
-        ISpanFormattable,
-        ISpanParsable<Vector4I<T>>,
-        IUtf8SpanFormattable,
-        IUtf8SpanParsable<Vector4I<T>>
-        where T : IBinaryInteger<T>
-    {
-        /// <summary>The X component of the vector.</summary>
-        public T X;
-
-        /// <summary>The Y component of the vector.</summary>
-        public T Y;
-
-        /// <summary>The Z component of the vector.</summary>
-        public T Z;
-
-        /// <summary>The W component of the vector.</summary>
-        public T W;
-
-        /// <summary>Initializes all components of the vector to the same value.</summary>
-        public Vector4I(T value) => (X, Y, Z, W) = (value, value, value, value);
-
-        /// <summary>Initializes the vector with individual component values.</summary>
-        public Vector4I(T x, T y, T z, T w) => (X, Y, Z, W) = (x, y, z, w);
-
-        /// <summary> Initializes the vector using a <see cref="Vector2I{T}"/> for the initial elements, and the specified components for the remainder. </summary>
-        public Vector4I(Vector2I<T> other, T z, T w) => (X, Y, Z, W) = (other.X, other.Y, z, w);
-
-        /// <summary> Initializes the vector using a <see cref="Vector3I{T}"/> for the initial elements, and the specified component for the remainder. </summary>
-        public Vector4I(Vector3I<T> other, T w) => (X, Y, Z, W) = (other.X, other.Y, other.Z, w);
-
-        /// <summary>Initializes the vector from a span of 4 values.</summary>
-        public Vector4I(ReadOnlySpan<T> values)
-        {
-            if (values.Length != 4)
-                throw new ArgumentException("Input span must contain exactly 4 elements.", nameof(values));
-
-            X = values[0];
-            Y = values[1];
-            Z = values[2];
-            W = values[3];
-        }
-
-        /// <summary>Gets a vector whose 4 elements are equal to one.</summary>
-        public static Vector4I<T> One => new(T.One);
-
-        /// <summary>Returns a vector whose 4 elements are equal to zero.</summary>
-        public static Vector4I<T> Zero => default;
-
-        /// <summary>Gets the vector (1, 0, 0, 0).</summary>
-        public static Vector4I<T> UnitX => new(T.One, T.Zero, T.Zero, T.Zero);
-
-        /// <summary>Gets the vector (0, 1, 0, 0).</summary>
-        public static Vector4I<T> UnitY => new(T.Zero, T.One, T.Zero, T.Zero);
-
-        /// <summary>Gets the vector (0, 0, 1, 0).</summary>
-        public static Vector4I<T> UnitZ => new(T.Zero, T.Zero, T.One, T.Zero);
-
-        /// <summary>Gets the vector (0, 0, 0, 1).</summary>
-        public static Vector4I<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
-
-        /// <summary>Gets a vector with all bits set for each component.</summary>
-        public static Vector4I<T> AllBitsSet => new Vector4I<T>(T.AllBitsSet, T.AllBitsSet, T.AllBitsSet, T.AllBitsSet);
-
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector4I.Dot(this, this);
-
-        /// <inheritdoc/>
-        T IReadOnlyList<T>.this[int index] => this[index];
-
-        ///<summary>Gets the component at the specified index: 0 = X, 1 = Y, 2 = Z, 3 = W. </summary>
-        [UnscopedRef]
-        public ref T this[int index]
-        {
-            get
-            {
-                switch (index)
-                {
-                    case 0:
-                        return ref X;
-                    case 1:
-                        return ref Y;
-                    case 2:
-                        return ref Z;
-                    case 3:
-                        return ref W;
-                }
-
-                throw new ArgumentOutOfRangeException(nameof(index));
-            }
-        }
-
-        /// <summary>The number of elements in the vector.</summary>
-        public int Count => 4;
-
-        /// <inheritdoc/>
-        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-        /// <summary> Returns an enumerator that iterates through the vector components.</summary>
-        public IEnumerator<T> GetEnumerator()
-        {
-            yield return X;
-            yield return Y;
-            yield return Z;
-            yield return W;
-        }
-
-        /// <summary>Copies the components of the vector to the specified array starting at index 0.</summary>
-        public void CopyTo(T[] array) => CopyTo(array, 0);
-
-        /// <summary>Copies the components of the vector to the specified array starting at the given index.</summary>
-        public void CopyTo(T[] array, int startIndex)
-        {
-            if (array == null)
-                throw new ArgumentNullException(nameof(array));
-            if (startIndex < 0 || startIndex + 4 > array.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            array[startIndex] = X;
-            array[startIndex + 1] = Y;
-            array[startIndex + 2] = Z;
-            array[startIndex + 3] = W;
-        }
-
-        /// <summary>Copies the components of the vector to the specified span starting at index 0.</summary>
-        public void CopyTo(Span<T> span) => CopyTo(span, 0);
-
-        /// <summary>Copies the components of the vector to the specified span starting at the given index.</summary>
-        public void CopyTo(Span<T> span, int startIndex)
-        {
-            if (startIndex < 0 || startIndex + 4 > span.Length)
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-
-            span[startIndex] = X;
-            span[startIndex + 1] = Y;
-            span[startIndex + 2] = Z;
-            span[startIndex + 3] = W;
-        }
-
-        /// <summary>Returns a span over the vector components.</summary>
-        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref X, 4);
-
-        /// <summary>Formats the vector as a string.</summary>
-        public override string ToString() =>
-            $"<{X}, {Y}, {Z}, {W}>";
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public string ToString(string? format, IFormatProvider? formatProvider) =>
-            $"<{X.ToString(format, formatProvider)}, {Y.ToString(format, formatProvider)}, {Z.ToString(format, formatProvider)}, {W.ToString(format, formatProvider)}>";
-
-        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static Vector4I<T> Parse(string s, IFormatProvider? provider) => Parse(s.AsSpan(), provider);
-
-        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<char> s, IFormatProvider? provider)
-        {
-            if (!TryParse(s, provider, out var result))
-                throw new FormatException("Invalid format for Vector4I.");
-
-            return result;
-        }
-
-        /// <summary>Formats the vector as a UTF-8 string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<byte> utf8Destination, out int bytesWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider)||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider)||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider)||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int estimatedSize = Encoding.UTF8.GetByteCount(xBuffer[..xChars]) +
-                                Encoding.UTF8.GetByteCount(yBuffer[..yChars]) +
-                                Encoding.UTF8.GetByteCount(zBuffer[..zChars]) +
-                                Encoding.UTF8.GetByteCount(wBuffer[..wChars]) +
-                                Encoding.UTF8.GetByteCount("<, >");
-
-            if (utf8Destination.Length < estimatedSize)
-            {
-                bytesWritten = 0;
-                return false;
-            }
-
-            int totalBytes = 0;
-
-            totalBytes += Encoding.UTF8.GetBytes("<", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(xBuffer[..xChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(yBuffer[..yChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(zBuffer[..zChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(", ", utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(wBuffer[..wChars], utf8Destination[totalBytes..]);
-            totalBytes += Encoding.UTF8.GetBytes(">", utf8Destination[totalBytes..]);
-
-            bytesWritten = totalBytes;
-            return true;
-        }
-
-        /// <summary>Formats the vector as a string using the specified format and format provider.</summary>
-        public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider? provider)
-        {
-            Span<char> xBuffer = stackalloc char[64];
-            Span<char> yBuffer = stackalloc char[64];
-            Span<char> zBuffer = stackalloc char[64];
-            Span<char> wBuffer = stackalloc char[64];
-
-            if (!X.TryFormat(xBuffer, out int xChars, format, provider) ||
-                !Y.TryFormat(yBuffer, out int yChars, format, provider) ||
-                !Z.TryFormat(zBuffer, out int zChars, format, provider) ||
-                !W.TryFormat(wBuffer, out int wChars, format, provider))
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int requiredLength = 1 + xChars + 2 + yChars + 2 + zChars + 2 + wChars + 1;
-
-            if (destination.Length < requiredLength)
-            {
-                charsWritten = 0;
-                return false;
-            }
-
-            int pos = 0;
-            destination[pos++] = '<';
-
-            xBuffer[..xChars].CopyTo(destination[pos..]);
-            pos += xChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            yBuffer[..yChars].CopyTo(destination[pos..]);
-            pos += yChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            zBuffer[..zChars].CopyTo(destination[pos..]);
-            pos += zChars;
-
-            destination[pos++] = ',';
-            destination[pos++] = ' ';
-
-            wBuffer[..wChars].CopyTo(destination[pos..]);
-            pos += wChars;
-
-            destination[pos++] = '>';
-
-            charsWritten = pos;
-            return true;
-        }
-
-        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            result = default;
-
-            s = s.Trim();
-            if (s.Length < 8 || s[0] != '<' || s[^1] != '>')
-                return false;
-
-            s = s[1..^1]; // Remove < and >
-
-            int commaX = s.IndexOf(',');
-            if (commaX < 0)
-                return false;
-
-            ReadOnlySpan<char> remainder1 = s.Slice(commaX + 1);
-            int commaYRelative = remainder1.IndexOf(',');
-            if (commaYRelative < 0)
-                return false;
-            int commaY = commaX + 1 + commaYRelative;
-
-            ReadOnlySpan<char> remainder2 = s.Slice(commaY + 1);
-            int commaZRelative = remainder2.IndexOf(',');
-            if (commaZRelative < 0)
-                return false;
-            int commaZ = commaY + 1 + commaZRelative;
-
-            ReadOnlySpan<char> xSpan = s[..commaX].Trim();
-            ReadOnlySpan<char> ySpan = s[(commaX + 1)..commaY].Trim();
-            ReadOnlySpan<char> zSpan = s[(commaY + 1)..commaZ].Trim();
-            ReadOnlySpan<char> wSpan = s[(commaZ + 1)..].Trim();
-
-            if (T.TryParse(xSpan, provider, out var x) &&
-                T.TryParse(ySpan, provider, out var y) &&
-                T.TryParse(zSpan, provider, out var z) &&
-                T.TryParse(wSpan, provider, out var w))
-            {
-                result = new Vector4I<T>(x, y, z, w);
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>Parses a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static Vector4I<T> Parse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return Parse(charBuffer, provider);
-        }
-
-        /// <summary>Tries to parse a UTF-8 span to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static bool TryParse(ReadOnlySpan<byte> utf8Text, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result)
-        {
-            int charCount = Encoding.UTF8.GetCharCount(utf8Text);
-            Span<char> charBuffer = charCount <= 128 ? stackalloc char[charCount] : new char[charCount];
-            Encoding.UTF8.GetChars(utf8Text, charBuffer);
-            return TryParse(charBuffer, provider, out result);
-        }
-
-        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
-        public static bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s.AsSpan(), provider, out result);
-
-        /// <summary>Parses a span to a <see cref="Vector4I{T}"/> instance.</summary>
-        static Vector4I<T> ISpanParsable<Vector4I<T>>.Parse(ReadOnlySpan<char> s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Parses a string to a <see cref="Vector4I{T}"/> instance.</summary>
-        static Vector4I<T> IParsable<Vector4I<T>>.Parse(string s, IFormatProvider? provider) =>
-            Parse(s, provider);
-
-        /// <summary>Tries to parse a span to a <see cref="Vector4I{T}"/> instance.</summary>
-        static bool ISpanParsable<Vector4I<T>>.TryParse(ReadOnlySpan<char> s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Tries to parse a string to a <see cref="Vector4I{T}"/> instance.</summary>
-        static bool IParsable<Vector4I<T>>.TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out Vector4I<T> result) =>
-            TryParse(s, provider, out result);
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are equal; <c>false</c> otherwise.</returns>
-        public static bool operator ==(Vector4I<T> left, Vector4I<T> right) =>
-            left.X == right.X &&
-            left.Y == right.Y &&
-            left.Z == right.Z &&
-            left.W == right.W;
-
-        /// <summary>Returns a boolean indicating whether the given two vectors are not equal.</summary>
-        /// <param name="left">The first vector to compare.</param>
-        /// <param name="right">The second vector to compare.</param>
-        /// <returns><c>true</c> if the given vectors are not equal; <c>false</c> otherwise.</returns>
-        public static bool operator !=(Vector4I<T> left, Vector4I<T> right) => !(left == right);
-
-        /// <inheridoc/>
-        public override bool Equals(object? obj) => obj is Vector4I<T> other && Equals(other);
-
-        /// <inheridoc/>
-        public bool Equals(Vector4I<T> other) => this == other;
-
-        /// <inheridoc/>
-        public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
-
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        /// <param name="z">The Z component.</param>
-        /// <param name="w">The W component.</param>
-        public void Deconstruct(out T x, out T y, out T z, out T w)
-        {
-            x = X;
-            y = Y;
-            z = Z;
-            w = W;
-        }
-
-        /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4I{T}"/>.</summary>
-        public static implicit operator Vector4I<T>((T X, T Y, T Z, T W) v) =>
-            new(v.X, v.Y, v.Z, v.W);
-
-        /// <summary>Implicitly casts a <see cref="Vector4I{T}"/> to a <see cref="ValueTuple{T, T, T, T}"/>.</summary>
-        public static implicit operator (T X, T Y, T Z, T W)(Vector4I<T> v) =>
-            (v.X, v.Y, v.Z, v.W);
-
-        public static Vector4I<T> operator +(Vector4I<T> vector) =>
-            vector;
-
-        public static Vector4I<T> operator -(Vector4I<T> vector) =>
-            new(-vector.X, -vector.Y, -vector.Z, -vector.W);
-
-        public static Vector4I<T> operator +(Vector4I<T> left, Vector4I<T> right) =>
-            new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
-
-        public static Vector4I<T> operator -(Vector4I<T> left, Vector4I<T> right) =>
-            new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
-
-        public static Vector4I<T> operator *(Vector4I<T> left, Vector4I<T> right) =>
-            new(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
-
-        public static Vector4I<T> operator /(Vector4I<T> left, Vector4I<T> right) =>
-            new(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
-
-        public static Vector4I<T> operator %(Vector4I<T> left, Vector4I<T> right) =>
-            new(left.X % right.X, left.Y % right.Y, left.Z % right.Z, left.W % right.W);
-
-        public static Vector4I<T> operator +(Vector4I<T> vector, T scalar) =>
-            new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
-
-        public static Vector4I<T> operator -(Vector4I<T> vector, T scalar) =>
-            new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
-
-        public static Vector4I<T> operator *(Vector4I<T> vector, T scalar) =>
-            new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
-
-        public static Vector4I<T> operator *(T scalar, Vector4I<T> vector) =>
-            new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
-
-        public static Vector4I<T> operator /(Vector4I<T> vector, T scalar) =>
-            new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
-
-        public static Vector4I<T> operator %(Vector4I<T> vector, T scalar) =>
-            new(vector.X % scalar, vector.Y % scalar, vector.Z % scalar, vector.W % scalar);
-
-        public static Vector4I<T> operator ~(Vector4I<T> vector) =>
-            new Vector4I<T>(~vector.X, ~vector.Y, ~vector.Z, ~vector.W);
-
-        public static Vector4I<T> operator &(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X & right.X, left.Y & right.Y, left.Z & right.Z, left.W & right.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X | right.X, left.Y | right.Y, left.Z | right.Z, left.W | right.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> left, Vector4I<T> right) =>
-            new Vector4I<T>(left.X ^ right.X, left.Y ^ right.Y, left.Z ^ right.Z, left.W ^ right.W);
-
-        public static Vector4I<T> operator &(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X & scalar, vector.Y & scalar, vector.Z & scalar, vector.W & scalar);
-
-        public static Vector4I<T> operator &(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar & vector.X, scalar & vector.Y, scalar & vector.Z, scalar & vector.W);
-
-        public static Vector4I<T> operator |(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X | scalar, vector.Y | scalar, vector.Z | scalar, vector.W | scalar);
-
-        public static Vector4I<T> operator |(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar | vector.X, scalar | vector.Y, scalar | vector.Z, scalar | vector.W);
-
-        public static Vector4I<T> operator ^(Vector4I<T> vector, T scalar) =>
-            new Vector4I<T>(vector.X ^ scalar, vector.Y ^ scalar, vector.Z ^ scalar, vector.W ^ scalar);
-
-        public static Vector4I<T> operator ^(T scalar, Vector4I<T> vector) =>
-            new Vector4I<T>(scalar ^ vector.X, scalar ^ vector.Y, scalar ^ vector.Z, scalar ^ vector.W);
-    }
-
-    static partial class Vector4I
-    {
-        /// <summary>Computes the dot product of two vectors.</summary>
-        public static T Dot<T>(this Vector4I<T> left, Vector4I<T> right)
-            where T : IBinaryInteger<T> =>
-            left.X * right.X + left.Y * right.Y + left.Z * right.Z + left.W * right.W;
-
-        /// <summary>Reflects a vector over a normal vector.</summary>
-        public static Vector4I<T> Reflect<T>(Vector4I<T> vector, Vector4I<T> normal)
-            where T : IBinaryInteger<T>
-        {
-            T dot = vector.Dot(normal);
-            return vector - (normal * (dot + dot));
-        }
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector4I<int> Sign<TSelf>(this Vector4I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Sign(value.X), TSelf.Sign(value.Y), TSelf.Sign(value.Z), TSelf.Sign(value.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> Max<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y.X), TSelf.Max(x.Y, y.Y), TSelf.Max(x.Z, y.Z), TSelf.Max(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Max(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> Max<TSelf>(this Vector4I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Max(x.X, y), TSelf.Max(x.Y, y), TSelf.Max(x.Z, y), TSelf.Max(x.W, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MaxNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y.X), TSelf.MaxNumber(x.Y, y.Y), TSelf.MaxNumber(x.Z, y.Z), TSelf.MaxNumber(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MaxNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MaxNumber<TSelf>(this Vector4I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxNumber(x.X, y), TSelf.MaxNumber(x.Y, y), TSelf.MaxNumber(x.Z, y), TSelf.MaxNumber(x.W, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> Min<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y.X), TSelf.Min(x.Y, y.Y), TSelf.Min(x.Z, y.Z), TSelf.Min(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Min(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> Min<TSelf>(this Vector4I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Min(x.X, y), TSelf.Min(x.Y, y), TSelf.Min(x.Z, y), TSelf.Min(x.W, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MinNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y.X), TSelf.MinNumber(x.Y, y.Y), TSelf.MinNumber(x.Z, y.Z), TSelf.MinNumber(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.MinNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A single value provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MinNumber<TSelf>(this Vector4I<TSelf> x, TSelf y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinNumber(x.X, y), TSelf.MinNumber(x.Y, y), TSelf.MinNumber(x.Z, y), TSelf.MinNumber(x.W, y));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A vector whose members will be provided for <parameref name="min"/>.</param>
-        /// <param name="max">A vector whose members will be provided for <parameref name="max"/>.</param>
-        public static Vector4I<TSelf> Clamp<TSelf>(this Vector4I<TSelf> value, Vector4I<TSelf> min, Vector4I<TSelf> max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min.X, max.X), TSelf.Clamp(value.Y, min.Y, max.Y), TSelf.Clamp(value.Z, min.Z, max.Z), TSelf.Clamp(value.W, min.W, max.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.Clamp(TSelf, TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="min">A single value provided for <parameref name="min"/>.</param>
-        /// <param name="max">A single value provided for <parameref name="max"/>.</param>
-        public static Vector4I<TSelf> Clamp<TSelf>(this Vector4I<TSelf> value, TSelf min, TSelf max)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Clamp(value.X, min, max), TSelf.Clamp(value.Y, min, max), TSelf.Clamp(value.Z, min, max), TSelf.Clamp(value.W, min, max));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A vector whose members will be provided for <parameref name="sign"/>.</param>
-        public static Vector4I<TSelf> CopySign<TSelf>(this Vector4I<TSelf> value, Vector4I<TSelf> sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign.X), TSelf.CopySign(value.Y, sign.Y), TSelf.CopySign(value.Z, sign.Z), TSelf.CopySign(value.W, sign.W));
-
-        /// <summary>Applies <see cref="INumber{TSelf}.CopySign(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        /// <param name="sign">A single value provided for <parameref name="sign"/>.</param>
-        public static Vector4I<TSelf> CopySign<TSelf>(this Vector4I<TSelf> value, TSelf sign)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.CopySign(value.X, sign), TSelf.CopySign(value.Y, sign), TSelf.CopySign(value.Z, sign), TSelf.CopySign(value.W, sign));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.Abs(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector4I<TSelf> Abs<TSelf>(this Vector4I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Abs(value.X), TSelf.Abs(value.Y), TSelf.Abs(value.Z), TSelf.Abs(value.W));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MaxMagnitude<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitude(x.X, y.X), TSelf.MaxMagnitude(x.Y, y.Y), TSelf.MaxMagnitude(x.Z, y.Z), TSelf.MaxMagnitude(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MaxMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MaxMagnitudeNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MaxMagnitudeNumber(x.X, y.X), TSelf.MaxMagnitudeNumber(x.Y, y.Y), TSelf.MaxMagnitudeNumber(x.Z, y.Z), TSelf.MaxMagnitudeNumber(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitude(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MinMagnitude<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitude(x.X, y.X), TSelf.MinMagnitude(x.Y, y.Y), TSelf.MinMagnitude(x.Z, y.Z), TSelf.MinMagnitude(x.W, y.W));
-
-        /// <summary>Applies <see cref="INumberBase{TSelf}.MinMagnitudeNumber(TSelf, TSelf)"/> to the provided arguments.</summary>
-        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
-        /// <param name="y">A vector whose members will be provided for <parameref name="y"/>.</param>
-        public static Vector4I<TSelf> MinMagnitudeNumber<TSelf>(this Vector4I<TSelf> x, Vector4I<TSelf> y)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.MinMagnitudeNumber(x.X, y.X), TSelf.MinMagnitudeNumber(x.Y, y.Y), TSelf.MinMagnitudeNumber(x.Z, y.Z), TSelf.MinMagnitudeNumber(x.W, y.W));
-
-        /// <summary>Applies <see cref="IBinaryNumber{TSelf}.Log2(TSelf)"/> to the provided arguments.</summary>
-        /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
-        public static Vector4I<TSelf> Log2<TSelf>(this Vector4I<TSelf> value)
-            where TSelf : IBinaryInteger<TSelf> =>
-            new(TSelf.Log2(value.X), TSelf.Log2(value.Y), TSelf.Log2(value.Z), TSelf.Log2(value.W));
-    }
-}

From aefd7eaf161db8cce54453f9ffb8d84cba64fc11 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Mon, 30 Jun 2025 19:45:07 -0700
Subject: [PATCH 36/52] Merge matrix types.

---
 sources/Maths/Maths/Matrix2X2.Ops.cs |  50 ++--
 sources/Maths/Maths/Matrix2X2.cs     | 208 +------------
 sources/Maths/Maths/Matrix2X2.gen.cs |  53 +++-
 sources/Maths/Maths/Matrix2X3.Ops.cs |  41 +--
 sources/Maths/Maths/Matrix2X3.cs     | 243 +--------------
 sources/Maths/Maths/Matrix2X3.gen.cs |  57 +++-
 sources/Maths/Maths/Matrix2X4.Ops.cs |  32 +-
 sources/Maths/Maths/Matrix2X4.cs     | 277 +-----------------
 sources/Maths/Maths/Matrix2X4.gen.cs |  63 +++-
 sources/Maths/Maths/Matrix3X2.Ops.cs |  66 ++---
 sources/Maths/Maths/Matrix3X2.cs     | 240 +--------------
 sources/Maths/Maths/Matrix3X2.gen.cs |  58 +++-
 sources/Maths/Maths/Matrix3X3.Ops.cs |  72 ++---
 sources/Maths/Maths/Matrix3X3.cs     | 279 +-----------------
 sources/Maths/Maths/Matrix3X3.gen.cs |  67 ++++-
 sources/Maths/Maths/Matrix3X4.Ops.cs |  38 +--
 sources/Maths/Maths/Matrix3X4.cs     | 319 +-------------------
 sources/Maths/Maths/Matrix3X4.gen.cs |  72 ++++-
 sources/Maths/Maths/Matrix4X2.Ops.cs |  45 +--
 sources/Maths/Maths/Matrix4X2.cs     | 295 +------------------
 sources/Maths/Maths/Matrix4X2.gen.cs |  65 +++-
 sources/Maths/Maths/Matrix4X3.Ops.cs |  39 +--
 sources/Maths/Maths/Matrix4X3.cs     | 328 +--------------------
 sources/Maths/Maths/Matrix4X3.gen.cs |  73 ++++-
 sources/Maths/Maths/Matrix4X4.Ops.cs | 115 ++++----
 sources/Maths/Maths/Matrix4X4.cs     | 423 +--------------------------
 sources/Maths/Maths/Matrix4X4.gen.cs | 309 +++++++++++++++++++
 sources/Maths/Maths/Matrix5X4.Ops.cs |  30 +-
 sources/Maths/Maths/Matrix5X4.cs     | 402 +------------------------
 sources/Maths/Maths/Matrix5X4.gen.cs |  74 ++++-
 30 files changed, 1075 insertions(+), 3358 deletions(-)
 create mode 100644 sources/Maths/Maths/Matrix4X4.gen.cs

diff --git a/sources/Maths/Maths/Matrix2X2.Ops.cs b/sources/Maths/Maths/Matrix2X2.Ops.cs
index 0d768ab0ce..e7f5828da8 100644
--- a/sources/Maths/Maths/Matrix2X2.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X2.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,14 +10,15 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix2X2{T}"/>
     /// </summary>
-    public static class Matrix2X2
+    public static partial class Matrix2X2
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Add<T>(Matrix2X2<T> value1, Matrix2X2<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        public static Matrix2X2<T> Add<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -26,68 +28,54 @@ public static Matrix2X2<T> Add<T>(Matrix2X2<T> value1, Matrix2X2<T> value2) wher
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X2<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 * value2;
+        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
+            where T : INumberBase<T> => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 * value2;
+        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2)
+            where T : INumberBase<T> => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 * value2;
+        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2)
+            where T : INumberBase<T> => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, T value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 * value2;
+        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, T value2)
+            where T : INumberBase<T> => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 * value2;
+        public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2)
+            where T : INumberBase<T> => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
         /// <param name="value">The source matrix.</param>
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Negate<T>(Matrix2X2<T> value) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => -value;
+        public static Matrix2X2<T> Negate<T>(Matrix2X2<T> value)
+            where T : INumberBase<T> => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Subtract<T>(Matrix2X2<T> value1, Matrix2X2<T> value2) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T> => value1 - value2;
-
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix2X2<T> Lerp<T>(Matrix2X2<T> matrix1, Matrix2X2<T> matrix2, T amount) where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            Matrix2X2<T> result = default;
-
-            // First row
-            result.M11 = Scalar.Add(matrix1.M11, Scalar.Multiply(Scalar.Subtract(matrix2.M11, matrix1.M11), amount));
-            result.M12 = Scalar.Add(matrix1.M12, Scalar.Multiply(Scalar.Subtract(matrix2.M12, matrix1.M12), amount));
-
-            // Second row
-            result.M21 = Scalar.Add(matrix1.M21, Scalar.Multiply(Scalar.Subtract(matrix2.M21, matrix1.M21), amount));
-            result.M22 = Scalar.Add(matrix1.M22, Scalar.Multiply(Scalar.Subtract(matrix2.M22, matrix1.M22), amount));
-
-            return result;
-        }
+        public static Matrix2X2<T> Subtract<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
+            where T : INumberBase<T> => value1 - value2;
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2X2.cs b/sources/Maths/Maths/Matrix2X2.cs
index e01fcf288f..50bde7046e 100644
--- a/sources/Maths/Maths/Matrix2X2.cs
+++ b/sources/Maths/Maths/Matrix2X2.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,117 +12,8 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 2x2 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix2X2<T> : IEquatable<Matrix2X2<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix2X2<T>
     {
-        private static readonly Matrix2X2<T> _identity = new(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.One);
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row1;
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row2;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column1 => new(M11, M21);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column2 => new(M12, M22);
-
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector2D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 1 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>Constructs a <see cref="Matrix2X2{T}"/> from the given components.</summary>
-        public Matrix2X2(T m11, T m12, T m21, T m22)
-        {
-            Row1 = new(m11, m12);
-            Row2 = new(m21, m22);
-        }
-
-        /// <summary>Constructs a <see cref="Matrix2X2{T}"/> from the given rows.</summary>
-        public Matrix2X2(Vector2D<T> row1, Vector2D<T> row2)
-        {
-            Row1 = row1;
-            Row2 = row2;
-        }
-
         /// <summary>Constructs a <see cref="Matrix2X2{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix2X2(Matrix3X2<T> value)
@@ -162,63 +54,12 @@ public Matrix2X2(Matrix4X2<T> value)
             Row2 = new(value.M21, value.M22);
         }
 
-        /// <summary>Returns the multiplicative identity matrix.</summary>
-        public static Matrix2X2<T> Identity => _identity;
-
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         public readonly bool IsIdentity
             => Scalar.Equal(M11, Scalar<T>.One) &&
                Scalar.Equal(M22, Scalar<T>.One) && // Check diagonal element first for early out.
                Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix2X2<T> operator +(Matrix2X2<T> value1, Matrix2X2<T> value2)
-        {
-            Matrix2X2<T> m;
-
-            m.Row1 = value1.Row1 + value2.Row1;
-            m.Row2 = value1.Row2 + value2.Row2;
-
-            return m;
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix2X2<T> value1, Matrix2X2<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M21, value2.M21);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix2X2<T> value1, Matrix2X2<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) ||
-                   Scalar.NotEqual(value1.M22, value2.M22) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M21, value2.M21);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X2<T> operator *(Matrix2X2<T> value1, Matrix2X2<T> value2)
-        {
-            return new
-            (
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2, value1.M21 * value2.Row1 + value1.M22 * value2.Row2
-            );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -237,23 +78,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix2X2<T> operator -(Matrix2X2<T> value1, Matrix2X2<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix2X2<T> operator -(Matrix2X2<T> value)
-        {
-            return new(-value.Row1, -value.Row2);
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -267,32 +91,6 @@ public readonly T GetDeterminant()
             return Scalar.Subtract(Scalar.Multiply(a, d), Scalar.Multiply(b, c));
         }
 
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj) => (obj is Matrix2X2<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix2X2<T> other) => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-
-            hash.Add(M21);
-            hash.Add(M22);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -414,7 +212,7 @@ public static explicit operator Matrix2X2<long>(Matrix2X2<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix2X2<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix2X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index fb351734b6..d1bffe8d59 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -2,27 +2,55 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix2X2<T> :
         IEquatable<Matrix2X2<T>>
         where T : INumberBase<T>
     {
         /// <summary>The multiplicative identity matrix of size 2x2.</summary>
-        public static readonly Matrix2X2<T> Identity = new(
+        public static Matrix2X2<T> Identity { get; } = new(
             new(T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.MultiplicativeIdentity));
 
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row2;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column1 => new(Row1.X, Row2.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column2 => new(Row1.Y, Row2.Y);
+
         /// <summary>
         /// Constructs a <see cref="Matrix2X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix2X2(Vector2D<T> row1, Vector2D<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X2(Vector2D<T> row1, Vector2D<T> row2) =>
+            (Row1, Row2) = (row1, row2);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix2X2{T}"/> from the given components.
+        /// </summary>
+        public Matrix2X2(
+            T m11, T m12,
+            T m21, T m22)
+        {
+            Row1 = new(m11, m12);
+            Row2 = new(m21, m22);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector2D<T> this[int row]
         {
@@ -36,30 +64,40 @@ public ref Vector2D<T> this[int row]
                         return ref Row2;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -121,9 +159,14 @@ public Matrix2X2<T> Transpose() =>
 
     public static partial class Matrix2X2
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix2X2<T> Lerp<T>(Matrix2X2<T> value1, Matrix2X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)));
+            new(Vector2D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector2D.Lerp(value1.Row2, value2.Row2, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index 6ebb6124ca..cd5d662780 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix2X3{T}"/>
     /// </summary>
-    public static class Matrix2X3
+    public static partial class Matrix2X3
     {
         private const float BillboardEpsilon = 1e-4f;
 
@@ -19,7 +20,7 @@ public static class Matrix2X3
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Add<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -31,7 +32,7 @@ public static Matrix2X3<T> Add<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix2X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
@@ -56,7 +57,7 @@ public static Matrix2X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector
         /// <param name="angle">The angle to rotate around the given axis, in radians.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix2X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // a: angle
             // x, y, z: unit vector for axis.
@@ -105,7 +106,7 @@ public static Matrix2X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix2X3<T> result = Matrix2X3<T>.Identity;
 
@@ -138,7 +139,7 @@ public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
@@ -150,7 +151,7 @@ public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -160,7 +161,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -169,7 +170,7 @@ public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -178,7 +179,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -187,7 +188,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, T value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector3D<T> Multiply<T>(Vector2D<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -195,7 +196,7 @@ public static Vector3D<T> Multiply<T>(Vector2D<T> value1, Matrix2X3<T> value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Negate<T>(Matrix2X3<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -204,27 +205,15 @@ public static Matrix2X3<T> Negate<T>(Matrix2X3<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Subtract<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
 
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix2X3<T> Lerp<T>(Matrix2X3<T> matrix1, Matrix2X3<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(Vector3D.Lerp(matrix1.Row1, matrix2.Row2, amount), Vector3D.Lerp(matrix1.Row2, matrix2.Row2, amount));
-        }
-
         /// <summary>Transforms the given matrix by applying the given Quaternion rotation.</summary>
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
         public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index 87bdfc4701..63e4bc944b 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,8 +12,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 2x3 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix2X3<T> : IEquatable<Matrix2X3<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix2X3<T>
     {
         private static readonly Matrix2X3<T> _identity = new
         (
@@ -20,136 +20,6 @@ public struct Matrix2X3<T> : IEquatable<Matrix2X3<T>>
             Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row2;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column1 => new Vector2D<T>(M11, M21);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column2 => new Vector2D<T>(M12, M22);
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column3 => new Vector2D<T>(M13, M23);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector3D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 1 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>Constructs a <see cref="Matrix2X3{T}"/> from the given components.</summary>
-        public Matrix2X3(T m11, T m12, T m13,
-                         T m21, T m22, T m23)
-        {
-            Row1 = new(m11, m12, m13);
-            Row2 = new(m21, m22, m23);
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix2X3{T}"/> from the given rows.
-        /// </summary>
-        public Matrix2X3(Vector3D<T> row1, Vector3D<T> row2)
-        {
-            Row1 = row1;
-            Row2 = row2;
-        }
-
         /// <summary>Constructs a <see cref="Matrix2X3{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix2X3(Matrix3X2<T> value)
@@ -201,48 +71,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
                Scalar.Equal(M21, Scalar<T>.Zero) && Scalar.Equal(M23, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix2X3<T> operator +(Matrix2X3<T> value1, Matrix2X3<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix2X3<T> value1, Matrix2X3<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M21, value2.M21) && Scalar.Equal(value1.M23, value2.M23);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix2X3<T> value1, Matrix2X3<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) ||
-                   Scalar.NotEqual(value1.M22, value2.M22) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M21, value2.M21) || Scalar.NotEqual(value1.M23, value2.M23);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X3<T> operator *(Matrix2X3<T> value1, Matrix3X3<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3, value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3);
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -252,24 +80,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X3<T> operator *(Matrix2X2<T> value1, Matrix2X3<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 + value1.M12 * value2.Row2, value1.M21 * value2.Row1 + value2.M22 * value2.Row2);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X2<T> operator *(Matrix2X3<T> value1, Matrix3X2<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 + value1.M12 * value2.Row2, value1.M21 * value2.Row1 + value1.M22 * value2.Row2);
-        }
-
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
@@ -279,53 +89,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix2X3<T> operator -(Matrix2X3<T> value1, Matrix2X3<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix2X3<T> operator -(Matrix2X3<T> value)
-        {
-            return new(-value.Row1, -value.Row2);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix2X3<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix2X3<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -454,7 +217,7 @@ public static explicit operator Matrix2X3<long>(Matrix2X3<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix2X3<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix2X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index 2039da3a7d..7447bdd571 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -2,22 +2,54 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix2X3<T> :
         IEquatable<Matrix2X3<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row2;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column1 => new(Row1.X, Row2.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column2 => new(Row1.Y, Row2.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column3 => new(Row1.Z, Row2.Z);
+
         /// <summary>
         /// Constructs a <see cref="Matrix2X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix2X3(Vector3D<T> row1, Vector3D<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X3(Vector3D<T> row1, Vector3D<T> row2) =>
+            (Row1, Row2) = (row1, row2);
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix2X3{T}"/> from the given components.
+        /// </summary>
+        public Matrix2X3(
+            T m11, T m12, T m13,
+            T m21, T m22, T m23)
+        {
+            Row1 = new(m11, m12, m13);
+            Row2 = new(m21, m22, m23);
+        }
 
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector3D<T> this[int row]
         {
@@ -31,38 +63,50 @@ public ref Vector3D<T> this[int row]
                         return ref Row2;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -133,9 +177,14 @@ public Matrix3X2<T> Transpose() =>
 
     public static partial class Matrix2X3
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix2X3<T> Lerp<T>(Matrix2X3<T> value1, Matrix2X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)));
+            new(Vector3D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector3D.Lerp(value1.Row2, value2.Row2, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X4.Ops.cs b/sources/Maths/Maths/Matrix2X4.Ops.cs
index b7402f1507..4d0f06cbd4 100644
--- a/sources/Maths/Maths/Matrix2X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X4.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix2X4{T}"/>
     /// </summary>
-    public static class Matrix2X4
+    public static partial class Matrix2X4
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -17,7 +18,7 @@ public static class Matrix2X4
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X4<T> Add<T>(Matrix2X4<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -28,7 +29,7 @@ public static Matrix2X4<T> Add<T>(Matrix2X4<T> value1, Matrix2X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -37,7 +38,7 @@ public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -46,7 +47,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -55,7 +56,7 @@ public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -65,7 +66,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -75,7 +76,7 @@ public static Matrix3X4<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X4<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -84,18 +85,7 @@ public static Matrix2X4<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector4D<T> Multiply<T>(Vector2D<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix2X4<T> Lerp<T>(Matrix2X4<T> matrix1, Matrix2X4<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(Vector4D.Lerp(matrix1.Row1, matrix2.Row1, amount), Vector4D.Lerp(matrix1.Row2, matrix2.Row2, amount));
-        }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index 7e6f38eabf..51d70e9c93 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,8 +12,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 2x4 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix2X4<T> : IEquatable<Matrix2X4<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix2X4<T>
     {
         private static readonly Matrix2X4<T> _identity = new
         (
@@ -20,157 +20,6 @@ public struct Matrix2X4<T> : IEquatable<Matrix2X4<T>>
             Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row2;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column1 => new(M11, M21);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column2 => new(M12, M22);
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column3 => new(M13, M23);
-
-        /// <summary>
-        /// Column 4 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Column4 => new(M14, M24);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 1, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M14
-        {
-            readonly get => Row1.W;
-            set => Row1.W = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M24
-        {
-            readonly get => Row2.W;
-            set => Row2.W = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector4D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 1 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="j">The column to select. Zero based.</param>
-        public unsafe T this[int x, int j]
-        {
-            get
-            {
-                var row = this[x];
-                return row[j];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix2X4{T}"/> from the given rows
-        /// </summary>
-        public Matrix2X4(Vector4D<T> row1, Vector4D<T> row2)
-        {
-            Row1 = row1;
-            Row2 = row2;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix2X4{T}"/> from the given components.</summary>
-        public Matrix2X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24)
-        {
-            Row1 = new(m11, m12, m13, m14);
-            Row2 = new(m21, m22, m23, m24);
-        }
-
         /// <summary>Constructs a <see cref="Matrix2X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix2X4(Matrix3X2<T> value)
@@ -223,51 +72,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M14, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
                Scalar.Equal(M23, Scalar<T>.Zero) && Scalar.Equal(M24, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix2X4<T> operator +(Matrix2X4<T> value1, Matrix2X4<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix2X4<T> value1, Matrix2X4<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) &&
-                   Scalar.Equal(value1.M22, value2.M22) && // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M14, value2.M14) && Scalar.Equal(value1.M21, value2.M21) &&
-                   Scalar.Equal(value1.M23, value2.M23) && Scalar.Equal(value1.M24, value2.M24);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix2X4<T> value1, Matrix2X4<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) ||
-                   Scalar.NotEqual(value1.M22, value2.M22) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M14, value2.M14) || Scalar.NotEqual(value1.M21, value2.M21) ||
-                   Scalar.NotEqual(value1.M23, value2.M23) || Scalar.NotEqual(value1.M24, value2.M24);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X4<T> operator *(Matrix2X4<T> value1, Matrix4X4<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 + value1.M12 * value1.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value1.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4);
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -287,32 +91,6 @@ public readonly bool IsIdentity
                 value1.M21 * value2.Row1 + value2.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4);
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X4<T> operator *(Matrix3X2<T> value1, Matrix2X4<T> value2)
-        {
-            return new
-            (
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2
-            );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X4<T> operator *(Matrix2X2<T> value1, Matrix2X4<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2
-                );
-        }
-
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
@@ -322,55 +100,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix2X4<T> operator -(Matrix2X4<T> value1, Matrix2X4<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix2X4<T> operator -(Matrix2X4<T> value)
-        {
-            return new(-value.Row1, -value.Row2);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix2X4<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix2X4<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-            hash.Add(M14);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-            hash.Add(M24);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -553,7 +282,7 @@ public static explicit operator Matrix2X4<long>(Matrix2X4<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix2X4<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix2X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index 10496deda3..970be0f0f5 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -2,22 +2,58 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix2X4<T> :
         IEquatable<Matrix2X4<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row2;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column1 => new(Row1.X, Row2.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column2 => new(Row1.Y, Row2.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column3 => new(Row1.Z, Row2.Z);
+
+        /// <summary>The 4th column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector2D<T> Column4 => new(Row1.W, Row2.W);
+
         /// <summary>
         /// Constructs a <see cref="Matrix2X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix2X4(Vector4D<T> row1, Vector4D<T> row2) => (Row1, Row2) = (row1, row2);
+        public Matrix2X4(Vector4D<T> row1, Vector4D<T> row2) =>
+            (Row1, Row2) = (row1, row2);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix2X4{T}"/> from the given components.
+        /// </summary>
+        public Matrix2X4(
+            T m11, T m12, T m13, T m14,
+            T m21, T m22, T m23, T m24)
+        {
+            Row1 = new(m11, m12, m13, m14);
+            Row2 = new(m21, m22, m23, m24);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector4D<T> this[int row]
         {
@@ -31,46 +67,60 @@ public ref Vector4D<T> this[int row]
                         return ref Row2;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M24 => ref Row2.W;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -151,9 +201,14 @@ public Matrix4X2<T> Transpose() =>
 
     public static partial class Matrix2X4
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix2X4<T> Lerp<T>(Matrix2X4<T> value1, Matrix2X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)));
+            new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector4D.Lerp(value1.Row2, value2.Row2, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X2.Ops.cs b/sources/Maths/Maths/Matrix3X2.Ops.cs
index 20d7ff905a..4f5194fe0a 100644
--- a/sources/Maths/Maths/Matrix3X2.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X2.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix3X2{T}"/>
     /// </summary>
-    public static class Matrix3X2
+    public static partial class Matrix3X2
     {
 #if MATHF
         private const float RotationEpsilon = 0.001f * MathF.PI / 180f;     // 0.1% of a degree
@@ -23,14 +24,14 @@ public static class Matrix3X2
         /// <returns>The matrix containing the summed values.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Add<T>(Matrix3X2<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 + value2;
 
         /// <summary>Creates a rotation matrix using the given rotation in radians.</summary>
         /// <param name="radians">The amount of rotation, in radians.</param>
         /// <returns>A rotation matrix.</returns>
         public static Matrix3X2<T> CreateRotation<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             radians = Scalar.IEEERemainder(radians, Scalar<T>.Tau);
 
@@ -121,7 +122,7 @@ public static Matrix3X2<T> CreateRotation<T>(T radians)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>A rotation matrix.</returns>
         public static Matrix3X2<T> CreateRotation<T>(T radians, Vector2D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             radians = Scalar.IEEERemainder(radians, Scalar<T>.Tau);
 
@@ -210,7 +211,7 @@ public static Matrix3X2<T> CreateRotation<T>(T radians, Vector2D<T> centerPoint)
         /// <param name="scales">The scale to use.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(Vector2D<T> scales)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -225,7 +226,7 @@ public static Matrix3X2<T> CreateScale<T>(Vector2D<T> scales)
         /// <param name="yScale">Value to scale by on the Y-axis.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(T xScale, T yScale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -241,7 +242,7 @@ public static Matrix3X2<T> CreateScale<T>(T xScale, T yScale)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(T xScale, T yScale, Vector2D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -261,7 +262,7 @@ public static Matrix3X2<T> CreateScale<T>(T xScale, T yScale, Vector2D<T> center
         /// <param name="centerPoint">The center offset.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(Vector2D<T> scales, Vector2D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -280,7 +281,7 @@ public static Matrix3X2<T> CreateScale<T>(Vector2D<T> scales, Vector2D<T> center
         /// <param name="scale">The uniform scale to use.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(T scale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -295,7 +296,7 @@ public static Matrix3X2<T> CreateScale<T>(T scale)
         /// <param name="centerPoint">The center offset.</param>
         /// <returns>A scaling matrix.</returns>
         public static Matrix3X2<T> CreateScale<T>(T scale, Vector2D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -315,7 +316,7 @@ public static Matrix3X2<T> CreateScale<T>(T scale, Vector2D<T> centerPoint)
         /// <param name="radiansY">The Y angle, in radians.</param>
         /// <returns>A skew matrix.</returns>
         public static Matrix3X2<T> CreateSkew<T>(T radiansX, T radiansY)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -334,7 +335,7 @@ public static Matrix3X2<T> CreateSkew<T>(T radiansX, T radiansY)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>A skew matrix.</returns>
         public static Matrix3X2<T> CreateSkew<T>(T radiansX, T radiansY, Vector2D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -354,10 +355,10 @@ public static Matrix3X2<T> CreateSkew<T>(T radiansX, T radiansY, Vector2D<T> cen
         }
 
         /// <summary>Creates a translation matrix from the given vector.</summary>
-        /// <param name="position">The translation position.</param>                        `
+        /// <param name="position">The translation position.</param>
         /// <returns>A translation matrix.</returns>
         public static Matrix3X2<T> CreateTranslation<T>(Vector2D<T> position)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -372,7 +373,7 @@ public static Matrix3X2<T> CreateTranslation<T>(Vector2D<T> position)
         /// <param name="yPosition">The Y position.</param>
         /// <returns>A translation matrix.</returns>
         public static Matrix3X2<T> CreateTranslation<T>(T xPosition, T yPosition)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X2<T> result = Matrix3X2<T>.Identity;
 
@@ -387,11 +388,11 @@ public static Matrix3X2<T> CreateTranslation<T>(T xPosition, T yPosition)
         /// <param name="result">The output matrix.</param>
         /// <returns>True if the operation succeeded, False otherwise.</returns>
         public static bool Invert<T>(Matrix3X2<T> matrix, out Matrix3X2<T> result)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : IFloatingPointIeee754<T>
         {
             T det = Scalar.Subtract(Scalar.Multiply(matrix.M11, matrix.M22), Scalar.Multiply(matrix.M21, matrix.M12));
 
-            if (!Scalar.GreaterThanOrEqual(Scalar.Abs(det), Scalar<T>.Epsilon))
+            if (!(T.Abs(det) >= T.Epsilon))
             {
                 result = new(Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN);
                 return false;
@@ -413,26 +414,13 @@ public static bool Invert<T>(Matrix3X2<T> matrix, out Matrix3X2<T> result)
             return true;
         }
 
-        /// <summary>Linearly interpolates from matrix1 to matrix2, based on the third parameter.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weighting of matrix2.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static Matrix3X2<T> Lerp<T>(Matrix3X2<T> matrix1, Matrix3X2<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(Vector2D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                Vector2D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                Vector2D.Lerp(matrix1.Row3, matrix2.Row3, amount));
-        }
-
         /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
         /// <returns>The product matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -441,7 +429,7 @@ public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector2D<T> Multiply<T>(Vector3D<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
@@ -450,7 +438,7 @@ public static Vector2D<T> Multiply<T>(Vector3D<T> value1, Matrix3X2<T> value2)
         /// <returns>The product matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
@@ -459,7 +447,7 @@ public static Matrix3X3<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X3<T> value2)
         /// <returns>The product matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
@@ -468,7 +456,7 @@ public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
         /// <returns>The product matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Scales all elements in a matrix by the given scalar factor.</summary>
@@ -477,7 +465,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Negates the given matrix by multiplying all values by -1.</summary>
@@ -485,7 +473,7 @@ public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, T value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Negate<T>(Matrix3X2<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts each matrix element in value2 from its corresponding element in value1.</summary>
@@ -494,7 +482,7 @@ public static Matrix3X2<T> Negate<T>(Matrix3X2<T> value)
         /// <returns>The matrix containing the resulting values.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Subtract<T>(Matrix3X2<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index 8d80e72d79..7f3224660c 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,9 +12,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 3x2 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix3X2<T>
-        : IEquatable<Matrix3X2<T>>
-        where T : unmanaged, IFormattable, IComparable<T>, IEquatable<T>
+    public partial struct Matrix3X2<T>
     {
         private static readonly Matrix3X2<T> _identity = new(
             Scalar<T>.One, Scalar<T>.Zero,
@@ -21,139 +20,6 @@ public struct Matrix3X2<T>
             Scalar<T>.Zero, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row3;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
-
-        /// <summary>The first element of the first row</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>The second element of the first row</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>The first element of the second row</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>The second element of the second row</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>The first element of the third row</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>The second element of the third row</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector2D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 2 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>Constructs a <see cref="Matrix3X2{T}"/> from the given components.</summary>
-        public Matrix3X2(T m11, T m12,
-            T m21, T m22,
-            T m31, T m32)
-        {
-            Row1 = new(m11, m12);
-            Row2 = new(m21, m22);
-            Row3 = new(m31, m32);
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3X2{T}"/> from the given rows.
-        /// </summary>
-        public Matrix3X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-        }
-
         /// <summary>Constructs a <see cref="Matrix3X2{T}"/> from the given Matrix4x3.</summary>
         /// <param name="value">The source Matrix4x3.</param>
         public Matrix3X2(Matrix4X3<T> value)
@@ -206,54 +72,6 @@ public Matrix3X2(Matrix4X2<T> value)
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
 
-        /// <summary>Adds each matrix element in value1 with its corresponding element in value2.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The matrix containing the summed values.</returns>
-        public static Matrix3X2<T> operator +(Matrix3X2<T> value1, Matrix3X2<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given matrices are equal.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public static bool operator ==(Matrix3X2<T> value1, Matrix3X2<T> value2)
-        {
-            return (Scalar.Equal(value1.M11, value2.M11)
-                 && Scalar.Equal(value1.M22, value2.M22) // Check diagonal element first for early out
-                 && Scalar.Equal(value1.M12, value2.M12)
-                 && Scalar.Equal(value1.M21, value2.M21)
-                 && Scalar.Equal(value1.M31, value2.M31)
-                 && Scalar.Equal(value1.M32, value2.M32));
-        }
-
-        /// <summary>Returns a boolean indicating whether the given matrices are not equal.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>True if the matrices are not equal; False if they are equal.</returns>
-        public static bool operator !=(Matrix3X2<T> value1, Matrix3X2<T> value2)
-        {
-            return (Scalar.NotEqual(value1.M11, value2.M11)
-                    || Scalar.NotEqual(value1.M22, value2.M22) // Check diagonal element first for early out
-                    || Scalar.NotEqual(value1.M12, value2.M12)
-                    || Scalar.NotEqual(value1.M21, value2.M21)
-                    || Scalar.NotEqual(value1.M31, value2.M31)
-                    || Scalar.NotEqual(value1.M32, value2.M32));
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X3<T> operator *(Matrix3X2<T> value1, Matrix2X3<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 * value1.M12 * value2.Row2,
-                value1.M21 * value2.Row1 * value1.M22 * value2.Row2,
-                value1.M31 * value2.Row1 * value1.M32 * value2.Row2);
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -263,19 +81,6 @@ public Matrix3X2(Matrix4X2<T> value)
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X2<T> operator *(Matrix3X2<T> value1, Matrix2X2<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2
-                );
-        }
-
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
@@ -298,38 +103,6 @@ public Matrix3X2(Matrix4X2<T> value)
             return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
         }
 
-        /// <summary>Subtracts each matrix element in value2 from its corresponding element in value1.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The matrix containing the resulting values.</returns>
-        public static Matrix3X2<T> operator -(Matrix3X2<T> value1, Matrix3X2<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2, value1.Row3 - value2.Row3);
-        }
-
-        /// <summary>Negates the given matrix by multiplying all values by -1.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static Matrix3X2<T> operator -(Matrix3X2<T> value)
-        {
-            return new(-value.Row1, -value.Row2, -value.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix3X2<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the matrix is equal to the other given matrix.</summary>
-        /// <param name="other">The other matrix to test equality against.</param>
-        /// <returns>True if this matrix is equal to other; False otherwise.</returns>
-        public readonly bool Equals(Matrix3X2<T> other)
-        {
-            return this == other;
-        }
-
         /// <summary>Calculates the determinant for this matrix.
         /// The determinant is calculated by expanding the matrix with a third column whose values are (0,0,1).</summary>
         /// <returns>The determinant.</returns>
@@ -354,13 +127,6 @@ public readonly T GetDeterminant()
             return Scalar.Subtract(Scalar.Multiply(M11, M22), Scalar.Multiply(M21, M12));
         }
 
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode()
-        {
-            return HashCode.Combine(M11, M12, M21, M22, M31, M32);
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -532,7 +298,7 @@ public static explicit operator Matrix3X2<long>(Matrix3X2<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix3X2<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix3X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index bde0ebf4e0..1caf6ea066 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -2,25 +2,56 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix3X2<T> :
         IEquatable<Matrix3X2<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row3;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
+
         /// <summary>
         /// Constructs a <see cref="Matrix3X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix3X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3) =>
+            (Row1, Row2, Row3) = (row1, row2, row3);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix3X2{T}"/> from the given components.
+        /// </summary>
+        public Matrix3X2(
+            T m11, T m12,
+            T m21, T m22,
+            T m31, T m32)
+        {
+            Row1 = new(m11, m12);
+            Row2 = new(m21, m22);
+            Row3 = new(m31, m32);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector2D<T> this[int row]
         {
@@ -36,38 +67,50 @@ public ref Vector2D<T> this[int row]
                         return ref Row3;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -143,10 +186,15 @@ public Matrix2X3<T> Transpose() =>
 
     public static partial class Matrix3X2
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix3X2<T> Lerp<T>(Matrix3X2<T> value1, Matrix3X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount)));
+            new(Vector2D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector2D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector2D.Lerp(value1.Row3, value2.Row3, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index aa3905c23a..5a77409ea4 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,21 +10,22 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix3X3{T}"/>
     /// </summary>
-    public static class Matrix3X3
+    public static partial class Matrix3X3
     {
         private const float BillboardEpsilon = 1e-4f;
         private const float DecomposeEpsilon = 0.0001f;
 
         private struct CanonicalBasis<T>
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             public Vector3D<T> Row0;
             public Vector3D<T> Row1;
             public Vector3D<T> Row2;
         };
 
+        /*
         private struct VectorBasis<T>
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
 #pragma warning disable 649
             public unsafe Vector3D<T>* Element0;
@@ -31,6 +33,7 @@ private struct VectorBasis<T>
             public unsafe Vector3D<T>* Element2;
 #pragma warning restore 649
         }
+        */
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -38,7 +41,7 @@ private struct VectorBasis<T>
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Add<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -50,7 +53,7 @@ public static Matrix3X3<T> Add<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix3X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
@@ -75,7 +78,7 @@ public static Matrix3X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector
         /// <param name="angle">The angle to rotate around the given axis, in radians.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // a: angle
             // x, y, z: unit vector for axis.
@@ -128,7 +131,7 @@ public static Matrix3X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -165,7 +168,7 @@ public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
@@ -175,7 +178,7 @@ public static Matrix3X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
         /// <param name="radians">The amount, in radians, by which to rotate around the X-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateRotationX<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -199,7 +202,7 @@ public static Matrix3X3<T> CreateRotationX<T>(T radians)
         /// <param name="radians">The amount, in radians, by which to rotate around the Y-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateRotationY<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -222,7 +225,7 @@ public static Matrix3X3<T> CreateRotationY<T>(T radians)
         /// <param name="radians">The amount, in radians, by which to rotate around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateRotationZ<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -247,7 +250,7 @@ public static Matrix3X3<T> CreateRotationZ<T>(T radians)
         /// <param name="zScale">Value to scale by on the Z-axis.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix3X3<T> CreateScale<T>(T xScale, T yScale, T zScale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
             result.M11 = xScale;
@@ -260,7 +263,7 @@ public static Matrix3X3<T> CreateScale<T>(T xScale, T yScale, T zScale)
         /// <param name="scales">The vector containing the amount to scale by on each axis.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix3X3<T> CreateScale<T>(Vector3D<T> scales)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
             result.M11 = scales.X;
@@ -273,7 +276,7 @@ public static Matrix3X3<T> CreateScale<T>(Vector3D<T> scales)
         /// <param name="scale">The uniform scaling factor.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix3X3<T> CreateScale<T>(T scale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -290,7 +293,7 @@ public static Matrix3X3<T> CreateScale<T>(T scale)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -299,7 +302,7 @@ public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -309,7 +312,7 @@ public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -319,7 +322,7 @@ public static Matrix3X2<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -329,7 +332,7 @@ public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -338,7 +341,7 @@ public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -347,7 +350,7 @@ public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, T value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector3D<T> Multiply<T>(Vector3D<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -355,7 +358,7 @@ public static Vector3D<T> Multiply<T>(Vector3D<T> value1, Matrix3X3<T> value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Negate<T>(Matrix3X3<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -364,9 +367,10 @@ public static Matrix3X3<T> Negate<T>(Matrix3X3<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
 
+        /*
         /// <summary>Attempts to extract the scale, translation, and rotation components from the given scale/rotation/translation matrix.
         /// If successful, the out parameters will contained the extracted values.</summary>
         /// <param name="matrix">The source matrix.</param>
@@ -374,7 +378,7 @@ public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <param name="rotation">The rotation component of the transformation matrix.</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
         public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             bool result = true;
 
@@ -559,28 +563,14 @@ public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out
 
             return result;
         }
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix3X3<T> Lerp<T>(Matrix3X3<T> matrix1, Matrix3X3<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Vector3D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                Vector3D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                Vector3D.Lerp(matrix1.Row3, matrix2.Row3, amount)
-            );
-        }
+        */
 
         /// <summary>Transforms the given matrix by applying the given Quaternion rotation.</summary>
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
         public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -620,7 +610,7 @@ public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Legacy.Quaternion<T>
         /// <param name="matrix">The source matrix.</param>
         /// <returns>The transposed matrix.</returns>
         public static unsafe Matrix3X3<T> Transpose<T>(Matrix3X3<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return new(matrix.Column1, matrix.Column2, matrix.Column3);
         }
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index 755697a772..b5161c146d 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,179 +12,8 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 3x3 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix3X3<T> : IEquatable<Matrix3X3<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix3X3<T>
     {
-        private static readonly Matrix3X3<T> _identity = new
-        (
-            Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One
-        );
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row3;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
-
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
-
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M33
-        {
-            readonly get => Row3.Z;
-            set => Row3.Z = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector3D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 2 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="i">The column to select. Zero based.</param>
-        public unsafe T this[int x, int i]
-        {
-            get
-            {
-                var row = this[x];
-                return row[i];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3X3{T}"/> from the given rows.
-        /// </summary>
-        public Matrix3X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix3X3{T}"/> from the given components.</summary>
-        public Matrix3X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33)
-        {
-            Row1 = new(m11, m12, m13);
-            Row2 = new(m21, m22, m23);
-            Row3 = new(m31, m32, m33);
-        }
-
         /// <summary>Constructs a <see cref="Matrix3X3{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix3X3(Matrix3X2<T> value)
@@ -247,9 +77,6 @@ public Matrix3X3(Matrix4X4<T> value)
             Row3 = new(value.M31, value.M32, value.M33);
         }
 
-        /// <summary>Returns the multiplicative identity matrix.</summary>
-        public static Matrix3X3<T> Identity => _identity;
-
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity
@@ -259,55 +86,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M21, Scalar<T>.Zero) && Scalar.Equal(M23, Scalar<T>.Zero) &&
                Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix3X3<T> operator +(Matrix3X3<T> value1, Matrix3X3<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix3X3<T> value1, Matrix3X3<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   Scalar.Equal(value1.M33, value2.M33) &&
-                   // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M21, value2.M21) && Scalar.Equal(value1.M23, value2.M23) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix3X3<T> value1, Matrix3X3<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||
-                   Scalar.NotEqual(value1.M33, value2.M33) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M21, value2.M21) || Scalar.NotEqual(value1.M23, value2.M23) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X3<T> operator *(Matrix3X3<T> value1, Matrix3X3<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3
-                );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -326,36 +104,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix3X3<T> operator -(Matrix3X3<T> value1, Matrix3X3<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2, value1.Row3 - value2.Row3);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix3X3<T> operator -(Matrix3X3<T> value)
-        {
-            return new(-value.Row1, -value.Row2, -value.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix3X3<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix3X3<T> other)
-            => this == other;
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -375,27 +123,6 @@ public readonly T GetDeterminant()
                 Scalar.Multiply(c, Scalar.Subtract(Scalar.Multiply(d, h), Scalar.Multiply(e, g))));
         }
 
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-
-            hash.Add(M31);
-            hash.Add(M32);
-            hash.Add(M33);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -541,7 +268,7 @@ public static explicit operator Matrix3X3<long>(Matrix3X3<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix3X3<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix3X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index df79a5c810..ad3c0b5b2a 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -2,31 +2,66 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix3X3<T> :
         IEquatable<Matrix3X3<T>>
         where T : INumberBase<T>
     {
         /// <summary>The multiplicative identity matrix of size 3x3.</summary>
-        public static readonly Matrix3X3<T> Identity = new(
+        public static Matrix3X3<T> Identity { get; } = new(
             new(T.MultiplicativeIdentity, T.Zero, T.Zero),
             new(T.Zero, T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.Zero, T.MultiplicativeIdentity));
 
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row3;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z);
+
         /// <summary>
         /// Constructs a <see cref="Matrix3X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix3X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3) =>
+            (Row1, Row2, Row3) = (row1, row2, row3);
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix3X3{T}"/> from the given components.
+        /// </summary>
+        public Matrix3X3(
+            T m11, T m12, T m13,
+            T m21, T m22, T m23,
+            T m31, T m32, T m33)
+        {
+            Row1 = new(m11, m12, m13);
+            Row2 = new(m21, m22, m23);
+            Row3 = new(m31, m32, m33);
+        }
 
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector3D<T> this[int row]
         {
@@ -42,50 +77,65 @@ public ref Vector3D<T> this[int row]
                         return ref Row3;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M33 => ref Row3.Z;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -170,10 +220,15 @@ public Matrix3X3<T> Transpose() =>
 
     public static partial class Matrix3X3
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix3X3<T> Lerp<T>(Matrix3X3<T> value1, Matrix3X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount)));
+            new(Vector3D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector3D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector3D.Lerp(value1.Row3, value2.Row3, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X4.Ops.cs b/sources/Maths/Maths/Matrix3X4.Ops.cs
index 3c9c07af8a..ae25df3fb3 100644
--- a/sources/Maths/Maths/Matrix3X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X4.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix3X4{T}"/>
     /// </summary>
-    public static class Matrix3X4
+    public static partial class Matrix3X4
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -17,7 +18,7 @@ public static class Matrix3X4
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Add<T>(Matrix3X4<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -28,7 +29,7 @@ public static Matrix3X4<T> Add<T>(Matrix3X4<T> value1, Matrix3X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -37,7 +38,7 @@ public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -46,7 +47,7 @@ public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
 
@@ -56,7 +57,7 @@ public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -65,7 +66,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -74,7 +75,7 @@ public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, T value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector4D<T> Multiply<T>(Vector3D<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -82,7 +83,7 @@ public static Vector4D<T> Multiply<T>(Vector3D<T> value1, Matrix3X4<T> value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Negate<T>(Matrix3X4<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -91,22 +92,7 @@ public static Matrix3X4<T> Negate<T>(Matrix3X4<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X4<T> Subtract<T>(Matrix3X4<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix3X4<T> Lerp<T>(Matrix3X4<T> matrix1, Matrix3X4<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Vector4D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                Vector4D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                Vector4D.Lerp(matrix1.Row3, matrix2.Row3, amount)
-            );
-        }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index ee466c0958..966669f93b 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,8 +12,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 3x4 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix3X4<T> : IEquatable<Matrix3X4<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix3X4<T>
     {
         private static readonly Matrix3X4<T> _identity = new
         (
@@ -21,200 +21,6 @@ public struct Matrix3X4<T> : IEquatable<Matrix3X4<T>>
             Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row3;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z);
-
-        /// <summary>
-        /// Column 4 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Column4 => new(Row1.W, Row2.W, Row3.W);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 1, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M14
-        {
-            readonly get => Row1.W;
-            set => Row1.W = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M24
-        {
-            readonly get => Row2.W;
-            set => Row2.W = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M33
-        {
-            readonly get => Row3.Z;
-            set => Row3.Z = value;
-        }
-
-        /// <summary>Value at row 3, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M34
-        {
-            readonly get => Row3.W;
-            set => Row3.W = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector4D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 2 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix3X4{T}"/> from the given rows.
-        /// </summary>
-        /// <param name="row1"></param>
-        /// <param name="row2"></param>
-        /// <param name="row3"></param>
-        public Matrix3X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given components.</summary>
-        public Matrix3X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34)
-        {
-            Row1 = new(m11, m12, m13, m14);
-            Row2 = new(m21, m22, m23, m24);
-            Row3 = new(m31, m32, m33, m34);
-        }
-
         /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix3X4(Matrix3X2<T> value)
@@ -283,58 +89,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
                Scalar.Equal(M34, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix3X4<T> operator +(Matrix3X4<T> value1, Matrix3X4<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix3X4<T> value1, Matrix3X4<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   Scalar.Equal(value1.M33, value2.M33) && // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M14, value2.M14) && Scalar.Equal(value1.M21, value2.M21) &&
-                   Scalar.Equal(value1.M23, value2.M23) && Scalar.Equal(value1.M24, value2.M24) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32) &&
-                   Scalar.Equal(value1.M34, value2.M34);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix3X4<T> value1, Matrix3X4<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||
-                   Scalar.NotEqual(value1.M33, value2.M33) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M14, value2.M14) || Scalar.NotEqual(value1.M21, value2.M21) ||
-                   Scalar.NotEqual(value1.M23, value2.M23) || Scalar.NotEqual(value1.M24, value2.M24) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32) ||
-                   Scalar.NotEqual(value1.M34, value2.M34);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X3<T> operator *(Matrix3X4<T> value1, Matrix4X3<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3 + value1.M34 * value2.Row4
-                );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -344,19 +98,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X4<T> operator *(Matrix3X3<T> value1, Matrix3X4<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3
-                );
-        }
-
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
@@ -366,60 +107,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix3X4<T> operator -(Matrix3X4<T> value1, Matrix3X4<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2, value1.Row3 - value2.Row3);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix3X4<T> operator -(Matrix3X4<T> value)
-        {
-            return new(-value.Row1, -value.Row2, -value.Row3);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix3X4<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix3X4<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-            hash.Add(M14);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-            hash.Add(M24);
-
-            hash.Add(M31);
-            hash.Add(M32);
-            hash.Add(M33);
-            hash.Add(M34);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -627,7 +314,7 @@ public static explicit operator Matrix3X4<long>(Matrix3X4<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix3X4<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix3X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index 72a40e990d..fa2463be59 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -2,25 +2,64 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix3X4<T> :
         IEquatable<Matrix3X4<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row3;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column1 => new(Row1.X, Row2.X, Row3.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z);
+
+        /// <summary>The 4th column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector3D<T> Column4 => new(Row1.W, Row2.W, Row3.W);
+
         /// <summary>
         /// Constructs a <see cref="Matrix3X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix3X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3) => (Row1, Row2, Row3) = (row1, row2, row3);
+        public Matrix3X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3) =>
+            (Row1, Row2, Row3) = (row1, row2, row3);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix3X4{T}"/> from the given components.
+        /// </summary>
+        public Matrix3X4(
+            T m11, T m12, T m13, T m14,
+            T m21, T m22, T m23, T m24,
+            T m31, T m32, T m33, T m34)
+        {
+            Row1 = new(m11, m12, m13, m14);
+            Row2 = new(m21, m22, m23, m24);
+            Row3 = new(m31, m32, m33, m34);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector4D<T> this[int row]
         {
@@ -36,62 +75,80 @@ public ref Vector4D<T> this[int row]
                         return ref Row3;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M34 => ref Row3.W;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -186,10 +243,15 @@ public Matrix4X3<T> Transpose() =>
 
     public static partial class Matrix3X4
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix3X4<T> Lerp<T>(Matrix3X4<T> value1, Matrix3X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)));
+            new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector4D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector4D.Lerp(value1.Row3, value2.Row3, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X2.Ops.cs b/sources/Maths/Maths/Matrix4X2.Ops.cs
index 3fa4c29020..697280fe63 100644
--- a/sources/Maths/Maths/Matrix4X2.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X2.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix4X2{T}"/>
     /// </summary>
-    public static class Matrix4X2
+    public static partial class Matrix4X2
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -17,7 +18,7 @@ public static class Matrix4X2
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Add<T>(Matrix4X2<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -28,7 +29,7 @@ public static Matrix4X2<T> Add<T>(Matrix4X2<T> value1, Matrix4X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -37,7 +38,7 @@ public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -46,7 +47,7 @@ public static Matrix4X3<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -55,7 +56,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -64,7 +65,7 @@ public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X2<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -73,7 +74,7 @@ public static Matrix3X2<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector2D<T> Multiply<T>(Vector4D<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -82,7 +83,7 @@ public static Vector2D<T> Multiply<T>(Vector4D<T> value1, Matrix4X2<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -90,7 +91,7 @@ public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Negate<T>(Matrix4X2<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -99,12 +100,12 @@ public static Matrix4X2<T> Negate<T>(Matrix4X2<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Subtract<T>(Matrix4X2<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
 
         /*[MethodImpl((MethodImplOptions)768)]
         private static Vector128<T> Permute<T>(Vector128<T> value, byte control)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             if (Avx.IsSupported)
             {
@@ -120,23 +121,5 @@ private static Vector128<T> Permute<T>(Vector128<T> value, byte control)
                 throw new PlatformNotSupportedException();
             }
         }*/
-
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix4X2<T> Lerp<T>(Matrix4X2<T> matrix1, Matrix4X2<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new
-            (
-                Vector2D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                Vector2D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                Vector2D.Lerp(matrix1.Row3, matrix2.Row3, amount),
-                Vector2D.Lerp(matrix1.Row4, matrix2.Row4, amount)
-            );
-        }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index ca60eb79d5..45d2b8c231 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Diagnostics;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -12,8 +13,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 4x2 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix4X2<T> : IEquatable<Matrix4X2<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix4X2<T>
     {
         private static readonly Matrix4X2<T> _identity = new
         (
@@ -23,163 +23,6 @@ public struct Matrix4X2<T> : IEquatable<Matrix4X2<T>>
             Scalar<T>.Zero, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row3;
-
-        /// <summary>
-        /// Row 4 of the matrix
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector2D<T> Row4;
-
-
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.X, Row4.X);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 4, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M41
-        {
-            readonly get => Row4.X;
-            set => Row4.X = value;
-        }
-
-        /// <summary>Value at row 4, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M42
-        {
-            readonly get => Row4.Y;
-            set => Row4.Y = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector2D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 3 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4X2{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3, Vector2D<T> row4)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-            Row4 = row4;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix4X2{T}"/> from the given components.</summary>
-        public Matrix4X2(T m11, T m12, T m21, T m22, T m31, T m32, T m41, T m42)
-        {
-            Row1 = new(m11, m12);
-            Row2 = new(m21, m22);
-            Row3 = new(m31, m32);
-            Row4 = new(m41, m42);
-        }
-
         /// <summary>Constructs a <see cref="Matrix4X2{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix4X2(Matrix3X2<T> value)
@@ -242,87 +85,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
                Scalar.Equal(M41, Scalar<T>.Zero) && Scalar.Equal(M42, Scalar<T>.Zero);
 
-
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix4X2<T> operator +(Matrix4X2<T> value1, Matrix4X2<T> value2)
-        {
-            return new
-            (
-                value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3,
-                value1.Row4 + value2.Row4
-            );
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix4X2<T> value1, Matrix4X2<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M21, value2.M21) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32) &&
-                   Scalar.Equal(value1.M41, value2.M41) && Scalar.Equal(value1.M42, value2.M42);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix4X2<T> value1, Matrix4X2<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||  // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M21, value2.M21) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32) ||
-                   Scalar.NotEqual(value1.M41, value2.M41) || Scalar.NotEqual(value1.M42, value2.M42);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X2<T> operator *(Matrix4X2<T> value1, Matrix2X2<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2,
-                    value1.M41 * value2.Row1 + value1.M42 * value2.Row2
-                );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X3<T> operator *(Matrix4X2<T> value1, Matrix2X3<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2,
-                    value1.M41 * value2.Row1 + value1.M42 * value2.Row2
-                );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X4<T> operator *(Matrix4X2<T> value1, Matrix2X4<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2,
-                    value1.M41 * value2.Row1 + value1.M42 * value2.Row2
-                );
-        }
-
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="value1">The first source matrix.</param>
         /// <param name="value2">The second source matrix.</param>
@@ -380,57 +142,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2, value1.Row4 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix4X2<T> operator -(Matrix4X2<T> value1, Matrix4X2<T> value2)
-        {
-            return new(value1.Row1 - value2.Row1, value1.Row2 - value2.Row2, value1.Row3 - value2.Row3, value1.Row4 - value2.Row4);
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix4X2<T> operator -(Matrix4X2<T> value)
-        {
-            return new(-value.Row1, -value.Row2, -value.Row3, -value.Row4);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix4X2<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix4X2<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-
-            hash.Add(M21);
-            hash.Add(M22);
-
-            hash.Add(M31);
-            hash.Add(M32);
-
-            hash.Add(M41);
-            hash.Add(M42);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -615,7 +326,7 @@ public static explicit operator Matrix4X2<long>(Matrix4X2<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix4X2<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix4X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index 36b257c507..8bd1df9859 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -2,28 +2,62 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix4X2<T> :
         IEquatable<Matrix4X2<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector2D<T> Row4;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y, Row4.Y);
+
         /// <summary>
         /// Constructs a <see cref="Matrix4X2{T}"/> from the given rows.
         /// </summary>
-        public Matrix4X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3, Vector2D<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        public Matrix4X2(Vector2D<T> row1, Vector2D<T> row2, Vector2D<T> row3, Vector2D<T> row4) =>
+            (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix4X2{T}"/> from the given components.
+        /// </summary>
+        public Matrix4X2(
+            T m11, T m12,
+            T m21, T m22,
+            T m31, T m32,
+            T m41, T m42)
+        {
+            Row1 = new(m11, m12);
+            Row2 = new(m21, m22);
+            Row3 = new(m31, m32);
+            Row4 = new(m41, m42);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector2D<T> this[int row]
         {
@@ -41,46 +75,60 @@ public ref Vector2D<T> this[int row]
                         return ref Row4;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M42 => ref Row4.Y;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -172,11 +220,16 @@ public Matrix2X4<T> Transpose() =>
 
     public static partial class Matrix4X2
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix4X2<T> Lerp<T>(Matrix4X2<T> value1, Matrix4X2<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount)),
-                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount)));
+            new(Vector2D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector2D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector2D.Lerp(value1.Row3, value2.Row3, amount),
+                Vector2D.Lerp(value1.Row4, value2.Row4, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X3.Ops.cs b/sources/Maths/Maths/Matrix4X3.Ops.cs
index 09407f0f98..807192cc85 100644
--- a/sources/Maths/Maths/Matrix4X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X3.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix4X3{T}"/>
     /// </summary>
-    public static class Matrix4X3
+    public static partial class Matrix4X3
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -17,7 +18,7 @@ public static class Matrix4X3
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Add<T>(Matrix4X3<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -28,7 +29,7 @@ public static Matrix4X3<T> Add<T>(Matrix4X3<T> value1, Matrix4X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -37,7 +38,7 @@ public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -46,7 +47,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -55,7 +56,7 @@ public static Matrix4X3<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X3<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -64,7 +65,7 @@ public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -73,7 +74,7 @@ public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, T value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector3D<T> Multiply<T>(Vector4D<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -81,7 +82,7 @@ public static Vector3D<T> Multiply<T>(Vector4D<T> value1, Matrix4X3<T> value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Negate<T>(Matrix4X3<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -90,23 +91,7 @@ public static Matrix4X3<T> Negate<T>(Matrix4X3<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X3<T> Subtract<T>(Matrix4X3<T> value1, Matrix4X3<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix4X3<T> Lerp<T>(Matrix4X3<T> matrix1, Matrix4X3<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                Vector3D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                Vector3D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                Vector3D.Lerp(matrix1.Row3, matrix2.Row3, amount),
-                Vector3D.Lerp(matrix1.Row4, matrix2.Row4, amount)
-            );
-        }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index 57088ec556..3cfd7e313a 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,8 +12,9 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 4x3 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix4X3<T> : IEquatable<Matrix4X3<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix4X3<T>
+        : IEquatable<Matrix4X3<T>>
+        where T : INumberBase<T>
     {
         private static readonly Matrix4X3<T> _identity = new
         (
@@ -22,199 +24,6 @@ public struct Matrix4X3<T> : IEquatable<Matrix4X3<T>>
             Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row1;
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row2;
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row3;
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector3D<T> Row4;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y, Row4.Y);
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z, Row4.Z);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M33
-        {
-            readonly get => Row3.Z;
-            set => Row3.Z = value;
-        }
-
-        /// <summary>Value at row 4, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M41
-        {
-            readonly get => Row4.X;
-            set => Row4.X = value;
-        }
-
-        /// <summary>Value at row 4, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M42
-        {
-            readonly get => Row4.Y;
-            set => Row4.Y = value;
-        }
-
-        /// <summary>Value at row 4, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M43
-        {
-            readonly get => Row4.Z;
-            set => Row4.Z = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector3D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 3 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="i">The column to select. Zero based.</param>
-        public unsafe T this[int x, int i]
-        {
-            get
-            {
-                var row = this[x];
-                return row[i];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4X3{T}"/> from the given rows.
-        /// </summary>
-        public Matrix4X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3, Vector3D<T> row4)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-            Row4 = row4;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix4X3{T}"/> from the given components.</summary>
-        public Matrix4X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33, T m41, T m42, T m43)
-        {
-            Row1 = new(m11, m12, m13);
-            Row2 = new(m21, m22, m23);
-            Row3 = new(m31, m32, m33);
-            Row4 = new(m41, m42, m43);
-        }
-
         /// <summary>Constructs a <see cref="Matrix4X3{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix4X3(Matrix3X2<T> value)
@@ -299,73 +108,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M41, Scalar<T>.Zero) && Scalar.Equal(M42, Scalar<T>.Zero) &&
                Scalar.Equal(M43, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix4X3<T> operator +(Matrix4X3<T> value1, Matrix4X3<T> value2)
-        {
-            return new(value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3, value1.Row4 + value2.Row4);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix4X3<T> value1, Matrix4X3<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   Scalar.Equal(value1.M33, value2.M33) && // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M21, value2.M21) && Scalar.Equal(value1.M23, value2.M23) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32) &&
-                   Scalar.Equal(value1.M41, value2.M41) && Scalar.Equal(value1.M42, value2.M42) &&
-                   Scalar.Equal(value1.M43, value2.M43);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix4X3<T> value1, Matrix4X3<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||
-                   Scalar.NotEqual(value1.M33, value2.M33) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M21, value2.M21) || Scalar.NotEqual(value1.M23, value2.M23) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32) ||
-                   Scalar.NotEqual(value1.M41, value2.M41) || Scalar.NotEqual(value1.M42, value2.M42) ||
-                   Scalar.NotEqual(value1.M43, value2.M43);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X4<T> operator *(Matrix4X3<T> value1, Matrix3X4<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3,
-                    value1.M41 * value2.Row1 + value1.M42 * value2.Row2 + value1.M43 * value2.Row3
-                );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X3<T> operator *(Matrix4X3<T> value1, Matrix3X3<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3,
-                value1.M41 * value2.Row1 + value1.M42 * value2.Row2 + value1.M43 * value2.Row3
-            );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -384,66 +126,6 @@ public readonly bool IsIdentity
             return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2, value1.Row4 * value2);
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix4X3<T> operator -(Matrix4X3<T> value1, Matrix4X3<T> value2)
-        {
-            return new(
-                    value1.Row1 - value2.Row1,
-                    value1.Row2 - value2.Row2,
-                    value1.Row3 - value2.Row3,
-                    value1.Row4 - value2.Row4
-                );
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix4X3<T> operator -(Matrix4X3<T> value)
-        {
-            return new(-value.Row1, -value.Row2, -value.Row3, -value.Row4);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix4X3<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix4X3<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-
-            hash.Add(M31);
-            hash.Add(M32);
-            hash.Add(M33);
-
-            hash.Add(M41);
-            hash.Add(M42);
-            hash.Add(M43);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -676,7 +358,7 @@ public static explicit operator Matrix4X3<long>(Matrix4X3<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix4X3<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix4X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index ba7647e55a..7fcb883410 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -2,28 +2,66 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix4X3<T> :
         IEquatable<Matrix4X3<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector3D<T> Row4;
 
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y, Row4.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z, Row4.Z);
+
         /// <summary>
         /// Constructs a <see cref="Matrix4X3{T}"/> from the given rows.
         /// </summary>
-        public Matrix4X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3, Vector3D<T> row4) => (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+        public Matrix4X3(Vector3D<T> row1, Vector3D<T> row2, Vector3D<T> row3, Vector3D<T> row4) =>
+            (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4X3{T}"/> from the given components.
+        /// </summary>
+        public Matrix4X3(
+            T m11, T m12, T m13,
+            T m21, T m22, T m23,
+            T m31, T m32, T m33,
+            T m41, T m42, T m43)
+        {
+            Row1 = new(m11, m12, m13);
+            Row2 = new(m21, m22, m23);
+            Row3 = new(m31, m32, m33);
+            Row4 = new(m41, m42, m43);
+        }
 
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector3D<T> this[int row]
         {
@@ -41,62 +79,80 @@ public ref Vector3D<T> this[int row]
                         return ref Row4;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M43 => ref Row4.Z;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -197,11 +253,16 @@ public Matrix3X4<T> Transpose() =>
 
     public static partial class Matrix4X3
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix4X3<T> Lerp<T>(Matrix4X3<T> value1, Matrix4X3<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount)),
-                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount)));
+            new(Vector3D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector3D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector3D.Lerp(value1.Row3, value2.Row3, amount),
+                Vector3D.Lerp(value1.Row4, value2.Row4, amount));
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index fb74c4345a..5bc49c3d06 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix4X4{T}"/>
     /// </summary>
-    public static class Matrix4X4
+    public static partial class Matrix4X4
     {
         private const float BillboardEpsilon = 1e-4f;
 #if MATHF
@@ -20,15 +21,16 @@ public static class Matrix4X4
         private const float DecomposeEpsilon = 0.0001f;
 
         private struct CanonicalBasis<T>
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             public Vector3D<T> Row0;
             public Vector3D<T> Row1;
             public Vector3D<T> Row2;
         };
 
+        /*
         private struct VectorBasis<T>
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
 #pragma warning disable 649
             public unsafe Vector3D<T>* Element0;
@@ -36,6 +38,7 @@ private struct VectorBasis<T>
             public unsafe Vector3D<T>* Element2;
 #pragma warning restore 649
         }
+        */
 
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -43,7 +46,7 @@ private struct VectorBasis<T>
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Add<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -55,7 +58,7 @@ public static Matrix4X4<T> Add<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix4X4<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
@@ -87,7 +90,7 @@ public static Matrix4X4<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector
         /// <param name="objectForwardVector">Forward vector of the object.</param>
         /// <returns>The created billboard matrix.</returns>
         public static Matrix4X4<T> CreateConstrainedBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> rotateAxis, Vector3D<T> cameraForwardVector, Vector3D<T> objectForwardVector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // Treat the case when object and camera positions are too close.
             Vector3D<T> faceDir = objectPosition - cameraPosition;
@@ -109,17 +112,17 @@ public static Matrix4X4<T> CreateConstrainedBillboard<T>(Vector3D<T> objectPosit
             // Treat the case when angle between faceDir and rotateAxis is too close to 0.
             T dot = Vector3D.Dot(rotateAxis, faceDir);
 
-            if (Scalar.GreaterThan(Scalar.Abs(dot), Scalar.As<float, T>(BillboardMinAngle)))
+            if (Scalar.GreaterThan(T.Abs(dot), Scalar.As<float, T>(BillboardMinAngle)))
             {
                 zaxis = objectForwardVector;
 
                 // Make sure passed values are useful for compute.
                 dot = Vector3D.Dot(rotateAxis, zaxis);
 
-                if (Scalar.GreaterThan(Scalar.Abs(dot), Scalar.As<float, T>(BillboardMinAngle)))
+                if (Scalar.GreaterThan(T.Abs(dot), Scalar.As<float, T>(BillboardMinAngle)))
                 {
                     zaxis =
-                        Scalar.GreaterThan(Scalar.Abs(rotateAxis.Z), Scalar.As<float, T>(BillboardMinAngle))
+                        Scalar.GreaterThan(T.Abs(rotateAxis.Z), Scalar.As<float, T>(BillboardMinAngle))
                             ? new Vector3D<T>(Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero)
                             : new Vector3D<T>(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.MinusOne);
                 }
@@ -145,7 +148,7 @@ public static Matrix4X4<T> CreateConstrainedBillboard<T>(Vector3D<T> objectPosit
         /// <param name="angle">The angle to rotate around the given axis, in radians.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // a: angle
             // x, y, z: unit vector for axis.
@@ -198,7 +201,7 @@ public static Matrix4X4<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -235,7 +238,7 @@ public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
@@ -247,7 +250,7 @@ public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
         /// <param name="cameraUpVector">The direction that is "up" from the camera's point of view.</param>
         /// <returns>The view matrix.</returns>
         public static Matrix4X4<T> CreateLookAt<T>(Vector3D<T> cameraPosition, Vector3D<T> cameraTarget, Vector3D<T> cameraUpVector)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector3D<T> zaxis = Vector3D.Normalize(cameraPosition - cameraTarget);
             Vector3D<T> xaxis = Vector3D.Normalize(Vector3D.Cross(cameraUpVector, zaxis));
@@ -281,7 +284,7 @@ public static Matrix4X4<T> CreateLookAt<T>(Vector3D<T> cameraPosition, Vector3D<
         /// <param name="zFarPlane">Maximum Z-value of the view volume.</param>
         /// <returns>The orthographic projection matrix.</returns>
         public static Matrix4X4<T> CreateOrthographic<T>(T width, T height, T zNearPlane, T zFarPlane)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -302,7 +305,7 @@ public static Matrix4X4<T> CreateOrthographic<T>(T width, T height, T zNearPlane
         /// <param name="zFarPlane">Maximum Z-value of the view volume.</param>
         /// <returns>The orthographic projection matrix.</returns>
         public static Matrix4X4<T> CreateOrthographicOffCenter<T>(T left, T right, T bottom, T top, T zNearPlane, T zFarPlane)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -326,7 +329,7 @@ public static Matrix4X4<T> CreateOrthographicOffCenter<T>(T left, T right, T bot
         /// <param name="farPlaneDistance">Distance to the far view plane.</param>
         /// <returns>The perspective projection matrix.</returns>
         public static Matrix4X4<T> CreatePerspective<T>(T width, T height, T nearPlaneDistance, T farPlaneDistance)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             if (!Scalar.GreaterThan(nearPlaneDistance, Scalar<T>.Zero))
                 throw new ArgumentOutOfRangeException(nameof(nearPlaneDistance));
@@ -362,7 +365,7 @@ public static Matrix4X4<T> CreatePerspective<T>(T width, T height, T nearPlaneDi
         /// <param name="farPlaneDistance">Distance to the far view plane.</param>
         /// <returns>The perspective projection matrix.</returns>
         public static Matrix4X4<T> CreatePerspectiveFieldOfView<T>(T fieldOfView, T aspectRatio, T nearPlaneDistance, T farPlaneDistance)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             if (!Scalar.GreaterThan(fieldOfView, Scalar<T>.Zero) || Scalar.GreaterThanOrEqual(fieldOfView, Scalar<T>.Pi))
                 throw new ArgumentOutOfRangeException(nameof(fieldOfView));
@@ -404,7 +407,7 @@ public static Matrix4X4<T> CreatePerspectiveFieldOfView<T>(T fieldOfView, T aspe
         /// <param name="farPlaneDistance">Distance to of the far view plane.</param>
         /// <returns>The perspective projection matrix.</returns>
         public static Matrix4X4<T> CreatePerspectiveOffCenter<T>(T left, T right, T bottom, T top, T nearPlaneDistance, T farPlaneDistance)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             if (!Scalar.GreaterThan(nearPlaneDistance, Scalar<T>.Zero))
                 throw new ArgumentOutOfRangeException(nameof(nearPlaneDistance));
@@ -436,7 +439,7 @@ public static Matrix4X4<T> CreatePerspectiveOffCenter<T>(T left, T right, T bott
         /// <param name="value">The Plane about which to create a reflection.</param>
         /// <returns>A new matrix expressing the reflection.</returns>
         public static Matrix4X4<T> CreateReflection<T>(Plane<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             value = Plane.Normalize(value);
 
@@ -473,7 +476,7 @@ public static Matrix4X4<T> CreateReflection<T>(Plane<T> value)
         /// <param name="radians">The amount, in radians, by which to rotate around the X-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationX<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -498,7 +501,7 @@ public static Matrix4X4<T> CreateRotationX<T>(T radians)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationX<T>(T radians, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -527,7 +530,7 @@ public static Matrix4X4<T> CreateRotationX<T>(T radians, Vector3D<T> centerPoint
         /// <param name="radians">The amount, in radians, by which to rotate around the Y-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationY<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -551,7 +554,7 @@ public static Matrix4X4<T> CreateRotationY<T>(T radians)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationY<T>(T radians, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -579,7 +582,7 @@ public static Matrix4X4<T> CreateRotationY<T>(T radians, Vector3D<T> centerPoint
         /// <param name="radians">The amount, in radians, by which to rotate around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationZ<T>(T radians)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -603,7 +606,7 @@ public static Matrix4X4<T> CreateRotationZ<T>(T radians)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateRotationZ<T>(T radians, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -633,7 +636,7 @@ public static Matrix4X4<T> CreateRotationZ<T>(T radians, Vector3D<T> centerPoint
         /// <param name="zScale">Value to scale by on the Z-axis.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(T xScale, T yScale, T zScale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
             result.M11 = xScale;
@@ -649,7 +652,7 @@ public static Matrix4X4<T> CreateScale<T>(T xScale, T yScale, T zScale)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(T xScale, T yScale, T zScale, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -670,7 +673,7 @@ public static Matrix4X4<T> CreateScale<T>(T xScale, T yScale, T zScale, Vector3D
         /// <param name="scales">The vector containing the amount to scale by on each axis.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(Vector3D<T> scales)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
             result.M11 = scales.X;
@@ -684,7 +687,7 @@ public static Matrix4X4<T> CreateScale<T>(Vector3D<T> scales)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(Vector3D<T> scales, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -705,7 +708,7 @@ public static Matrix4X4<T> CreateScale<T>(Vector3D<T> scales, Vector3D<T> center
         /// <param name="scale">The uniform scaling factor.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(T scale)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -721,7 +724,7 @@ public static Matrix4X4<T> CreateScale<T>(T scale)
         /// <param name="centerPoint">The center point.</param>
         /// <returns>The scaling matrix.</returns>
         public static Matrix4X4<T> CreateScale<T>(T scale, Vector3D<T> centerPoint)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -745,7 +748,7 @@ public static Matrix4X4<T> CreateScale<T>(T scale, Vector3D<T> centerPoint)
         /// <param name="plane">The Plane onto which the new matrix should flatten geometry so as to cast a shadow.</param>
         /// <returns>A new Matrix that can be used to flatten geometry onto the specified plane from the specified direction.</returns>
         public static Matrix4X4<T> CreateShadow<T>(Vector3D<T> lightDirection, Plane<T> plane)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Plane<T> p = Plane.Normalize(plane);
 
@@ -781,7 +784,7 @@ public static Matrix4X4<T> CreateShadow<T>(Vector3D<T> lightDirection, Plane<T>
         /// <param name="position">The amount to translate in each axis.</param>
         /// <returns>The translation matrix.</returns>
         public static Matrix4X4<T> CreateTranslation<T>(Vector3D<T> position)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
             result.M41 = position.X;
@@ -796,7 +799,7 @@ public static Matrix4X4<T> CreateTranslation<T>(Vector3D<T> position)
         /// <param name="zPosition">The amount to translate on the Z-axis.</param>
         /// <returns>The translation matrix.</returns>
         public static Matrix4X4<T> CreateTranslation<T>(T xPosition, T yPosition, T zPosition)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity; ;
             result.M41 = xPosition;
@@ -811,7 +814,7 @@ public static Matrix4X4<T> CreateTranslation<T>(T xPosition, T yPosition, T zPos
         /// <param name="up">Upward direction of the object; usually [0, 1, 0].</param>
         /// <returns>The world matrix.</returns>
         public static Matrix4X4<T> CreateWorld<T>(Vector3D<T> position, Vector3D<T> forward, Vector3D<T> up)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector3D<T> zaxis = Vector3D.Normalize(-forward);
             Vector3D<T> xaxis = Vector3D.Normalize(Vector3D.Cross(up, zaxis));
@@ -845,7 +848,7 @@ public static Matrix4X4<T> CreateWorld<T>(Vector3D<T> position, Vector3D<T> forw
         ///
         [MethodImpl((MethodImplOptions) 768)]
         public static unsafe bool Invert<T>(Matrix4X4<T> matrix, out Matrix4X4<T> result)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // This implementation is based on the DirectX Math Library XMMatrixInverse method
             // https://github.com/microsoft/DirectXMath/blob/master/Inc/DirectXMathMatrix.inl
@@ -1137,7 +1140,7 @@ static bool SoftwareFallback(Matrix4X4<T> matrix, out Matrix4X4<T> result)
 
                 T det = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(a, a11), Scalar.Multiply(b, a12)), Scalar.Multiply(c, a13)), Scalar.Multiply(d, a14));
 
-                if (!Scalar.GreaterThanOrEqual(Scalar.Abs(det), Scalar<T>.Epsilon))
+                if (!Scalar.GreaterThanOrEqual(T.Abs(det), Scalar<T>.Epsilon))
                 {
                     result = new Matrix4X4<T>(Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN,
                                            Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN, Scalar<T>.NaN,
@@ -1195,7 +1198,7 @@ static bool SoftwareFallback(Matrix4X4<T> matrix, out Matrix4X4<T> result)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
@@ -1204,7 +1207,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -1213,7 +1216,7 @@ public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix4X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by another matrix.</summary>
@@ -1222,7 +1225,7 @@ public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -1231,7 +1234,7 @@ public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -1239,7 +1242,7 @@ public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, T value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Negate<T>(Matrix4X4<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -1248,7 +1251,7 @@ public static Matrix4X4<T> Negate<T>(Matrix4X4<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix4X4<T> Subtract<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
 
         /*[MethodImpl((MethodImplOptions)768)]
@@ -1269,6 +1272,7 @@ private static Vector128<T> Permute(Vector128<T> value, byte control)
             }
         }*/
 
+        /*
         /// <summary>Attempts to extract the scale, translation, and rotation components from the given scale/rotation/translation matrix.
         /// If successful, the out parameters will contained the extracted values.</summary>
         /// <param name="matrix">The source matrix.</param>
@@ -1277,7 +1281,7 @@ private static Vector128<T> Permute(Vector128<T> value, byte control)
         /// <param name="translation">The translation component of the transformation matrix</param>
         /// <returns>True if the source matrix was successfully decomposed; False otherwise.</returns>
         public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out Silk.NET.Maths.Legacy.Quaternion<T> rotation, out Vector3D<T> translation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             bool result = true;
 
@@ -1467,29 +1471,14 @@ public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out
 
             return result;
         }
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix4X4<T> Lerp<T>(Matrix4X4<T> matrix1, Matrix4X4<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                    Vector4D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                    Vector4D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                    Vector4D.Lerp(matrix1.Row3, matrix2.Row3, amount),
-                    Vector4D.Lerp(matrix1.Row4, matrix2.Row4, amount)
-                );
-        }
+        */
 
         /// <summary>Transforms the given matrix by applying the given Quaternion rotation.</summary>
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
         public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
@@ -1534,7 +1523,7 @@ public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Legacy.Quaternion<T>
         /// <param name="matrix">The source matrix.</param>
         /// <returns>The transposed matrix.</returns>
         public static unsafe Matrix4X4<T> Transpose<T>(Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return new(matrix.Column1, matrix.Column2, matrix.Column3, matrix.Column4);
         }
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index 1bc8c0553a..700a86cdb5 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,266 +12,8 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 4x4 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix4X4<T> : IEquatable<Matrix4X4<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix4X4<T>
     {
-        private static readonly Matrix4X4<T> _identity = new
-        (
-            Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One
-        );
-
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row3;
-
-        /// <summary>
-        /// Row 4 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row4;
-
-        /// <summary>
-        /// Column 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
-
-        /// <summary>
-        /// Column 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y, Row4.Y);
-
-        /// <summary>
-        /// Column 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z, Row4.Z);
-
-        /// <summary>
-        /// Column 4 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Column4 => new(Row1.W, Row2.W, Row3.W, Row4.W);
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 1, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M14
-        {
-            readonly get => Row1.W;
-            set => Row1.W = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M24
-        {
-            readonly get => Row2.W;
-            set => Row2.W = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M33
-        {
-            readonly get => Row3.Z;
-            set => Row3.Z = value;
-        }
-
-        /// <summary>Value at row 3, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M34
-        {
-            readonly get => Row3.W;
-            set => Row3.W = value;
-        }
-
-        /// <summary>Value at row 4, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M41
-        {
-            readonly get => Row4.X;
-            set => Row4.X = value;
-        }
-
-        /// <summary>Value at row 4, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M42
-        {
-            readonly get => Row4.Y;
-            set => Row4.Y = value;
-        }
-
-        /// <summary>Value at row 4, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M43
-        {
-            readonly get => Row4.Z;
-            set => Row4.Z = value;
-        }
-
-        /// <summary>Value at row 4, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M44
-        {
-            readonly get => Row4.W;
-            set => Row4.W = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector4D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 3 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix4X4{T}"/> from the given rows
-        /// </summary>
-        public Matrix4X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-            Row4 = row4;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix4X4{T}"/> from the given components.</summary>
-        public Matrix4X4
-        (
-            T m11,
-            T m12,
-            T m13,
-            T m14,
-            T m21,
-            T m22,
-            T m23,
-            T m24,
-            T m31,
-            T m32,
-            T m33,
-            T m34,
-            T m41,
-            T m42,
-            T m43,
-            T m44
-        )
-        {
-            Row1 = new(m11, m12, m13, m14);
-            Row2 = new(m21, m22, m23, m24);
-            Row3 = new(m31, m32, m33, m34);
-            Row4 = new(m41, m42, m43, m44);
-        }
-
         /// <summary>Constructs a <see cref="Matrix4X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix4X4(Matrix3X2<T> value)
@@ -331,9 +74,6 @@ public Matrix4X4(Matrix4X2<T> value)
             Row4 = new(value.M41, value.M42, default, Scalar<T>.One);
         }
 
-        /// <summary>Returns the multiplicative identity matrix.</summary>
-        public static Matrix4X4<T> Identity => _identity;
-
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity
@@ -347,67 +87,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M34, Scalar<T>.Zero) && Scalar.Equal(M41, Scalar<T>.Zero) &&
                Scalar.Equal(M42, Scalar<T>.Zero) && Scalar.Equal(M43, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix4X4<T> operator +(Matrix4X4<T> value1, Matrix4X4<T> value2)
-        {
-            return new
-            (
-                value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3,
-                value1.Row4 + value2.Row4
-            );
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix4X4<T> value1, Matrix4X4<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   Scalar.Equal(value1.M33, value2.M33) &&
-                   Scalar.Equal(value1.M44, value2.M44) && // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M14, value2.M14) && Scalar.Equal(value1.M21, value2.M21) &&
-                   Scalar.Equal(value1.M23, value2.M23) && Scalar.Equal(value1.M24, value2.M24) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32) &&
-                   Scalar.Equal(value1.M34, value2.M34) && Scalar.Equal(value1.M41, value2.M41) &&
-                   Scalar.Equal(value1.M42, value2.M42) && Scalar.Equal(value1.M43, value2.M43);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix4X4<T> value1, Matrix4X4<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||
-                   Scalar.NotEqual(value1.M33, value2.M33) ||
-                   Scalar.NotEqual(value1.M44, value2.M44) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M14, value2.M14) || Scalar.NotEqual(value1.M21, value2.M21) ||
-                   Scalar.NotEqual(value1.M23, value2.M23) || Scalar.NotEqual(value1.M24, value2.M24) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32) ||
-                   Scalar.NotEqual(value1.M34, value2.M34) || Scalar.NotEqual(value1.M41, value2.M41) ||
-                   Scalar.NotEqual(value1.M42, value2.M42) || Scalar.NotEqual(value1.M43, value2.M43);
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X4<T> operator *(Matrix4X4<T> value1, Matrix4X4<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                    value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3 + value1.M34 * value2.Row4,
-                    value1.M41 * value2.Row1 + value1.M42 * value2.Row2 + value1.M43 * value2.Row3 + value1.M44 * value2.Row4
-                );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -418,33 +97,6 @@ public readonly bool IsIdentity
                    value1.W * value2.Row4;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X4<T> operator *(Matrix3X4<T> value1, Matrix4X4<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3 + value1.M34 * value2.Row4
-            );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X3<T> operator *(Matrix4X4<T> value1, Matrix4X3<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3 + value1.M34 * value2.Row4,
-                value1.M41 * value2.Row1 + value1.M42 * value2.Row2 + value1.M43 * value2.Row3 + value1.M44 * value2.Row4
-            );
-        }
-
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
@@ -459,46 +111,6 @@ public readonly bool IsIdentity
                 );
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix4X4<T> operator -(Matrix4X4<T> value1, Matrix4X4<T> value2)
-        {
-            return new(
-                    value1.Row1 - value2.Row1,
-                    value1.Row2 - value2.Row2,
-                    value1.Row3 - value2.Row3,
-                    value1.Row4 - value2.Row4
-                );
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix4X4<T> operator -(Matrix4X4<T> value)
-        {
-            return new(
-                -value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4
-            );
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix4X4<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix4X4<T> other)
-            => this == other;
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -563,35 +175,6 @@ public readonly T GetDeterminant()
                             Scalar.Multiply(g, in_jm)))));
         }
 
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-            hash.Add(M14);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-            hash.Add(M24);
-
-            hash.Add(M31);
-            hash.Add(M32);
-            hash.Add(M33);
-            hash.Add(M34);
-
-            hash.Add(M41);
-            hash.Add(M42);
-            hash.Add(M43);
-            hash.Add(M44);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -824,7 +407,7 @@ public static explicit operator Matrix4X4<long>(Matrix4X4<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix4X4<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix4X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
new file mode 100644
index 0000000000..7fe91550bb
--- /dev/null
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -0,0 +1,309 @@
+namespace Silk.NET.Maths
+{
+    using System.Diagnostics.CodeAnalysis;
+    using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+
+    public partial struct Matrix4X4<T> :
+        IEquatable<Matrix4X4<T>>
+        where T : INumberBase<T>
+    {
+        /// <summary>The multiplicative identity matrix of size 4x4.</summary>
+        public static Matrix4X4<T> Identity { get; } = new(
+            new(T.MultiplicativeIdentity, T.Zero, T.Zero, T.Zero),
+            new(T.Zero, T.MultiplicativeIdentity, T.Zero, T.Zero),
+            new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
+            new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
+
+        /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Row1;
+
+        /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Row2;
+
+        /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Row3;
+
+        /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Row4;
+
+        /// <summary>The 1st column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column1 => new(Row1.X, Row2.X, Row3.X, Row4.X);
+
+        /// <summary>The 2nd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column2 => new(Row1.Y, Row2.Y, Row3.Y, Row4.Y);
+
+        /// <summary>The 3rd column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column3 => new(Row1.Z, Row2.Z, Row3.Z, Row4.Z);
+
+        /// <summary>The 4th column of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
+        public Vector4D<T> Column4 => new(Row1.W, Row2.W, Row3.W, Row4.W);
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4X4{T}"/> from the given rows.
+        /// </summary>
+        public Matrix4X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4) =>
+            (Row1, Row2, Row3, Row4) = (row1, row2, row3, row4);
+
+        /// <summary>
+        /// Constructs a <see cref="Matrix4X4{T}"/> from the given components.
+        /// </summary>
+        public Matrix4X4(
+            T m11, T m12, T m13, T m14,
+            T m21, T m22, T m23, T m24,
+            T m31, T m32, T m33, T m34,
+            T m41, T m42, T m43, T m44)
+        {
+            Row1 = new(m11, m12, m13, m14);
+            Row2 = new(m21, m22, m23, m24);
+            Row3 = new(m31, m32, m33, m34);
+            Row4 = new(m41, m42, m43, m44);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        [UnscopedRef]
+        public ref Vector4D<T> this[int row]
+        {
+            get
+            {
+                switch (row)
+                {
+                    case 0:
+                        return ref Row1;
+                    case 1:
+                        return ref Row2;
+                    case 2:
+                        return ref Row3;
+                    case 3:
+                        return ref Row4;
+                }
+
+                throw new IndexOutOfRangeException();
+            }
+        }
+
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
+        [UnscopedRef]
+        public ref T this[int row, int column] => ref this[row][column];
+
+        /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M11 => ref Row1.X;
+
+        /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M12 => ref Row1.Y;
+
+        /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M13 => ref Row1.Z;
+
+        /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M14 => ref Row1.W;
+
+        /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M21 => ref Row2.X;
+
+        /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M22 => ref Row2.Y;
+
+        /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M23 => ref Row2.Z;
+
+        /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M24 => ref Row2.W;
+
+        /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M31 => ref Row3.X;
+
+        /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M32 => ref Row3.Y;
+
+        /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M33 => ref Row3.Z;
+
+        /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M34 => ref Row3.W;
+
+        /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M41 => ref Row4.X;
+
+        /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M42 => ref Row4.Y;
+
+        /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M43 => ref Row4.Z;
+
+        /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
+        [DataMember]
+        [UnscopedRef]
+        public ref T M44 => ref Row4.W;
+
+        /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+        public override bool Equals(object? obj) => obj is Matrix4X4<T> other && Equals(other);
+
+        /// <inheridoc/>
+        public bool Equals(Matrix4X4<T> other) => this == other;
+
+        /// <inheridoc/>
+        public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
+
+        /// <summary>Computes the transpose of the matrix.</summary>
+        public Matrix4X4<T> Transpose() =>
+            new(new(M11, M21, M31, M41),
+                new(M12, M22, M32, M42),
+                new(M13, M23, M33, M43),
+                new(M14, M24, M34, M44));
+
+        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are equal; <c>false</c> otherwise.</returns>
+        public static bool operator ==(Matrix4X4<T> left, Matrix4X4<T> right) =>
+            left.Row1 == right.Row1 &&
+            left.Row2 == right.Row2 &&
+            left.Row3 == right.Row3 &&
+            left.Row4 == right.Row4;
+
+        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
+        /// <param name="left">The first matrix to compare.</param>
+        /// <param name="right">The second matrix to compare.</param>
+        /// <returns><c>true</c> if the given matrices are not equal; <c>false</c> otherwise.</returns>
+        public static bool operator !=(Matrix4X4<T> left, Matrix4X4<T> right) => !(left == right);
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4X4<T> operator +(Matrix4X4<T> left, Matrix4X4<T> right) =>
+            new(left.Row1 + right.Row1,
+                left.Row2 + right.Row2,
+                left.Row3 + right.Row3,
+                left.Row4 + right.Row4);
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4X4<T> operator -(Matrix4X4<T> left, Matrix4X4<T> right) =>
+            new(left.Row1 - right.Row1,
+                left.Row2 - right.Row2,
+                left.Row3 - right.Row3,
+                left.Row4 - right.Row4);
+
+        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4X4<T> operator -(Matrix4X4<T> value) =>
+            new(-value.Row1,
+                -value.Row2,
+                -value.Row3,
+                -value.Row4);
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> operator *(Matrix2X4<T> left, Matrix4X4<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4);
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> operator *(Matrix3X4<T> left, Matrix4X4<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> operator *(Matrix4X4<T> left, Matrix4X2<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> operator *(Matrix4X4<T> left, Matrix4X3<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> operator *(Matrix4X4<T> left, Matrix4X4<T> right) =>
+            new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
+                left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
+                left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
+                left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+    }
+
+    public static partial class Matrix4X4
+    {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
+        public static Matrix4X4<T> Lerp<T>(Matrix4X4<T> value1, Matrix4X4<T> value2, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector4D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector4D.Lerp(value1.Row3, value2.Row3, amount),
+                Vector4D.Lerp(value1.Row4, value2.Row4, amount));
+    }
+}
diff --git a/sources/Maths/Maths/Matrix5X4.Ops.cs b/sources/Maths/Maths/Matrix5X4.Ops.cs
index 18fe708f4e..032181692f 100644
--- a/sources/Maths/Maths/Matrix5X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix5X4.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -9,7 +10,7 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Methods for working with <see cref="Matrix4X4{T}"/>
     /// </summary>
-    public static class Matrix5X4
+    public static partial class Matrix5X4
     {
         /// <summary>Adds two matrices together.</summary>
         /// <param name="value1">The first source matrix.</param>
@@ -17,7 +18,7 @@ public static class Matrix5X4
         /// <returns>The resulting matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix5X4<T> Add<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             return value1 + value2;
         }
@@ -28,7 +29,7 @@ public static Matrix5X4<T> Add<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
         /// <returns>The result of the multiplication.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix5X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Multiplies a matrix by a scalar value.</summary>
@@ -37,7 +38,7 @@ public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix5X4<T> value2)
         /// <returns>The scaled matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> value1, T value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 * value2;
 
         /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
@@ -45,7 +46,7 @@ public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> value1, T value2)
         /// <returns>The negated matrix.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix5X4<T> Negate<T>(Matrix5X4<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => -value;
 
         /// <summary>Subtracts the second matrix from the first.</summary>
@@ -54,24 +55,7 @@ public static Matrix5X4<T> Negate<T>(Matrix5X4<T> value)
         /// <returns>The result of the subtraction.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Matrix5X4<T> Subtract<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => value1 - value2;
-
-        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
-        /// <param name="matrix1">The first source matrix.</param>
-        /// <param name="matrix2">The second source matrix.</param>
-        /// <param name="amount">The relative weight of the second source matrix.</param>
-        /// <returns>The interpolated matrix.</returns>
-        public static unsafe Matrix5X4<T> Lerp<T>(Matrix5X4<T> matrix1, Matrix5X4<T> matrix2, T amount)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
-        {
-            return new(
-                    Vector4D.Lerp(matrix1.Row1, matrix2.Row1, amount),
-                    Vector4D.Lerp(matrix1.Row2, matrix2.Row2, amount),
-                    Vector4D.Lerp(matrix1.Row3, matrix2.Row3, amount),
-                    Vector4D.Lerp(matrix1.Row4, matrix2.Row4, amount),
-                    Vector4D.Lerp(matrix1.Row5, matrix2.Row5, amount)
-                );
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix5X4.cs b/sources/Maths/Maths/Matrix5X4.cs
index 348ba77941..b9c85c3f89 100644
--- a/sources/Maths/Maths/Matrix5X4.cs
+++ b/sources/Maths/Maths/Matrix5X4.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -11,8 +12,7 @@ namespace Silk.NET.Maths
     /// <summary>A structure encapsulating a 4x4 matrix.</summary>
     [Serializable]
     [DataContract]
-    public struct Matrix5X4<T> : IEquatable<Matrix5X4<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+    public partial struct Matrix5X4<T>
     {
         private static readonly Matrix5X4<T> _identity = new
         (
@@ -23,275 +23,6 @@ public struct Matrix5X4<T> : IEquatable<Matrix5X4<T>>
             Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero
         );
 
-        /// <summary>
-        /// Row 1 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row1;
-
-        /// <summary>
-        /// Row 2 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row2;
-
-        /// <summary>
-        /// Row 3 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row3;
-
-        /// <summary>
-        /// Row 4 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row4;
-
-        /// <summary>
-        /// Row 5 of the matrix.
-        /// </summary>
-        [IgnoreDataMember]
-        public Vector4D<T> Row5;
-
-        /// <summary>Value at row 1, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M11
-        {
-            readonly get => Row1.X;
-            set => Row1.X = value;
-        }
-
-        /// <summary>Value at row 1, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M12
-        {
-            readonly get => Row1.Y;
-            set => Row1.Y = value;
-        }
-
-        /// <summary>Value at row 1, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M13
-        {
-            readonly get => Row1.Z;
-            set => Row1.Z = value;
-        }
-
-        /// <summary>Value at row 1, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M14
-        {
-            readonly get => Row1.W;
-            set => Row1.W = value;
-        }
-
-        /// <summary>Value at row 2, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M21
-        {
-            readonly get => Row2.X;
-            set => Row2.X = value;
-        }
-
-        /// <summary>Value at row 2, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M22
-        {
-            readonly get => Row2.Y;
-            set => Row2.Y = value;
-        }
-
-        /// <summary>Value at row 2, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M23
-        {
-            readonly get => Row2.Z;
-            set => Row2.Z = value;
-        }
-
-        /// <summary>Value at row 2, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M24
-        {
-            readonly get => Row2.W;
-            set => Row2.W = value;
-        }
-
-        /// <summary>Value at row 3, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M31
-        {
-            readonly get => Row3.X;
-            set => Row3.X = value;
-        }
-
-        /// <summary>Value at row 3, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M32
-        {
-            readonly get => Row3.Y;
-            set => Row3.Y = value;
-        }
-
-        /// <summary>Value at row 3, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M33
-        {
-            readonly get => Row3.Z;
-            set => Row3.Z = value;
-        }
-
-        /// <summary>Value at row 3, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M34
-        {
-            readonly get => Row3.W;
-            set => Row3.W = value;
-        }
-
-        /// <summary>Value at row 4, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M41
-        {
-            readonly get => Row4.X;
-            set => Row4.X = value;
-        }
-
-        /// <summary>Value at row 4, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M42
-        {
-            readonly get => Row4.Y;
-            set => Row4.Y = value;
-        }
-
-        /// <summary>Value at row 4, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M43
-        {
-            readonly get => Row4.Z;
-            set => Row4.Z = value;
-        }
-
-        /// <summary>Value at row 4, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M44
-        {
-            readonly get => Row4.W;
-            set => Row4.W = value;
-        }
-
-        /// <summary>Value at row 5, column 1 of the matrix.</summary>
-        [DataMember]
-        public T M51
-        {
-            readonly get => Row5.X;
-            set => Row5.X = value;
-        }
-
-        /// <summary>Value at row 5, column 2 of the matrix.</summary>
-        [DataMember]
-        public T M52
-        {
-            readonly get => Row5.Y;
-            set => Row5.Y = value;
-        }
-
-        /// <summary>Value at row 5, column 3 of the matrix.</summary>
-        [DataMember]
-        public T M53
-        {
-            readonly get => Row5.Z;
-            set => Row5.Z = value;
-        }
-
-        /// <summary>Value at row 5, column 4 of the matrix.</summary>
-        [DataMember]
-        public T M54
-        {
-            readonly get => Row5.W;
-            set => Row5.W = value;
-        }
-
-        /// <summary>
-        /// Indexer for the rows of this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        public unsafe Vector4D<T> this[int x]
-        {
-            get
-            {
-                static void VerifyBounds(int i)
-                {
-                    static void ThrowHelper() => throw new IndexOutOfRangeException();
-
-                    if (i > 4 || i < 0)
-                        ThrowHelper();
-                }
-
-                VerifyBounds(x);
-                return Unsafe.Add(ref Row1, x);
-            }
-        }
-
-        /// <summary>
-        /// Indexer for the values in this matrix.
-        /// </summary>
-        /// <param name="x">The row to select. Zero based.</param>
-        /// <param name="y">The column to select. Zero based.</param>
-        public unsafe T this[int x, int y]
-        {
-            get
-            {
-                var row = this[x];
-                return row[y];
-            }
-        }
-
-        /// <summary>
-        /// Constructs a <see cref="Matrix5X4{T}"/> from the given rows
-        /// </summary>
-        public Matrix5X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4, Vector4D<T> row5)
-        {
-            Row1 = row1;
-            Row2 = row2;
-            Row3 = row3;
-            Row4 = row4;
-            Row5 = row5;
-        }
-
-        /// <summary>Constructs a <see cref="Matrix5X4{T}"/> from the given components.</summary>
-        public Matrix5X4
-        (
-            T m11,
-            T m12,
-            T m13,
-            T m14,
-            T m21,
-            T m22,
-            T m23,
-            T m24,
-            T m31,
-            T m32,
-            T m33,
-            T m34,
-            T m41,
-            T m42,
-            T m43,
-            T m44,
-            T m51,
-            T m52,
-            T m53,
-            T m54
-        )
-        {
-            Row1 = new(m11, m12, m13, m14);
-            Row2 = new(m21, m22, m23, m24);
-            Row3 = new(m31, m32, m33, m34);
-            Row4 = new(m41, m42, m43, m44);
-            Row5 = new(m51, m52, m53, m54);
-        }
-
         /// <summary>Constructs a <see cref="Matrix5X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix5X4(Matrix3X2<T> value)
@@ -387,57 +118,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M51, Scalar<T>.Zero) && Scalar.Equal(M52, Scalar<T>.Zero) &&
                Scalar.Equal(M53, Scalar<T>.Zero) && Scalar.Equal(M54, Scalar<T>.Zero);
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static unsafe Matrix5X4<T> operator +(Matrix5X4<T> value1, Matrix5X4<T> value2)
-        {
-            return new
-            (
-                value1.Row1 + value2.Row1, value1.Row2 + value2.Row2, value1.Row3 + value2.Row3,
-                value1.Row4 + value2.Row4, value1.Row5 + value2.Row5
-            );
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are equal; False otherwise.</returns>
-        public static unsafe bool operator ==(Matrix5X4<T> value1, Matrix5X4<T> value2)
-        {
-            return Scalar.Equal(value1.M11, value2.M11) && Scalar.Equal(value1.M22, value2.M22) &&
-                   Scalar.Equal(value1.M33, value2.M33) &&
-                   Scalar.Equal(value1.M44, value2.M44) && // Check diagonal elements first for early out.
-                   Scalar.Equal(value1.M12, value2.M12) && Scalar.Equal(value1.M13, value2.M13) &&
-                   Scalar.Equal(value1.M14, value2.M14) && Scalar.Equal(value1.M21, value2.M21) &&
-                   Scalar.Equal(value1.M23, value2.M23) && Scalar.Equal(value1.M24, value2.M24) &&
-                   Scalar.Equal(value1.M31, value2.M31) && Scalar.Equal(value1.M32, value2.M32) &&
-                   Scalar.Equal(value1.M34, value2.M34) && Scalar.Equal(value1.M41, value2.M41) &&
-                   Scalar.Equal(value1.M42, value2.M42) && Scalar.Equal(value1.M43, value2.M43) &&
-                   Scalar.Equal(value1.M51, value2.M51) && Scalar.Equal(value1.M52, value2.M52) &&
-                   Scalar.Equal(value1.M53, value2.M53) && Scalar.Equal(value1.M54, value2.M54);
-        }
-
-        /// <summary>Returns a boolean indicating whether the given two matrices are not equal.</summary>
-        /// <param name="value1">The first matrix to compare.</param>
-        /// <param name="value2">The second matrix to compare.</param>
-        /// <returns>True if the given matrices are not equal; False if they are equal.</returns>
-        public static unsafe bool operator !=(Matrix5X4<T> value1, Matrix5X4<T> value2)
-        {
-            return Scalar.NotEqual(value1.M11, value2.M11) || Scalar.NotEqual(value1.M22, value2.M22) ||
-                   Scalar.NotEqual(value1.M33, value2.M33) ||
-                   Scalar.NotEqual(value1.M44, value2.M44) || // Check diagonal elements first for early out.
-                   Scalar.NotEqual(value1.M12, value2.M12) || Scalar.NotEqual(value1.M13, value2.M13) ||
-                   Scalar.NotEqual(value1.M14, value2.M14) || Scalar.NotEqual(value1.M21, value2.M21) ||
-                   Scalar.NotEqual(value1.M23, value2.M23) || Scalar.NotEqual(value1.M24, value2.M24) ||
-                   Scalar.NotEqual(value1.M31, value2.M31) || Scalar.NotEqual(value1.M32, value2.M32) ||
-                   Scalar.NotEqual(value1.M34, value2.M34) || Scalar.NotEqual(value1.M41, value2.M41) ||
-                   Scalar.NotEqual(value1.M42, value2.M42) || Scalar.NotEqual(value1.M43, value2.M43) ||
-                   Scalar.NotEqual(value1.M51, value2.M51) || Scalar.NotEqual(value1.M52, value2.M52) ||
-                   Scalar.NotEqual(value1.M53, value2.M53) || Scalar.NotEqual(value1.M54, value2.M54);
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -463,82 +143,6 @@ public readonly bool IsIdentity
                 );
         }
 
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        public static unsafe Matrix5X4<T> operator -(Matrix5X4<T> value1, Matrix5X4<T> value2)
-        {
-            return new(
-                    value1.Row1 - value2.Row1,
-                    value1.Row2 - value2.Row2,
-                    value1.Row3 - value2.Row3,
-                    value1.Row4 - value2.Row4,
-                    value1.Row5 - value2.Row5
-                );
-        }
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        public static unsafe Matrix5X4<T> operator -(Matrix5X4<T> value)
-        {
-            return new(
-                -value.Row1,
-                -value.Row2,
-                -value.Row3,
-                -value.Row4,
-                -value.Row5
-            );
-        }
-
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this matrix instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this matrix; False otherwise.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public override readonly bool Equals(object? obj)
-            => (obj is Matrix5X4<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether this matrix instance is equal to the other given matrix.</summary>
-        /// <param name="other">The matrix to compare this instance to.</param>
-        /// <returns>True if the matrices are equal; False otherwise.</returns>
-        public readonly bool Equals(Matrix5X4<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>   
-        public override readonly int GetHashCode()
-        {
-            HashCode hash = default;
-
-            hash.Add(M11);
-            hash.Add(M12);
-            hash.Add(M13);
-            hash.Add(M14);
-
-            hash.Add(M21);
-            hash.Add(M22);
-            hash.Add(M23);
-            hash.Add(M24);
-
-            hash.Add(M31);
-            hash.Add(M32);
-            hash.Add(M33);
-            hash.Add(M34);
-
-            hash.Add(M41);
-            hash.Add(M42);
-            hash.Add(M43);
-            hash.Add(M44);
-
-            hash.Add(M51);
-            hash.Add(M52);
-            hash.Add(M53);
-            hash.Add(M54);
-
-            return hash.ToHashCode();
-        }
-
         /// <summary>Returns a String representing this matrix instance.</summary>
         /// <returns>The string representation.</returns>
         public override readonly string ToString()
@@ -796,7 +400,7 @@ public static explicit operator Matrix5X4<long>(Matrix5X4<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted matrix</returns>
-        public Matrix5X4<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Matrix5X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>(), Row5.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index f2eeff2e38..c4da23f556 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -2,31 +2,60 @@ namespace Silk.NET.Maths
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Numerics;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
 
     public partial struct Matrix5X4<T> :
         IEquatable<Matrix5X4<T>>
         where T : INumberBase<T>
     {
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row1;
 
         /// <summary>The 2nd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row2;
 
         /// <summary>The 3rd row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row3;
 
         /// <summary>The 4th row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row4;
 
         /// <summary>The 5th row of the matrix represented as a vector.</summary>
+        [IgnoreDataMember]
         public Vector4D<T> Row5;
 
         /// <summary>
         /// Constructs a <see cref="Matrix5X4{T}"/> from the given rows.
         /// </summary>
-        public Matrix5X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4, Vector4D<T> row5) => (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
+        public Matrix5X4(Vector4D<T> row1, Vector4D<T> row2, Vector4D<T> row3, Vector4D<T> row4, Vector4D<T> row5) =>
+            (Row1, Row2, Row3, Row4, Row5) = (row1, row2, row3, row4, row5);
 
+        /// <summary>
+        /// Constructs a <see cref="Matrix5X4{T}"/> from the given components.
+        /// </summary>
+        public Matrix5X4(
+            T m11, T m12, T m13, T m14,
+            T m21, T m22, T m23, T m24,
+            T m31, T m32, T m33, T m34,
+            T m41, T m42, T m43, T m44,
+            T m51, T m52, T m53, T m54)
+        {
+            Row1 = new(m11, m12, m13, m14);
+            Row2 = new(m21, m22, m23, m24);
+            Row3 = new(m31, m32, m33, m34);
+            Row4 = new(m41, m42, m43, m44);
+            Row5 = new(m51, m52, m53, m54);
+        }
+
+        /// <summary>
+        /// Indexer for the rows of this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
         [UnscopedRef]
         public ref Vector4D<T> this[int row]
         {
@@ -46,94 +75,120 @@ public ref Vector4D<T> this[int row]
                         return ref Row5;
                 }
 
-                throw new ArgumentOutOfRangeException(nameof(row));
+                throw new IndexOutOfRangeException();
             }
         }
 
+        /// <summary>
+        /// Indexer for the values in this matrix.
+        /// </summary>
+        /// <param name="row">The row to select. Zero based.</param>
+        /// <param name="column">The column to select. Zero based.</param>
         [UnscopedRef]
         public ref T this[int row, int column] => ref this[row][column];
 
         /// <summary>Gets the element in the 1st row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M11 => ref Row1.X;
 
         /// <summary>Gets the element in the 1st row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M12 => ref Row1.Y;
 
         /// <summary>Gets the element in the 1st row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M13 => ref Row1.Z;
 
         /// <summary>Gets the element in the 1st row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M14 => ref Row1.W;
 
         /// <summary>Gets the element in the 2nd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M21 => ref Row2.X;
 
         /// <summary>Gets the element in the 2nd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
         /// <summary>Gets the element in the 2nd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
         /// <summary>Gets the element in the 2nd row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M24 => ref Row2.W;
 
         /// <summary>Gets the element in the 3rd row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M31 => ref Row3.X;
 
         /// <summary>Gets the element in the 3rd row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
         /// <summary>Gets the element in the 3rd row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M33 => ref Row3.Z;
 
         /// <summary>Gets the element in the 3rd row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M34 => ref Row3.W;
 
         /// <summary>Gets the element in the 4th row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M41 => ref Row4.X;
 
         /// <summary>Gets the element in the 4th row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M42 => ref Row4.Y;
 
         /// <summary>Gets the element in the 4th row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M43 => ref Row4.Z;
 
         /// <summary>Gets the element in the 4th row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M44 => ref Row4.W;
 
         /// <summary>Gets the element in the 5th row and 1st column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M51 => ref Row5.X;
 
         /// <summary>Gets the element in the 5th row and 2nd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M52 => ref Row5.Y;
 
         /// <summary>Gets the element in the 5th row and 3rd column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M53 => ref Row5.Z;
 
         /// <summary>Gets the element in the 5th row and 4th column of the matrix.</summary>
+        [DataMember]
         [UnscopedRef]
         public ref T M54 => ref Row5.W;
 
         /// <inheridoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix5X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -205,12 +260,17 @@ public ref Vector4D<T> this[int row]
 
     public static partial class Matrix5X4
     {
+        /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
+        /// <param name="value1">The first source matrix.</param>
+        /// <param name="value2">The second source matrix.</param>
+        /// <param name="amount">The relative weight of the second source matrix.</param>
+        /// <returns>The interpolated matrix.</returns>
         public static Matrix5X4<T> Lerp<T>(Matrix5X4<T> value1, Matrix5X4<T> value2, T amount)
             where T : IFloatingPointIeee754<T> =>
-            new(new(T.Lerp(value1.M11, value2.M11, amount), T.Lerp(value1.M12, value2.M12, amount), T.Lerp(value1.M13, value2.M13, amount), T.Lerp(value1.M14, value2.M14, amount)),
-                new(T.Lerp(value1.M21, value2.M21, amount), T.Lerp(value1.M22, value2.M22, amount), T.Lerp(value1.M23, value2.M23, amount), T.Lerp(value1.M24, value2.M24, amount)),
-                new(T.Lerp(value1.M31, value2.M31, amount), T.Lerp(value1.M32, value2.M32, amount), T.Lerp(value1.M33, value2.M33, amount), T.Lerp(value1.M34, value2.M34, amount)),
-                new(T.Lerp(value1.M41, value2.M41, amount), T.Lerp(value1.M42, value2.M42, amount), T.Lerp(value1.M43, value2.M43, amount), T.Lerp(value1.M44, value2.M44, amount)),
-                new(T.Lerp(value1.M51, value2.M51, amount), T.Lerp(value1.M52, value2.M52, amount), T.Lerp(value1.M53, value2.M53, amount), T.Lerp(value1.M54, value2.M54, amount)));
+            new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
+                Vector4D.Lerp(value1.Row2, value2.Row2, amount),
+                Vector4D.Lerp(value1.Row3, value2.Row3, amount),
+                Vector4D.Lerp(value1.Row4, value2.Row4, amount),
+                Vector4D.Lerp(value1.Row5, value2.Row5, amount));
     }
 }

From acaf6b4b28d4311d929cd402a1dcc31320de4510 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Mon, 30 Jun 2025 19:45:25 -0700
Subject: [PATCH 37/52] Update existing types to use INumberBase.

---
 sources/Maths/Maths/Box2D.cs             |  9 +++++----
 sources/Maths/Maths/Box3D.cs             |  4 ++--
 sources/Maths/Maths/Circle.cs            |  8 +++++---
 sources/Maths/Maths/Cube.cs              |  9 +++++----
 sources/Maths/Maths/Legacy/Quaternion.cs |  6 ++++--
 sources/Maths/Maths/Plane.Ops.cs         | 17 +++++++++--------
 sources/Maths/Maths/Plane.cs             | 10 ++++++----
 sources/Maths/Maths/Ray2D.cs             |  8 +++++---
 sources/Maths/Maths/Ray3D.cs             |  7 ++++---
 sources/Maths/Maths/Rectangle.Ops.cs     |  5 +++--
 sources/Maths/Maths/Rectangle.cs         |  9 +++++----
 sources/Maths/Maths/Sphere.cs            |  7 ++++---
 12 files changed, 57 insertions(+), 42 deletions(-)

diff --git a/sources/Maths/Maths/Box2D.cs b/sources/Maths/Maths/Box2D.cs
index c9b4945be4..a5536faf6e 100644
--- a/sources/Maths/Maths/Box2D.cs
+++ b/sources/Maths/Maths/Box2D.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -14,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Box2D<T>
         : IEquatable<Box2D<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The min.
@@ -148,7 +149,7 @@ public Box2D<T> GetScaled(Vector2D<T> scale, Vector2D<T> anchor)
         /// <typeparam name="TScale">The type of the scale.</typeparam>
         /// <returns>The calculated box.</returns>
         public Box2D<T> GetScaled<TScale>(Vector2D<TScale> scale, Vector2D<T> anchor)
-            where TScale : unmanaged, IFormattable, IEquatable<TScale>, IComparable<TScale>
+            where TScale : INumberBase<TScale>
         {
             return this.As<TScale>().GetScaled(scale, anchor.As<TScale>()).As<T>();
         }
@@ -209,9 +210,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
-        public Box2D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Box2D<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Box3D.cs b/sources/Maths/Maths/Box3D.cs
index 48812a2039..f32a0afd1f 100644
--- a/sources/Maths/Maths/Box3D.cs
+++ b/sources/Maths/Maths/Box3D.cs
@@ -15,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Box3D<T>
         : IEquatable<Box3D<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The min.
@@ -222,7 +222,7 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
-        public Box3D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Box3D<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Circle.cs b/sources/Maths/Maths/Circle.cs
index fafcc12f4d..fd0a4ff342 100644
--- a/sources/Maths/Maths/Circle.cs
+++ b/sources/Maths/Maths/Circle.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.Serialization;
 
 namespace Silk.NET.Maths
@@ -12,7 +13,8 @@ namespace Silk.NET.Maths
     [Serializable]
     [DataContract]
     public struct Circle<T>
-        : IEquatable<Circle<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        : IEquatable<Circle<T>>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The center.
@@ -172,9 +174,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted circle</returns>
-        public Circle<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Circle<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Center.As<TOther>(), Scalar.As<T, TOther>(Radius));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Cube.cs b/sources/Maths/Maths/Cube.cs
index c5ef00cca7..b0a2e2a3c2 100644
--- a/sources/Maths/Maths/Cube.cs
+++ b/sources/Maths/Maths/Cube.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -14,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Cube<T>
         : IEquatable<Cube<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The origin.
@@ -169,7 +170,7 @@ public Cube<T> GetScaled(Vector3D<T> scale, Vector3D<T> anchor)
         /// <param name="anchor">The anchor.</param>
         /// <returns>The calculated cube.</returns>
         public Cube<T> GetScaled<TScale>(Vector3D<TScale> scale, Vector3D<T> anchor)
-            where TScale : unmanaged, IFormattable, IEquatable<TScale>, IComparable<TScale>
+            where TScale : INumberBase<TScale>
         {
             var convertedAnchor = anchor.As<TScale>();
             var min = (scale * (Origin.As<TScale>() - convertedAnchor)) + convertedAnchor;
@@ -235,9 +236,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted cube</returns>
-        public Cube<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Cube<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Origin.As<TOther>(), Max.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Legacy/Quaternion.cs b/sources/Maths/Maths/Legacy/Quaternion.cs
index b0c46916b9..2694588fca 100644
--- a/sources/Maths/Maths/Legacy/Quaternion.cs
+++ b/sources/Maths/Maths/Legacy/Quaternion.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using Silk.NET.Maths;
@@ -16,7 +17,8 @@ namespace Silk.NET.Maths.Legacy
     [Serializable]
     [DataContract]
     public struct Quaternion<T>
-        : IEquatable<Quaternion<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        : IEquatable<Quaternion<T>>
+        where T : INumberBase<T>
     {
         private const float SlerpEpsilon = 1e-6f;
 
@@ -786,7 +788,7 @@ public static explicit operator Quaternion<long>(Quaternion<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted quaternion</returns>
-        public Quaternion<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Quaternion<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z), Scalar.As<T, TOther>(W));
         }
diff --git a/sources/Maths/Maths/Plane.Ops.cs b/sources/Maths/Maths/Plane.Ops.cs
index 24879072fb..fff64125ca 100644
--- a/sources/Maths/Maths/Plane.Ops.cs
+++ b/sources/Maths/Maths/Plane.Ops.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Maths
@@ -18,7 +19,7 @@ public static class Plane
         /// <returns>The Plane containing the three points.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Plane<T> CreateFromVertices<T>(Vector3D<T> point1, Vector3D<T> point2, Vector3D<T> point3)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             var a = point1;
             var b = point2;
@@ -86,7 +87,7 @@ public static Plane<T> CreateFromVertices<T>(Vector3D<T> point1, Vector3D<T> poi
         /// <returns>The dot product.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static T Dot<T>(Plane<T> plane, Vector4D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => Scalar.Add(
                 Scalar.Add(
                     Scalar.Add(Scalar.Multiply(plane.Normal.X, value.X),
@@ -99,7 +100,7 @@ public static T Dot<T>(Plane<T> plane, Vector4D<T> value)
         /// <returns>The resulting value.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static T DotCoordinate<T>(Plane<T> plane, Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => Scalar.Add(Vector3D.Dot(plane.Normal, value), plane.Distance);
 
         /// <summary>Returns the dot product of a specified Vector3D and the Normal vector of this Plane.</summary>
@@ -108,7 +109,7 @@ public static T DotCoordinate<T>(Plane<T> plane, Vector3D<T> value)
         /// <returns>The resulting dot product.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static T DotNormal<T>(Plane<T> plane, Vector3D<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
             => Vector3D.Dot(plane.Normal, value);
 
         private const float NormalizeEpsilon = 1.192092896e-07f; // smallest such that 1.0+NormalizeEpsilon != 1.0
@@ -118,7 +119,7 @@ public static T DotNormal<T>(Plane<T> plane, Vector3D<T> value)
         /// <returns>The normalized Plane.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Plane<T> Normalize<T>(Plane<T> value)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             /*if (Vector.IsHardwareAccelerated)
             {
@@ -140,7 +141,7 @@ public static Plane<T> Normalize<T>(Plane<T> value)
                         Scalar.Multiply(value.Normal.Y, value.Normal.Y)),
                     Scalar.Multiply(value.Normal.Z, value.Normal.Z));
 
-                if (!Scalar.GreaterThanOrEqual(Scalar.Abs(Scalar.Subtract(f, Scalar<T>.One)), Scalar.As<float, T>(NormalizeEpsilon)))
+                if (!Scalar.GreaterThanOrEqual(T.Abs(Scalar.Subtract(f, Scalar<T>.One)), Scalar.As<float, T>(NormalizeEpsilon)))
                 {
                     return value; // It already normalized, so we don't need to further process.
                 }
@@ -162,7 +163,7 @@ public static Plane<T> Normalize<T>(Plane<T> value)
         /// <returns>The transformed Plane.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Plane<T> Transform<T>(Plane<T> plane, Matrix4X4<T> matrix)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Matrix4X4.Invert(matrix, out Matrix4X4<T> m);
 
@@ -182,7 +183,7 @@ public static Plane<T> Transform<T>(Plane<T> plane, Matrix4X4<T> matrix)
         /// <returns>A new Plane that results from applying the rotation.</returns>
         [MethodImpl((MethodImplOptions) 768)]
         public static Plane<T> Transform<T>(Plane<T> plane, Legacy.Quaternion<T> rotation)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Plane.cs b/sources/Maths/Maths/Plane.cs
index 83b0fccaf1..f14e3f989f 100644
--- a/sources/Maths/Maths/Plane.cs
+++ b/sources/Maths/Maths/Plane.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Globalization;
+using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 
@@ -15,7 +16,8 @@ namespace Silk.NET.Maths
     [Serializable]
     [DataContract]
     public struct Plane<T>
-        : IEquatable<Plane<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        : IEquatable<Plane<T>>
+        where T : INumberBase<T>
     {
         /// <summary>The normal vector of the Plane.</summary>
         [DataMember]
@@ -173,7 +175,7 @@ public static explicit operator Plane<ushort>(Plane<T> from)
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="short"/> matrix</returns>
         public static explicit operator Plane<short>(Plane<T> from)
-            => new((Vector3D<short>) from.Normal, Scalar.As<T, short>(from.Distance));
+            => new(from.Normal.As<short>(), short.CreateSaturating(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
@@ -212,9 +214,9 @@ public static explicit operator Plane<long>(Plane<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted plane</returns>
-        public Plane<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Plane<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Normal.As<TOther>(), Scalar.As<T, TOther>(Distance));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Ray2D.cs b/sources/Maths/Maths/Ray2D.cs
index 91b181f2fd..9980748f31 100644
--- a/sources/Maths/Maths/Ray2D.cs
+++ b/sources/Maths/Maths/Ray2D.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.Serialization;
 
 namespace Silk.NET.Maths
@@ -14,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Ray2D<T>
         : IEquatable<Ray2D<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The origin of this Ray.
@@ -129,9 +130,10 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted ray</returns>
-        public Ray2D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Ray2D<TOther> As<TOther>()
+            where TOther : INumberBase<TOther>
         {
             return new(Origin.As<TOther>(), Direction.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Ray3D.cs b/sources/Maths/Maths/Ray3D.cs
index 14797d6756..b73feceb17 100644
--- a/sources/Maths/Maths/Ray3D.cs
+++ b/sources/Maths/Maths/Ray3D.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.Serialization;
 
 namespace Silk.NET.Maths
@@ -14,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Ray3D<T>
         : IEquatable<Ray3D<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The origin of this Ray.
@@ -133,9 +134,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted ray</returns>
-        public Ray3D<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Ray3D<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Origin.As<TOther>(), Direction.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Rectangle.Ops.cs b/sources/Maths/Maths/Rectangle.Ops.cs
index 4913e6523c..7dd2d6e9a0 100644
--- a/sources/Maths/Maths/Rectangle.Ops.cs
+++ b/sources/Maths/Maths/Rectangle.Ops.cs
@@ -1,7 +1,8 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 
 namespace Silk.NET.Maths
 {
@@ -20,7 +21,7 @@ public static class Rectangle
         /// <typeparam name="T">The type.</typeparam>
         /// <returns>The constructed rectangle.</returns>
         public static Rectangle<T> FromLTRB<T>(T left, T top, T right, T bottom)
-            where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+            where T : INumberBase<T>
         {
             Vector2D<T> o = new(left, top);
             return new Rectangle<T>(o, new Vector2D<T>(right, bottom) - o);
diff --git a/sources/Maths/Maths/Rectangle.cs b/sources/Maths/Maths/Rectangle.cs
index 344d8f02a9..c00d48993d 100644
--- a/sources/Maths/Maths/Rectangle.cs
+++ b/sources/Maths/Maths/Rectangle.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.Serialization;
 
 namespace Silk.NET.Maths
@@ -13,7 +14,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Rectangle<T>
         : IEquatable<Rectangle<T>>
-        where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        where T : INumberBase<T>
     {
         /// <summary>
         /// The origin.
@@ -161,7 +162,7 @@ public Rectangle<T> GetScaled(Vector2D<T> scale, Vector2D<T> anchor)
         /// <param name="anchor">The anchor.</param>
         /// <returns>The calculated rectangle.</returns>
         public Rectangle<T> GetScaled<TScale>(Vector2D<TScale> scale, Vector2D<T> anchor)
-            where TScale : unmanaged, IFormattable, IEquatable<TScale>, IComparable<TScale>
+            where TScale : INumberBase<TScale>
         {
             var convertedAnchor = anchor.As<TScale>();
             var min = (scale * (Origin.As<TScale>() - convertedAnchor)) + convertedAnchor;
@@ -227,9 +228,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted rectangle</returns>
-        public Rectangle<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Rectangle<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Origin.As<TOther>(), Size.As<TOther>());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/sources/Maths/Maths/Sphere.cs b/sources/Maths/Maths/Sphere.cs
index 5985308774..91bce6e0f2 100644
--- a/sources/Maths/Maths/Sphere.cs
+++ b/sources/Maths/Maths/Sphere.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Numerics;
 using System.Runtime.Serialization;
 
 namespace Silk.NET.Maths
@@ -12,7 +13,7 @@ namespace Silk.NET.Maths
     [Serializable]
     [DataContract]
     public struct Sphere<T>
-        : IEquatable<Sphere<T>> where T : unmanaged, IFormattable, IEquatable<T>, IComparable<T>
+        : IEquatable<Sphere<T>> where T : INumberBase<T>
     {
         /// <summary>
         /// The center.
@@ -168,9 +169,9 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted sphere</returns>
-        public Sphere<TOther> As<TOther>() where TOther : unmanaged, IFormattable, IEquatable<TOther>, IComparable<TOther>
+        public Sphere<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Center.As<TOther>(), Scalar.As<T, TOther>(Radius));
         }
     }
-}
\ No newline at end of file
+}

From ffb7f58d0a373b6780d83b045b07323a38257f65 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Mon, 30 Jun 2025 20:34:30 -0700
Subject: [PATCH 38/52] Fix errors.

---
 sources/Maths/Maths/Matrix2X4.cs     | 10 -------
 sources/Maths/Maths/Matrix3X2.cs     | 13 ----------
 sources/Maths/Maths/Matrix3X3.Ops.cs |  2 +-
 sources/Maths/Maths/Matrix4X2.cs     | 39 ----------------------------
 sources/Maths/Maths/Matrix4X4.Ops.cs |  2 +-
 sources/Maths/Maths/Vector2D.gen.cs  |  1 -
 sources/Maths/Maths/Vector3D.gen.cs  |  1 -
 sources/Maths/Maths/Vector4D.gen.cs  |  1 -
 8 files changed, 2 insertions(+), 67 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index 51d70e9c93..c991743a0d 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -81,16 +81,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X3<T> operator *(Matrix2X4<T> value1, Matrix4X3<T> value2)
-        {
-            return new(value1.M11 * value2.Row1 + value2.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value2.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4);
-        }
-
         /// <summary>Multiplies a matrix by a scalar value.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling factor.</param>
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index 7f3224660c..f1c69cd9a8 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -81,19 +81,6 @@ public Matrix3X2(Matrix4X2<T> value)
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X2<T> operator *(Matrix3X3<T> value1, Matrix3X2<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M33 * value2.Row3,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M23 * value2.Row3
-                );
-        }
-
         /// <summary>Scales all elements in a matrix by the given scalar factor.</summary>
         /// <param name="value1">The source matrix.</param>
         /// <param name="value2">The scaling value to use.</param>
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index 5a77409ea4..e955b5c9bb 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -15,6 +15,7 @@ public static partial class Matrix3X3
         private const float BillboardEpsilon = 1e-4f;
         private const float DecomposeEpsilon = 0.0001f;
 
+        /*
         private struct CanonicalBasis<T>
             where T : INumberBase<T>
         {
@@ -23,7 +24,6 @@ private struct CanonicalBasis<T>
             public Vector3D<T> Row2;
         };
 
-        /*
         private struct VectorBasis<T>
             where T : INumberBase<T>
         {
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index 45d2b8c231..3893815a5d 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -85,45 +85,6 @@ public readonly bool IsIdentity
                Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
                Scalar.Equal(M41, Scalar<T>.Zero) && Scalar.Equal(M42, Scalar<T>.Zero);
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix2X2<T> operator *(Matrix2X4<T> value1, Matrix4X2<T> value2)
-        {
-            return new(
-                    value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                    value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4
-                );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix3X2<T> operator *(Matrix3X4<T> value1, Matrix4X2<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4
-            );
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Matrix4X2<T> operator *(Matrix4X4<T> value1, Matrix4X2<T> value2)
-        {
-            return new(
-                value1.M11 * value2.Row1 + value1.M12 * value2.Row2 + value1.M13 * value2.Row3 + value1.M14 * value2.Row4,
-                value1.M21 * value2.Row1 + value1.M22 * value2.Row2 + value1.M23 * value2.Row3 + value1.M24 * value2.Row4,
-                value1.M31 * value2.Row1 + value1.M32 * value2.Row2 + value1.M33 * value2.Row3 + value1.M34 * value2.Row4,
-                value1.M41 * value2.Row1 + value1.M42 * value2.Row2 + value1.M43 * value2.Row3 + value1.M44 * value2.Row4
-            );
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index 5bc49c3d06..d44381a2c8 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -20,6 +20,7 @@ public static partial class Matrix4X4
 #endif
         private const float DecomposeEpsilon = 0.0001f;
 
+        /*
         private struct CanonicalBasis<T>
             where T : INumberBase<T>
         {
@@ -28,7 +29,6 @@ private struct CanonicalBasis<T>
             public Vector3D<T> Row2;
         };
 
-        /*
         private struct VectorBasis<T>
             where T : INumberBase<T>
         {
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 3c9845a843..d62934f8fb 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -356,7 +356,6 @@ public static implicit operator (T X, T Y)(Vector2D<T> v) =>
 
         public static Vector2D<T> operator /(Vector2D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar);
-
     }
 
     public static partial class Vector2D
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index e894afc9a1..f65b1522b7 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -395,7 +395,6 @@ public static implicit operator (T X, T Y, T Z)(Vector3D<T> v) =>
 
         public static Vector3D<T> operator /(Vector3D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
-
     }
 
     public static partial class Vector3D
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index 1cecb3c459..1055a4c936 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -434,7 +434,6 @@ public static implicit operator (T X, T Y, T Z, T W)(Vector4D<T> v) =>
 
         public static Vector4D<T> operator /(Vector4D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
-
     }
 
     public static partial class Vector4D

From d07c355799244a3c777a70aa5e17425e99ca124c Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 13:11:02 -0700
Subject: [PATCH 39/52] Code-gen more matrix implememtations.

---
 sources/Maths/Maths/Matrix2X2.cs     | 125 -------------
 sources/Maths/Maths/Matrix2X2.gen.cs | 131 +++++++++++++
 sources/Maths/Maths/Matrix2X3.cs     | 132 -------------
 sources/Maths/Maths/Matrix2X3.gen.cs | 131 +++++++++++++
 sources/Maths/Maths/Matrix2X4.cs     | 186 -------------------
 sources/Maths/Maths/Matrix2X4.gen.cs | 131 +++++++++++++
 sources/Maths/Maths/Matrix3X2.cs     | 163 ----------------
 sources/Maths/Maths/Matrix3X2.gen.cs | 146 +++++++++++++++
 sources/Maths/Maths/Matrix3X3.cs     | 149 ---------------
 sources/Maths/Maths/Matrix3X3.gen.cs | 146 +++++++++++++++
 sources/Maths/Maths/Matrix3X4.cs     | 211 ---------------------
 sources/Maths/Maths/Matrix3X4.gen.cs | 146 +++++++++++++++
 sources/Maths/Maths/Matrix4X2.cs     | 188 -------------------
 sources/Maths/Maths/Matrix4X2.gen.cs | 161 ++++++++++++++++
 sources/Maths/Maths/Matrix4X3.cs     | 236 -----------------------
 sources/Maths/Maths/Matrix4X3.gen.cs | 161 ++++++++++++++++
 sources/Maths/Maths/Matrix4X4.cs     | 241 ------------------------
 sources/Maths/Maths/Matrix4X4.gen.cs | 161 ++++++++++++++++
 sources/Maths/Maths/Matrix5X4.cs     | 267 ---------------------------
 sources/Maths/Maths/Matrix5X4.gen.cs | 176 ++++++++++++++++++
 20 files changed, 1490 insertions(+), 1898 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X2.cs b/sources/Maths/Maths/Matrix2X2.cs
index 50bde7046e..ada5e31b39 100644
--- a/sources/Maths/Maths/Matrix2X2.cs
+++ b/sources/Maths/Maths/Matrix2X2.cs
@@ -69,15 +69,6 @@ public readonly bool IsIdentity
             return value1 * value2.Row1 + value1 * value2.Row2;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix2X2<T> operator *(Matrix2X2<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2);
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -91,122 +82,6 @@ public readonly T GetDeterminant()
             return Scalar.Subtract(Scalar.Multiply(a, d), Scalar.Multiply(b, c));
         }
 
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} }}", M11, M12,
-                M21, M22);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from)
-            => new(Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12), Scalar.As<T, Half>(from.M21),
-                Scalar.As<T, Half>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix2X2<float>(Matrix2X2<T> from)
-            => new(Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix2X2<double>(Matrix2X2<T> from)
-            => new(Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from)
-            => new(Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from)
-            => new(Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from)
-            => new(Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12), Scalar.As<T, byte>(from.M21),
-                Scalar.As<T, byte>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from)
-            => new(Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix2X2<short>(Matrix2X2<T> from)
-            => new(Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from)
-            => new(Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12), Scalar.As<T, uint>(from.M21),
-                Scalar.As<T, uint>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix2X2<int>(Matrix2X2<T> from)
-            => new(Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12), Scalar.As<T, int>(from.M21),
-                Scalar.As<T, int>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix2X2<ulong>(Matrix2X2<T> from)
-            => new(Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix2X2<long>(Matrix2X2<T> from)
-            => new(Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12), Scalar.As<T, long>(from.M21),
-                Scalar.As<T, long>(from.M22));
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index d1bffe8d59..8d49a1fdba 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -96,6 +96,14 @@ public ref Vector2D<T> this[int row]
         [UnscopedRef]
         public ref T M22 => ref Row2.Y;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} }}",
+                Row1.X, Row1.Y,
+                Row2.X, Row2.Y);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X2<T> other && Equals(other);
@@ -148,6 +156,22 @@ public Matrix2X2<T> Transpose() =>
             new(-value.Row1,
                 -value.Row2);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X2<T> operator *(T left, Matrix2X2<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X2<T> operator *(Matrix2X2<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -155,6 +179,113 @@ public Matrix2X2<T> Transpose() =>
         public static Matrix2X2<T> operator *(Matrix2X2<T> left, Matrix2X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix2X2<float>(Matrix2X2<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix2X2<double>(Matrix2X2<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix2X2<short>(Matrix2X2<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix2X2<int>(Matrix2X2<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix2X2<long>(Matrix2X2<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix2X2<ulong>(Matrix2X2<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>());
     }
 
     public static partial class Matrix2X2
diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index 63e4bc944b..884d142dd2 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -80,138 +80,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix2X3<T> operator *(Matrix2X3<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2);
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} }} {{M21:{3} M22:{4} M23:{5} }} }}",
-                                 M11, M12, M13,
-                                 M21, M22, M23);
-        }
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from)
-            => new(Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12), Scalar.As<T, Half>(from.M13),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22), Scalar.As<T, Half>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix2X3<float>(Matrix2X3<T> from)
-            => new(Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix2X3<double>(Matrix2X3<T> from)
-            => new(Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M21),
-                Scalar.As<T, double>(from.M22), Scalar.As<T, double>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from)
-            => new(Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M21),
-                Scalar.As<T, decimal>(from.M22), Scalar.As<T, decimal>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from)
-            => new(Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from)
-            => new(Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12), Scalar.As<T, byte>(from.M13),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22), Scalar.As<T, byte>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from)
-            => new(Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M21),
-                Scalar.As<T, ushort>(from.M22), Scalar.As<T, ushort>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix2X3<short>(Matrix2X3<T> from)
-            => new(Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from)
-            => new(Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12), Scalar.As<T, uint>(from.M13),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22), Scalar.As<T, uint>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix2X3<int>(Matrix2X3<T> from)
-            => new(Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12), Scalar.As<T, int>(from.M13),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22), Scalar.As<T, int>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix2X3<ulong>(Matrix2X3<T> from)
-            => new(Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix2X3<long>(Matrix2X3<T> from)
-            => new(Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12), Scalar.As<T, long>(from.M13),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22), Scalar.As<T, long>(from.M23));
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index 7447bdd571..d8d87fd30b 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -105,6 +105,14 @@ public ref Vector3D<T> this[int row]
         [UnscopedRef]
         public ref T M23 => ref Row2.Z;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2}}} {{M21:{3} M22:{4} M23:{5}}} }}",
+                Row1.X, Row1.Y, Row1.Z,
+                Row2.X, Row2.Y, Row2.Z);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X3<T> other && Equals(other);
@@ -158,6 +166,22 @@ public Matrix3X2<T> Transpose() =>
             new(-value.Row1,
                 -value.Row2);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X3<T> operator *(T left, Matrix2X3<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X3<T> operator *(Matrix2X3<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -173,6 +197,113 @@ public Matrix3X2<T> Transpose() =>
         public static Matrix2X2<T> operator *(Matrix2X3<T> left, Matrix3X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix2X3<float>(Matrix2X3<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix2X3<double>(Matrix2X3<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix2X3<short>(Matrix2X3<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix2X3<int>(Matrix2X3<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix2X3<long>(Matrix2X3<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix2X3<ulong>(Matrix2X3<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>());
     }
 
     public static partial class Matrix2X3
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index c991743a0d..d6d530eb34 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -81,192 +81,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix2X4<T> operator *(Matrix2X4<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2);
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} }}",
-                                 M11, M12, M13, M14,
-                                 M21, M22, M23, M24);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M13), Scalar.As<T, Half>(from.M14),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M23), Scalar.As<T, Half>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix2X4<float>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M14),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23), Scalar.As<T, float>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix2X4<double>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M14),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M23), Scalar.As<T, double>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M14),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M23), Scalar.As<T, decimal>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M14),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23), Scalar.As<T, sbyte>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M13), Scalar.As<T, byte>(from.M14),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M23), Scalar.As<T, byte>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M14),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M23), Scalar.As<T, ushort>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix2X4<short>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M14),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23), Scalar.As<T, short>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M13), Scalar.As<T, uint>(from.M14),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M23), Scalar.As<T, uint>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix2X4<int>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M13), Scalar.As<T, int>(from.M14),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M23), Scalar.As<T, int>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix2X4<ulong>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M14),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23), Scalar.As<T, ulong>(from.M24)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix2X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix2X4<long>(Matrix2X4<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M13), Scalar.As<T, long>(from.M14),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M23), Scalar.As<T, long>(from.M24)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index 970be0f0f5..35573895a3 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -119,6 +119,14 @@ public ref Vector4D<T> this[int row]
         [UnscopedRef]
         public ref T M24 => ref Row2.W;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} }}",
+                Row1.X, Row1.Y, Row1.Z, Row1.W,
+                Row2.X, Row2.Y, Row2.Z, Row2.W);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X4<T> other && Equals(other);
@@ -173,6 +181,22 @@ public Matrix4X2<T> Transpose() =>
             new(-value.Row1,
                 -value.Row2);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X4<T> operator *(T left, Matrix2X4<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X4<T> operator *(Matrix2X4<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -197,6 +221,113 @@ public Matrix4X2<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix2X4<float>(Matrix2X4<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix2X4<double>(Matrix2X4<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix2X4<short>(Matrix2X4<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix2X4<int>(Matrix2X4<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix2X4<long>(Matrix2X4<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix2X4<ulong>(Matrix2X4<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>());
     }
 
     public static partial class Matrix2X4
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index f1c69cd9a8..2ec8ed1612 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -81,15 +81,6 @@ public Matrix3X2(Matrix4X2<T> value)
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Scales all elements in a matrix by the given scalar factor.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling value to use.</param>
-        /// <returns>The resulting matrix.</returns>
-        public static Matrix3X2<T> operator *(Matrix3X2<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
-        }
-
         /// <summary>Calculates the determinant for this matrix.
         /// The determinant is calculated by expanding the matrix with a third column whose values are (0,0,1).</summary>
         /// <returns>The determinant.</returns>
@@ -114,40 +105,6 @@ public readonly T GetDeterminant()
             return Scalar.Subtract(Scalar.Multiply(M11, M22), Scalar.Multiply(M21, M12));
         }
 
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} {{M31:{4} M32:{5}}} }}",
-                                 M11, M12,
-                                 M21, M22,
-                                 M31, M32);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix3X2<float>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32)
-            );
-
         /// <summary>
         /// Converts a <see cref="Matrix3X2{T}"/> into a <see cref="System.Numerics.Matrix3x2"/> one.
         /// </summary>
@@ -159,127 +116,7 @@ public static explicit operator System.Numerics.Matrix3x2(Matrix3X2<T> from)
                 Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
                 Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32)
             );
-        
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix3X2<double>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32)
-            );
 
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix3X2<short>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix3X2<int>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix3X2<ulong>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix3X2<long>(Matrix3X2<T> from)
-            => new(
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 1caf6ea066..2bb0ed9718 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -109,6 +109,15 @@ public ref Vector2D<T> this[int row]
         [UnscopedRef]
         public ref T M32 => ref Row3.Y;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} {{M31:{4} M32:{5}}} }}",
+                Row1.X, Row1.Y,
+                Row2.X, Row2.Y,
+                Row3.X, Row3.Y);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X2<T> other && Equals(other);
@@ -165,6 +174,24 @@ public Matrix2X3<T> Transpose() =>
                 -value.Row2,
                 -value.Row3);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X2<T> operator *(T left, Matrix3X2<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X2<T> operator *(Matrix3X2<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -182,6 +209,125 @@ public Matrix2X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix3X2<float>(Matrix3X2<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix3X2<double>(Matrix3X2<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix3X2<short>(Matrix3X2<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix3X2<int>(Matrix3X2<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix3X2<long>(Matrix3X2<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix3X2<ulong>(Matrix3X2<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>());
     }
 
     public static partial class Matrix3X2
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index b5161c146d..69e0db0bd1 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -95,15 +95,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix3X3<T> operator *(Matrix3X3<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -123,146 +114,6 @@ public readonly T GetDeterminant()
                 Scalar.Multiply(c, Scalar.Subtract(Scalar.Multiply(d, h), Scalar.Multiply(e, g))));
         }
 
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} }} {{M21:{3} M22:{4} M23:{5} }} {{M31:{6} M32:{7} M33:{8}}} }}",
-                                 M11, M12, M13,
-                                 M21, M22, M23,
-                                 M31, M32, M33);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from)
-            => new(Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12), Scalar.As<T, Half>(from.M13),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22), Scalar.As<T, Half>(from.M23),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32), Scalar.As<T, Half>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix3X3<float>(Matrix3X3<T> from)
-            => new(Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23), Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix3X3<double>(Matrix3X3<T> from)
-            => new(Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M21),
-                Scalar.As<T, double>(from.M22), Scalar.As<T, double>(from.M23),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from)
-            => new(Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M21),
-                Scalar.As<T, decimal>(from.M22), Scalar.As<T, decimal>(from.M23),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from)
-            => new(Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23), Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from)
-            => new(Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12), Scalar.As<T, byte>(from.M13),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22), Scalar.As<T, byte>(from.M23),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32), Scalar.As<T, byte>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from)
-            => new(Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M21),
-                Scalar.As<T, ushort>(from.M22), Scalar.As<T, ushort>(from.M23),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix3X3<short>(Matrix3X3<T> from)
-            => new(Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23), Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from)
-            => new(Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12), Scalar.As<T, uint>(from.M13),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22), Scalar.As<T, uint>(from.M23),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32), Scalar.As<T, uint>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix3X3<int>(Matrix3X3<T> from)
-            => new(Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12), Scalar.As<T, int>(from.M13),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22), Scalar.As<T, int>(from.M23),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32), Scalar.As<T, int>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix3X3<ulong>(Matrix3X3<T> from)
-            => new(Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23), Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M33));
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix3X3<long>(Matrix3X3<T> from)
-            => new(Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12), Scalar.As<T, long>(from.M13),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22), Scalar.As<T, long>(from.M23),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32), Scalar.As<T, long>(from.M33));
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index ad3c0b5b2a..0796c2baa5 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -134,6 +134,15 @@ public ref Vector3D<T> this[int row]
         [UnscopedRef]
         public ref T M33 => ref Row3.Z;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2}}} {{M21:{3} M22:{4} M23:{5}}} {{M31:{6} M32:{7} M33:{8}}} }}",
+                Row1.X, Row1.Y, Row1.Z,
+                Row2.X, Row2.Y, Row2.Z,
+                Row3.X, Row3.Y, Row3.Z);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X3<T> other && Equals(other);
@@ -191,6 +200,24 @@ public Matrix3X3<T> Transpose() =>
                 -value.Row2,
                 -value.Row3);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X3<T> operator *(T left, Matrix3X3<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X3<T> operator *(Matrix3X3<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -216,6 +243,125 @@ public Matrix3X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix3X3<float>(Matrix3X3<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix3X3<double>(Matrix3X3<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix3X3<short>(Matrix3X3<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix3X3<int>(Matrix3X3<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix3X3<long>(Matrix3X3<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix3X3<ulong>(Matrix3X3<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>());
     }
 
     public static partial class Matrix3X3
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index 966669f93b..b84ae7b298 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -98,217 +98,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix3X4<T> operator *(Matrix3X4<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2);
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} }}",
-                                 M11, M12, M13, M14,
-                                 M21, M22, M23, M24,
-                                 M31, M32, M33, M34);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M13), Scalar.As<T, Half>(from.M14),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M23), Scalar.As<T, Half>(from.M24),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32),
-                Scalar.As<T, Half>(from.M33), Scalar.As<T, Half>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix3X4<float>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M14),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23), Scalar.As<T, float>(from.M24),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M33), Scalar.As<T, float>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix3X4<double>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M14),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M23), Scalar.As<T, double>(from.M24),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M33), Scalar.As<T, double>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M14),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M23), Scalar.As<T, decimal>(from.M24),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M33), Scalar.As<T, decimal>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M14),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23), Scalar.As<T, sbyte>(from.M24),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M33), Scalar.As<T, sbyte>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M13), Scalar.As<T, byte>(from.M14),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M23), Scalar.As<T, byte>(from.M24),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32),
-                Scalar.As<T, byte>(from.M33), Scalar.As<T, byte>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M14),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M23), Scalar.As<T, ushort>(from.M24),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M33), Scalar.As<T, ushort>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix3X4<short>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M14),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23), Scalar.As<T, short>(from.M24),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M33), Scalar.As<T, short>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M13), Scalar.As<T, uint>(from.M14),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M23), Scalar.As<T, uint>(from.M24),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32),
-                Scalar.As<T, uint>(from.M33), Scalar.As<T, uint>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix3X4<int>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M13), Scalar.As<T, int>(from.M14),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M23), Scalar.As<T, int>(from.M24),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32),
-                Scalar.As<T, int>(from.M33), Scalar.As<T, int>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix3X4<ulong>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M14),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23), Scalar.As<T, ulong>(from.M24),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M33), Scalar.As<T, ulong>(from.M34)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix3X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix3X4<long>(Matrix3X4<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M13), Scalar.As<T, long>(from.M14),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M23), Scalar.As<T, long>(from.M24),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32),
-                Scalar.As<T, long>(from.M33), Scalar.As<T, long>(from.M34)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index fa2463be59..e662cce318 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -147,6 +147,15 @@ public ref Vector4D<T> this[int row]
         [UnscopedRef]
         public ref T M34 => ref Row3.W;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} }}",
+                Row1.X, Row1.Y, Row1.Z, Row1.W,
+                Row2.X, Row2.Y, Row2.Z, Row2.W,
+                Row3.X, Row3.Y, Row3.Z, Row3.W);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X4<T> other && Equals(other);
@@ -205,6 +214,24 @@ public Matrix4X3<T> Transpose() =>
                 -value.Row2,
                 -value.Row3);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X4<T> operator *(T left, Matrix3X4<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X4<T> operator *(Matrix3X4<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -239,6 +266,125 @@ public Matrix4X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix3X4<float>(Matrix3X4<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix3X4<double>(Matrix3X4<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix3X4<short>(Matrix3X4<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix3X4<int>(Matrix3X4<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix3X4<long>(Matrix3X4<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix3X4<ulong>(Matrix3X4<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>());
     }
 
     public static partial class Matrix3X4
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index 3893815a5d..606ca14133 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -94,194 +94,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix4X2<T> operator *(Matrix4X2<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2, value1.Row4 * value2);
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} {{M31:{4} M32:{5}}} {{M41:{6} M42:{7}}} }}",
-                                 M11, M12,
-                                 M21, M22,
-                                 M31, M32,
-                                 M41, M42);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32),
-                Scalar.As<T, Half>(from.M41), Scalar.As<T, Half>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix4X2<float>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M41), Scalar.As<T, float>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix4X2<double>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M41), Scalar.As<T, double>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M41), Scalar.As<T, decimal>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M41), Scalar.As<T, sbyte>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32),
-                Scalar.As<T, byte>(from.M41), Scalar.As<T, byte>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M41), Scalar.As<T, ushort>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix4X2<short>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M41), Scalar.As<T, short>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32),
-                Scalar.As<T, uint>(from.M41), Scalar.As<T, uint>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix4X2<int>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32),
-                Scalar.As<T, int>(from.M41), Scalar.As<T, int>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix4X2<ulong>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M41), Scalar.As<T, ulong>(from.M42)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X2{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix4X2<long>(Matrix4X2<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32),
-                Scalar.As<T, long>(from.M41), Scalar.As<T, long>(from.M42)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index 8bd1df9859..e5f3a6cff8 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -127,6 +127,16 @@ public ref Vector2D<T> this[int row]
         [UnscopedRef]
         public ref T M42 => ref Row4.Y;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1}}} {{M21:{2} M22:{3}}} {{M31:{4} M32:{5}}} {{M41:{6} M42:{7}}} }}",
+                Row1.X, Row1.Y,
+                Row2.X, Row2.Y,
+                Row3.X, Row3.Y,
+                Row4.X, Row4.Y);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X2<T> other && Equals(other);
@@ -187,6 +197,26 @@ public Matrix2X4<T> Transpose() =>
                 -value.Row3,
                 -value.Row4);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X2<T> operator *(T left, Matrix4X2<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3,
+                left * right.Row4);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X2<T> operator *(Matrix4X2<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right,
+                left.Row4 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -216,6 +246,137 @@ public Matrix2X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>(),
+                from.Row4.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix4X2<float>(Matrix4X2<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>(),
+                from.Row4.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix4X2<double>(Matrix4X2<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>(),
+                from.Row4.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>(),
+                from.Row4.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>(),
+                from.Row4.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix4X2<short>(Matrix4X2<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>(),
+                from.Row4.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix4X2<int>(Matrix4X2<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>(),
+                from.Row4.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix4X2<long>(Matrix4X2<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>(),
+                from.Row4.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>(),
+                from.Row4.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>(),
+                from.Row4.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>(),
+                from.Row4.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix4X2<ulong>(Matrix4X2<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>(),
+                from.Row4.As<ulong>());
     }
 
     public static partial class Matrix4X2
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index 3cfd7e313a..7e69e7d550 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -117,242 +117,6 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix4X3<T> operator *(Matrix4X3<T> value1, T value2)
-        {
-            return new(value1.Row1 * value2, value1.Row2 * value2, value1.Row3 * value2, value1.Row4 * value2);
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2}}} {{M21:{3} M22:{4} M23:{5}}} {{M31:{6} M32:{7} M33:{8}}} {{M41:{9} M42:{10} M43:{11}}} }}",
-                                 M11, M12, M13,
-                                 M21, M22, M23,
-                                 M31, M32, M33,
-                                 M41, M42, M43);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M13),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M23),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32),
-                Scalar.As<T, Half>(from.M33),
-                Scalar.As<T, Half>(from.M41), Scalar.As<T, Half>(from.M42),
-                Scalar.As<T, Half>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix4X3<float>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M33),
-                Scalar.As<T, float>(from.M41), Scalar.As<T, float>(from.M42),
-                Scalar.As<T, float>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix4X3<double>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M23),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M33),
-                Scalar.As<T, double>(from.M41), Scalar.As<T, double>(from.M42),
-                Scalar.As<T, double>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M23),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M33),
-                Scalar.As<T, decimal>(from.M41), Scalar.As<T, decimal>(from.M42),
-                Scalar.As<T, decimal>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M33),
-                Scalar.As<T, sbyte>(from.M41), Scalar.As<T, sbyte>(from.M42),
-                Scalar.As<T, sbyte>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M13),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M23),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32),
-                Scalar.As<T, byte>(from.M33),
-                Scalar.As<T, byte>(from.M41), Scalar.As<T, byte>(from.M42),
-                Scalar.As<T, byte>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M23),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M33),
-                Scalar.As<T, ushort>(from.M41), Scalar.As<T, ushort>(from.M42),
-                Scalar.As<T, ushort>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix4X3<short>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M33),
-                Scalar.As<T, short>(from.M41), Scalar.As<T, short>(from.M42),
-                Scalar.As<T, short>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M13),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M23),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32),
-                Scalar.As<T, uint>(from.M33),
-                Scalar.As<T, uint>(from.M41), Scalar.As<T, uint>(from.M42),
-                Scalar.As<T, uint>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix4X3<int>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M13),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M23),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32),
-                Scalar.As<T, int>(from.M33),
-                Scalar.As<T, int>(from.M41), Scalar.As<T, int>(from.M42),
-                Scalar.As<T, int>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix4X3<ulong>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M33),
-                Scalar.As<T, ulong>(from.M41), Scalar.As<T, ulong>(from.M42),
-                Scalar.As<T, ulong>(from.M43)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X3{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix4X3<long>(Matrix4X3<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M13),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M23),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32),
-                Scalar.As<T, long>(from.M33),
-                Scalar.As<T, long>(from.M41), Scalar.As<T, long>(from.M42),
-                Scalar.As<T, long>(from.M43)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index 7fcb883410..b21822d0f2 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -151,6 +151,16 @@ public ref Vector3D<T> this[int row]
         [UnscopedRef]
         public ref T M43 => ref Row4.Z;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2}}} {{M21:{3} M22:{4} M23:{5}}} {{M31:{6} M32:{7} M33:{8}}} {{M41:{9} M42:{10} M43:{11}}} }}",
+                Row1.X, Row1.Y, Row1.Z,
+                Row2.X, Row2.Y, Row2.Z,
+                Row3.X, Row3.Y, Row3.Z,
+                Row4.X, Row4.Y, Row4.Z);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X3<T> other && Equals(other);
@@ -212,6 +222,26 @@ public Matrix3X4<T> Transpose() =>
                 -value.Row3,
                 -value.Row4);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X3<T> operator *(T left, Matrix4X3<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3,
+                left * right.Row4);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X3<T> operator *(Matrix4X3<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right,
+                left.Row4 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -249,6 +279,137 @@ public Matrix3X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>(),
+                from.Row4.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix4X3<float>(Matrix4X3<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>(),
+                from.Row4.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix4X3<double>(Matrix4X3<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>(),
+                from.Row4.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>(),
+                from.Row4.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>(),
+                from.Row4.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix4X3<short>(Matrix4X3<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>(),
+                from.Row4.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix4X3<int>(Matrix4X3<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>(),
+                from.Row4.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix4X3<long>(Matrix4X3<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>(),
+                from.Row4.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>(),
+                from.Row4.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>(),
+                from.Row4.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>(),
+                from.Row4.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix4X3<ulong>(Matrix4X3<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>(),
+                from.Row4.As<ulong>());
     }
 
     public static partial class Matrix4X3
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index 700a86cdb5..2a5149bd5b 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -97,20 +97,6 @@ public readonly bool IsIdentity
                    value1.W * value2.Row4;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix4X4<T> operator *(Matrix4X4<T> value1, T value2)
-        {
-            return new(
-                value1.Row1 * value2,
-                value1.Row2 * value2,
-                value1.Row3 * value2,
-                value1.Row4 * value2
-                );
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
@@ -175,233 +161,6 @@ public readonly T GetDeterminant()
                             Scalar.Multiply(g, in_jm)))));
         }
 
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} {{M41:{12} M42:{13} M43:{14} M44:{15}}} }}",
-                                 M11, M12, M13, M14,
-                                 M21, M22, M23, M24,
-                                 M31, M32, M33, M34,
-                                 M41, M42, M43, M44);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M13), Scalar.As<T, Half>(from.M14),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M23), Scalar.As<T, Half>(from.M24),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32),
-                Scalar.As<T, Half>(from.M33), Scalar.As<T, Half>(from.M34),
-                Scalar.As<T, Half>(from.M41), Scalar.As<T, Half>(from.M42),
-                Scalar.As<T, Half>(from.M43), Scalar.As<T, Half>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix4X4<float>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M14),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23), Scalar.As<T, float>(from.M24),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M33), Scalar.As<T, float>(from.M34),
-                Scalar.As<T, float>(from.M41), Scalar.As<T, float>(from.M42),
-                Scalar.As<T, float>(from.M43), Scalar.As<T, float>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix4X4<double>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M14),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M23), Scalar.As<T, double>(from.M24),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M33), Scalar.As<T, double>(from.M34),
-                Scalar.As<T, double>(from.M41), Scalar.As<T, double>(from.M42),
-                Scalar.As<T, double>(from.M43), Scalar.As<T, double>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M14),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M23), Scalar.As<T, decimal>(from.M24),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M33), Scalar.As<T, decimal>(from.M34),
-                Scalar.As<T, decimal>(from.M41), Scalar.As<T, decimal>(from.M42),
-                Scalar.As<T, decimal>(from.M43), Scalar.As<T, decimal>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M14),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23), Scalar.As<T, sbyte>(from.M24),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M33), Scalar.As<T, sbyte>(from.M34),
-                Scalar.As<T, sbyte>(from.M41), Scalar.As<T, sbyte>(from.M42),
-                Scalar.As<T, sbyte>(from.M43), Scalar.As<T, sbyte>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M13), Scalar.As<T, byte>(from.M14),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M23), Scalar.As<T, byte>(from.M24),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32),
-                Scalar.As<T, byte>(from.M33), Scalar.As<T, byte>(from.M34),
-                Scalar.As<T, byte>(from.M41), Scalar.As<T, byte>(from.M42),
-                Scalar.As<T, byte>(from.M43), Scalar.As<T, byte>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M14),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M23), Scalar.As<T, ushort>(from.M24),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M33), Scalar.As<T, ushort>(from.M34),
-                Scalar.As<T, ushort>(from.M41), Scalar.As<T, ushort>(from.M42),
-                Scalar.As<T, ushort>(from.M43), Scalar.As<T, ushort>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix4X4<short>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M14),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23), Scalar.As<T, short>(from.M24),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M33), Scalar.As<T, short>(from.M34),
-                Scalar.As<T, short>(from.M41), Scalar.As<T, short>(from.M42),
-                Scalar.As<T, short>(from.M43), Scalar.As<T, short>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M13), Scalar.As<T, uint>(from.M14),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M23), Scalar.As<T, uint>(from.M24),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32),
-                Scalar.As<T, uint>(from.M33), Scalar.As<T, uint>(from.M34),
-                Scalar.As<T, uint>(from.M41), Scalar.As<T, uint>(from.M42),
-                Scalar.As<T, uint>(from.M43), Scalar.As<T, uint>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix4X4<int>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M13), Scalar.As<T, int>(from.M14),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M23), Scalar.As<T, int>(from.M24),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32),
-                Scalar.As<T, int>(from.M33), Scalar.As<T, int>(from.M34),
-                Scalar.As<T, int>(from.M41), Scalar.As<T, int>(from.M42),
-                Scalar.As<T, int>(from.M43), Scalar.As<T, int>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix4X4<ulong>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M14),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23), Scalar.As<T, ulong>(from.M24),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M33), Scalar.As<T, ulong>(from.M34),
-                Scalar.As<T, ulong>(from.M41), Scalar.As<T, ulong>(from.M42),
-                Scalar.As<T, ulong>(from.M43), Scalar.As<T, ulong>(from.M44)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix4X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix4X4<long>(Matrix4X4<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M13), Scalar.As<T, long>(from.M14),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M23), Scalar.As<T, long>(from.M24),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32),
-                Scalar.As<T, long>(from.M33), Scalar.As<T, long>(from.M34),
-                Scalar.As<T, long>(from.M41), Scalar.As<T, long>(from.M42),
-                Scalar.As<T, long>(from.M43), Scalar.As<T, long>(from.M44)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index 7fe91550bb..c93d2d3804 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -182,6 +182,16 @@ public ref Vector4D<T> this[int row]
         [UnscopedRef]
         public ref T M44 => ref Row4.W;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} {{M41:{12} M42:{13} M43:{14} M44:{15}}} }}",
+                Row1.X, Row1.Y, Row1.Z, Row1.W,
+                Row2.X, Row2.Y, Row2.Z, Row2.W,
+                Row3.X, Row3.Y, Row3.Z, Row3.W,
+                Row4.X, Row4.Y, Row4.Z, Row4.W);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X4<T> other && Equals(other);
@@ -244,6 +254,26 @@ public Matrix4X4<T> Transpose() =>
                 -value.Row3,
                 -value.Row4);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X4<T> operator *(T left, Matrix4X4<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3,
+                left * right.Row4);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X4<T> operator *(Matrix4X4<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right,
+                left.Row4 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -290,6 +320,137 @@ public Matrix4X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>(),
+                from.Row4.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix4X4<float>(Matrix4X4<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>(),
+                from.Row4.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix4X4<double>(Matrix4X4<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>(),
+                from.Row4.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>(),
+                from.Row4.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>(),
+                from.Row4.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix4X4<short>(Matrix4X4<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>(),
+                from.Row4.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix4X4<int>(Matrix4X4<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>(),
+                from.Row4.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix4X4<long>(Matrix4X4<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>(),
+                from.Row4.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>(),
+                from.Row4.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>(),
+                from.Row4.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>(),
+                from.Row4.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix4X4<ulong>(Matrix4X4<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>(),
+                from.Row4.As<ulong>());
     }
 
     public static partial class Matrix4X4
diff --git a/sources/Maths/Maths/Matrix5X4.cs b/sources/Maths/Maths/Matrix5X4.cs
index b9c85c3f89..8f624e5b99 100644
--- a/sources/Maths/Maths/Matrix5X4.cs
+++ b/sources/Maths/Maths/Matrix5X4.cs
@@ -128,273 +128,6 @@ public readonly bool IsIdentity
                    value1.W * value2.Row4 + value2.Row5;
         }
 
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        public static unsafe Matrix5X4<T> operator *(Matrix5X4<T> value1, T value2)
-        {
-            return new(
-                value1.Row1 * value2,
-                value1.Row2 * value2,
-                value1.Row3 * value2,
-                value1.Row4 * value2,
-                value1.Row5 * value2
-                );
-        }
-
-        /// <summary>Returns a String representing this matrix instance.</summary>
-        /// <returns>The string representation.</returns>
-        public override readonly string ToString()
-        {
-            return string.Format(CultureInfo.CurrentCulture, "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} {{M41:{12} M42:{13} M43:{14} M44:{15}}} {{M51:{16} M52:{17} M53:{18} M54:{19}}} }}",
-                                 M11, M12, M13, M14,
-                                 M21, M22, M23, M24,
-                                 M31, M32, M33, M34,
-                                 M41, M42, M43, M44,
-                                 M51, M52, M53, M54);
-        }
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="Half"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
-        public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, Half>(from.M11), Scalar.As<T, Half>(from.M12),
-                Scalar.As<T, Half>(from.M13), Scalar.As<T, Half>(from.M14),
-                Scalar.As<T, Half>(from.M21), Scalar.As<T, Half>(from.M22),
-                Scalar.As<T, Half>(from.M23), Scalar.As<T, Half>(from.M24),
-                Scalar.As<T, Half>(from.M31), Scalar.As<T, Half>(from.M32),
-                Scalar.As<T, Half>(from.M33), Scalar.As<T, Half>(from.M34),
-                Scalar.As<T, Half>(from.M41), Scalar.As<T, Half>(from.M42),
-                Scalar.As<T, Half>(from.M43), Scalar.As<T, Half>(from.M44),
-                Scalar.As<T, Half>(from.M51), Scalar.As<T, Half>(from.M52),
-                Scalar.As<T, Half>(from.M53), Scalar.As<T, Half>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="float"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
-        public static explicit operator Matrix5X4<float>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, float>(from.M11), Scalar.As<T, float>(from.M12),
-                Scalar.As<T, float>(from.M13), Scalar.As<T, float>(from.M14),
-                Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
-                Scalar.As<T, float>(from.M23), Scalar.As<T, float>(from.M24),
-                Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32),
-                Scalar.As<T, float>(from.M33), Scalar.As<T, float>(from.M34),
-                Scalar.As<T, float>(from.M41), Scalar.As<T, float>(from.M42),
-                Scalar.As<T, float>(from.M43), Scalar.As<T, float>(from.M44),
-                Scalar.As<T, float>(from.M51), Scalar.As<T, float>(from.M52),
-                Scalar.As<T, float>(from.M53), Scalar.As<T, float>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
-        public static explicit operator Matrix5X4<double>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, double>(from.M11), Scalar.As<T, double>(from.M12),
-                Scalar.As<T, double>(from.M13), Scalar.As<T, double>(from.M14),
-                Scalar.As<T, double>(from.M21), Scalar.As<T, double>(from.M22),
-                Scalar.As<T, double>(from.M23), Scalar.As<T, double>(from.M24),
-                Scalar.As<T, double>(from.M31), Scalar.As<T, double>(from.M32),
-                Scalar.As<T, double>(from.M33), Scalar.As<T, double>(from.M34),
-                Scalar.As<T, double>(from.M41), Scalar.As<T, double>(from.M42),
-                Scalar.As<T, double>(from.M43), Scalar.As<T, double>(from.M44),
-                Scalar.As<T, double>(from.M51), Scalar.As<T, double>(from.M52),
-                Scalar.As<T, double>(from.M53), Scalar.As<T, double>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, decimal>(from.M11), Scalar.As<T, decimal>(from.M12),
-                Scalar.As<T, decimal>(from.M13), Scalar.As<T, decimal>(from.M14),
-                Scalar.As<T, decimal>(from.M21), Scalar.As<T, decimal>(from.M22),
-                Scalar.As<T, decimal>(from.M23), Scalar.As<T, decimal>(from.M24),
-                Scalar.As<T, decimal>(from.M31), Scalar.As<T, decimal>(from.M32),
-                Scalar.As<T, decimal>(from.M33), Scalar.As<T, decimal>(from.M34),
-                Scalar.As<T, decimal>(from.M41), Scalar.As<T, decimal>(from.M42),
-                Scalar.As<T, decimal>(from.M43), Scalar.As<T, decimal>(from.M44),
-                Scalar.As<T, decimal>(from.M51), Scalar.As<T, decimal>(from.M52),
-                Scalar.As<T, decimal>(from.M53), Scalar.As<T, decimal>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, sbyte>(from.M11), Scalar.As<T, sbyte>(from.M12),
-                Scalar.As<T, sbyte>(from.M13), Scalar.As<T, sbyte>(from.M14),
-                Scalar.As<T, sbyte>(from.M21), Scalar.As<T, sbyte>(from.M22),
-                Scalar.As<T, sbyte>(from.M23), Scalar.As<T, sbyte>(from.M24),
-                Scalar.As<T, sbyte>(from.M31), Scalar.As<T, sbyte>(from.M32),
-                Scalar.As<T, sbyte>(from.M33), Scalar.As<T, sbyte>(from.M34),
-                Scalar.As<T, sbyte>(from.M41), Scalar.As<T, sbyte>(from.M42),
-                Scalar.As<T, sbyte>(from.M43), Scalar.As<T, sbyte>(from.M44),
-                Scalar.As<T, sbyte>(from.M51), Scalar.As<T, sbyte>(from.M52),
-                Scalar.As<T, sbyte>(from.M53), Scalar.As<T, sbyte>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, byte>(from.M11), Scalar.As<T, byte>(from.M12),
-                Scalar.As<T, byte>(from.M13), Scalar.As<T, byte>(from.M14),
-                Scalar.As<T, byte>(from.M21), Scalar.As<T, byte>(from.M22),
-                Scalar.As<T, byte>(from.M23), Scalar.As<T, byte>(from.M24),
-                Scalar.As<T, byte>(from.M31), Scalar.As<T, byte>(from.M32),
-                Scalar.As<T, byte>(from.M33), Scalar.As<T, byte>(from.M34),
-                Scalar.As<T, byte>(from.M41), Scalar.As<T, byte>(from.M42),
-                Scalar.As<T, byte>(from.M43), Scalar.As<T, byte>(from.M44),
-                Scalar.As<T, byte>(from.M51), Scalar.As<T, byte>(from.M52),
-                Scalar.As<T, byte>(from.M53), Scalar.As<T, byte>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, ushort>(from.M11), Scalar.As<T, ushort>(from.M12),
-                Scalar.As<T, ushort>(from.M13), Scalar.As<T, ushort>(from.M14),
-                Scalar.As<T, ushort>(from.M21), Scalar.As<T, ushort>(from.M22),
-                Scalar.As<T, ushort>(from.M23), Scalar.As<T, ushort>(from.M24),
-                Scalar.As<T, ushort>(from.M31), Scalar.As<T, ushort>(from.M32),
-                Scalar.As<T, ushort>(from.M33), Scalar.As<T, ushort>(from.M34),
-                Scalar.As<T, ushort>(from.M41), Scalar.As<T, ushort>(from.M42),
-                Scalar.As<T, ushort>(from.M43), Scalar.As<T, ushort>(from.M44),
-                Scalar.As<T, ushort>(from.M51), Scalar.As<T, ushort>(from.M52),
-                Scalar.As<T, ushort>(from.M53), Scalar.As<T, ushort>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Matrix5X4<short>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, short>(from.M11), Scalar.As<T, short>(from.M12),
-                Scalar.As<T, short>(from.M13), Scalar.As<T, short>(from.M14),
-                Scalar.As<T, short>(from.M21), Scalar.As<T, short>(from.M22),
-                Scalar.As<T, short>(from.M23), Scalar.As<T, short>(from.M24),
-                Scalar.As<T, short>(from.M31), Scalar.As<T, short>(from.M32),
-                Scalar.As<T, short>(from.M33), Scalar.As<T, short>(from.M34),
-                Scalar.As<T, short>(from.M41), Scalar.As<T, short>(from.M42),
-                Scalar.As<T, short>(from.M43), Scalar.As<T, short>(from.M44),
-                Scalar.As<T, short>(from.M51), Scalar.As<T, short>(from.M52),
-                Scalar.As<T, short>(from.M53), Scalar.As<T, short>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, uint>(from.M11), Scalar.As<T, uint>(from.M12),
-                Scalar.As<T, uint>(from.M13), Scalar.As<T, uint>(from.M14),
-                Scalar.As<T, uint>(from.M21), Scalar.As<T, uint>(from.M22),
-                Scalar.As<T, uint>(from.M23), Scalar.As<T, uint>(from.M24),
-                Scalar.As<T, uint>(from.M31), Scalar.As<T, uint>(from.M32),
-                Scalar.As<T, uint>(from.M33), Scalar.As<T, uint>(from.M34),
-                Scalar.As<T, uint>(from.M41), Scalar.As<T, uint>(from.M42),
-                Scalar.As<T, uint>(from.M43), Scalar.As<T, uint>(from.M44),
-                Scalar.As<T, uint>(from.M51), Scalar.As<T, uint>(from.M52),
-                Scalar.As<T, uint>(from.M53), Scalar.As<T, uint>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Matrix5X4<int>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, int>(from.M11), Scalar.As<T, int>(from.M12),
-                Scalar.As<T, int>(from.M13), Scalar.As<T, int>(from.M14),
-                Scalar.As<T, int>(from.M21), Scalar.As<T, int>(from.M22),
-                Scalar.As<T, int>(from.M23), Scalar.As<T, int>(from.M24),
-                Scalar.As<T, int>(from.M31), Scalar.As<T, int>(from.M32),
-                Scalar.As<T, int>(from.M33), Scalar.As<T, int>(from.M34),
-                Scalar.As<T, int>(from.M41), Scalar.As<T, int>(from.M42),
-                Scalar.As<T, int>(from.M43), Scalar.As<T, int>(from.M44),
-                Scalar.As<T, int>(from.M51), Scalar.As<T, int>(from.M52),
-                Scalar.As<T, int>(from.M53), Scalar.As<T, int>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Matrix5X4<ulong>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, ulong>(from.M11), Scalar.As<T, ulong>(from.M12),
-                Scalar.As<T, ulong>(from.M13), Scalar.As<T, ulong>(from.M14),
-                Scalar.As<T, ulong>(from.M21), Scalar.As<T, ulong>(from.M22),
-                Scalar.As<T, ulong>(from.M23), Scalar.As<T, ulong>(from.M24),
-                Scalar.As<T, ulong>(from.M31), Scalar.As<T, ulong>(from.M32),
-                Scalar.As<T, ulong>(from.M33), Scalar.As<T, ulong>(from.M34),
-                Scalar.As<T, ulong>(from.M41), Scalar.As<T, ulong>(from.M42),
-                Scalar.As<T, ulong>(from.M43), Scalar.As<T, ulong>(from.M44),
-                Scalar.As<T, ulong>(from.M51), Scalar.As<T, ulong>(from.M52),
-                Scalar.As<T, ulong>(from.M53), Scalar.As<T, ulong>(from.M54)
-            );
-
-        /// <summary>
-        /// Converts a <see cref="Matrix5X4{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Matrix5X4<long>(Matrix5X4<T> from)
-            => new
-            (
-                Scalar.As<T, long>(from.M11), Scalar.As<T, long>(from.M12),
-                Scalar.As<T, long>(from.M13), Scalar.As<T, long>(from.M14),
-                Scalar.As<T, long>(from.M21), Scalar.As<T, long>(from.M22),
-                Scalar.As<T, long>(from.M23), Scalar.As<T, long>(from.M24),
-                Scalar.As<T, long>(from.M31), Scalar.As<T, long>(from.M32),
-                Scalar.As<T, long>(from.M33), Scalar.As<T, long>(from.M34),
-                Scalar.As<T, long>(from.M41), Scalar.As<T, long>(from.M42),
-                Scalar.As<T, long>(from.M43), Scalar.As<T, long>(from.M44),
-                Scalar.As<T, long>(from.M51), Scalar.As<T, long>(from.M52),
-                Scalar.As<T, long>(from.M53), Scalar.As<T, long>(from.M54)
-            );
-        
         /// <summary>
         /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index c4da23f556..def96a81ab 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -187,6 +187,17 @@ public ref Vector4D<T> this[int row]
         [UnscopedRef]
         public ref T M54 => ref Row5.W;
 
+
+        /// <inheritdoc/>
+        public override string ToString() =>
+            string.Format(
+                "{{ {{M11:{0} M12:{1} M13:{2} M14:{3}}} {{M21:{4} M22:{5} M23:{6} M24:{7}}} {{M31:{8} M32:{9} M33:{10} M34:{11}}} {{M41:{12} M42:{13} M43:{14} M44:{15}}} {{M51:{16} M52:{17} M53:{18} M54:{19}}} }}",
+                Row1.X, Row1.Y, Row1.Z, Row1.W,
+                Row2.X, Row2.Y, Row2.Z, Row2.W,
+                Row3.X, Row3.Y, Row3.Z, Row3.W,
+                Row4.X, Row4.Y, Row4.Z, Row4.W,
+                Row5.X, Row5.Y, Row5.Z, Row5.W);
+
         /// <inheridoc/>
         [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix5X4<T> other && Equals(other);
@@ -246,6 +257,28 @@ public ref Vector4D<T> this[int row]
                 -value.Row4,
                 -value.Row5);
 
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix5X4<T> operator *(T left, Matrix5X4<T> right) =>
+            new(left * right.Row1,
+                left * right.Row2,
+                left * right.Row3,
+                left * right.Row4,
+                left * right.Row5);
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix5X4<T> operator *(Matrix5X4<T> left, T right) =>
+            new(left.Row1 * right,
+                left.Row2 * right,
+                left.Row3 * right,
+                left.Row4 * right,
+                left.Row5 * right);
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -256,6 +289,149 @@ public ref Vector4D<T> this[int row]
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="Half"/> matrix</returns>
+        public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from) =>
+            new(from.Row1.As<Half>(),
+                from.Row2.As<Half>(),
+                from.Row3.As<Half>(),
+                from.Row4.As<Half>(),
+                from.Row5.As<Half>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="float"/> matrix</returns>
+        public static explicit operator Matrix5X4<float>(Matrix5X4<T> from) =>
+            new(from.Row1.As<float>(),
+                from.Row2.As<float>(),
+                from.Row3.As<float>(),
+                from.Row4.As<float>(),
+                from.Row5.As<float>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="double"/> matrix</returns>
+        public static explicit operator Matrix5X4<double>(Matrix5X4<T> from) =>
+            new(from.Row1.As<double>(),
+                from.Row2.As<double>(),
+                from.Row3.As<double>(),
+                from.Row4.As<double>(),
+                from.Row5.As<double>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="decimal"/> matrix</returns>
+        public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from) =>
+            new(from.Row1.As<decimal>(),
+                from.Row2.As<decimal>(),
+                from.Row3.As<decimal>(),
+                from.Row4.As<decimal>(),
+                from.Row5.As<decimal>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="byte"/> matrix</returns>
+        public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from) =>
+            new(from.Row1.As<byte>(),
+                from.Row2.As<byte>(),
+                from.Row3.As<byte>(),
+                from.Row4.As<byte>(),
+                from.Row5.As<byte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="short"/> matrix</returns>
+        public static explicit operator Matrix5X4<short>(Matrix5X4<T> from) =>
+            new(from.Row1.As<short>(),
+                from.Row2.As<short>(),
+                from.Row3.As<short>(),
+                from.Row4.As<short>(),
+                from.Row5.As<short>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="int"/> matrix</returns>
+        public static explicit operator Matrix5X4<int>(Matrix5X4<T> from) =>
+            new(from.Row1.As<int>(),
+                from.Row2.As<int>(),
+                from.Row3.As<int>(),
+                from.Row4.As<int>(),
+                from.Row5.As<int>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="long"/> matrix</returns>
+        public static explicit operator Matrix5X4<long>(Matrix5X4<T> from) =>
+            new(from.Row1.As<long>(),
+                from.Row2.As<long>(),
+                from.Row3.As<long>(),
+                from.Row4.As<long>(),
+                from.Row5.As<long>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from) =>
+            new(from.Row1.As<sbyte>(),
+                from.Row2.As<sbyte>(),
+                from.Row3.As<sbyte>(),
+                from.Row4.As<sbyte>(),
+                from.Row5.As<sbyte>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ushort"/> matrix</returns>
+        public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from) =>
+            new(from.Row1.As<ushort>(),
+                from.Row2.As<ushort>(),
+                from.Row3.As<ushort>(),
+                from.Row4.As<ushort>(),
+                from.Row5.As<ushort>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="uint"/> matrix</returns>
+        public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from) =>
+            new(from.Row1.As<uint>(),
+                from.Row2.As<uint>(),
+                from.Row3.As<uint>(),
+                from.Row4.As<uint>(),
+                from.Row5.As<uint>());
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix</param>
+        /// <returns>The <see cref="ulong"/> matrix</returns>
+        public static explicit operator Matrix5X4<ulong>(Matrix5X4<T> from) =>
+            new(from.Row1.As<ulong>(),
+                from.Row2.As<ulong>(),
+                from.Row3.As<ulong>(),
+                from.Row4.As<ulong>(),
+                from.Row5.As<ulong>());
     }
 
     public static partial class Matrix5X4

From 80fbbfc378d539179bf19605cadff43ff08571b2 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 13:24:42 -0700
Subject: [PATCH 40/52] Types that need Min/Max (e.g. Box) use INumber instead
 of INumberBase. INumber implies a total order opposed to INumberBase which
 supports e.g. Complex numbers.

---
 sources/Maths/Maths/Box2D.cs         | 7 ++++---
 sources/Maths/Maths/Box3D.cs         | 5 +++--
 sources/Maths/Maths/Cube.cs          | 5 +++--
 sources/Maths/Maths/Rectangle.Ops.cs | 2 +-
 sources/Maths/Maths/Rectangle.cs     | 5 +++--
 5 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/sources/Maths/Maths/Box2D.cs b/sources/Maths/Maths/Box2D.cs
index a5536faf6e..f038fd5fd5 100644
--- a/sources/Maths/Maths/Box2D.cs
+++ b/sources/Maths/Maths/Box2D.cs
@@ -15,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Box2D<T>
         : IEquatable<Box2D<T>>
-        where T : INumberBase<T>
+        where T : INumber<T>
     {
         /// <summary>
         /// The min.
@@ -149,7 +149,7 @@ public Box2D<T> GetScaled(Vector2D<T> scale, Vector2D<T> anchor)
         /// <typeparam name="TScale">The type of the scale.</typeparam>
         /// <returns>The calculated box.</returns>
         public Box2D<T> GetScaled<TScale>(Vector2D<TScale> scale, Vector2D<T> anchor)
-            where TScale : INumberBase<TScale>
+            where TScale : INumber<TScale>
         {
             return this.As<TScale>().GetScaled(scale, anchor.As<TScale>()).As<T>();
         }
@@ -210,7 +210,8 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
-        public Box2D<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Box2D<TOther> As<TOther>()
+            where TOther : INumber<TOther>
         {
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Box3D.cs b/sources/Maths/Maths/Box3D.cs
index f32a0afd1f..040c2b0256 100644
--- a/sources/Maths/Maths/Box3D.cs
+++ b/sources/Maths/Maths/Box3D.cs
@@ -15,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Box3D<T>
         : IEquatable<Box3D<T>>
-        where T : INumberBase<T>
+        where T : INumber<T>
     {
         /// <summary>
         /// The min.
@@ -222,7 +222,8 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
-        public Box3D<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Box3D<TOther> As<TOther>()
+            where TOther : INumber<TOther>
         {
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Cube.cs b/sources/Maths/Maths/Cube.cs
index b0a2e2a3c2..90bc620d49 100644
--- a/sources/Maths/Maths/Cube.cs
+++ b/sources/Maths/Maths/Cube.cs
@@ -15,7 +15,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Cube<T>
         : IEquatable<Cube<T>>
-        where T : INumberBase<T>
+        where T : INumber<T>
     {
         /// <summary>
         /// The origin.
@@ -236,7 +236,8 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted cube</returns>
-        public Cube<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Cube<TOther> As<TOther>()
+            where TOther : INumber<TOther>
         {
             return new(Origin.As<TOther>(), Max.As<TOther>());
         }
diff --git a/sources/Maths/Maths/Rectangle.Ops.cs b/sources/Maths/Maths/Rectangle.Ops.cs
index 7dd2d6e9a0..cb1175a1a8 100644
--- a/sources/Maths/Maths/Rectangle.Ops.cs
+++ b/sources/Maths/Maths/Rectangle.Ops.cs
@@ -21,7 +21,7 @@ public static class Rectangle
         /// <typeparam name="T">The type.</typeparam>
         /// <returns>The constructed rectangle.</returns>
         public static Rectangle<T> FromLTRB<T>(T left, T top, T right, T bottom)
-            where T : INumberBase<T>
+            where T : INumber<T>
         {
             Vector2D<T> o = new(left, top);
             return new Rectangle<T>(o, new Vector2D<T>(right, bottom) - o);
diff --git a/sources/Maths/Maths/Rectangle.cs b/sources/Maths/Maths/Rectangle.cs
index c00d48993d..db90d7032b 100644
--- a/sources/Maths/Maths/Rectangle.cs
+++ b/sources/Maths/Maths/Rectangle.cs
@@ -14,7 +14,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Rectangle<T>
         : IEquatable<Rectangle<T>>
-        where T : INumberBase<T>
+        where T : INumber<T>
     {
         /// <summary>
         /// The origin.
@@ -228,7 +228,8 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted rectangle</returns>
-        public Rectangle<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Rectangle<TOther> As<TOther>()
+            where TOther : INumber<TOther>
         {
             return new(Origin.As<TOther>(), Size.As<TOther>());
         }

From 2a79fd860ebba7e5c8bf5db55e11360c899d9e43 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 13:25:13 -0700
Subject: [PATCH 41/52] Added explicit casts for vectors.

---
 sources/Maths/Maths/Matrix2X2.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix2X3.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix2X4.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix3X2.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix3X3.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix3X4.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix4X2.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix4X3.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix4X4.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Matrix5X4.gen.cs | 48 +++++++-------
 sources/Maths/Maths/Vector2D.gen.cs  | 96 ++++++++++++++++++++++++++++
 sources/Maths/Maths/Vector3D.gen.cs  | 96 ++++++++++++++++++++++++++++
 sources/Maths/Maths/Vector4D.gen.cs  | 96 ++++++++++++++++++++++++++++
 13 files changed, 528 insertions(+), 240 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index 8d49a1fdba..d1490acf18 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -182,8 +182,8 @@ public Matrix2X2<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>());
@@ -191,8 +191,8 @@ public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X2<float>(Matrix2X2<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>());
@@ -200,8 +200,8 @@ public static explicit operator Matrix2X2<float>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X2<double>(Matrix2X2<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>());
@@ -209,8 +209,8 @@ public static explicit operator Matrix2X2<double>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>());
@@ -218,8 +218,8 @@ public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>());
@@ -227,8 +227,8 @@ public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X2<short>(Matrix2X2<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>());
@@ -236,8 +236,8 @@ public static explicit operator Matrix2X2<short>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X2<int>(Matrix2X2<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>());
@@ -245,8 +245,8 @@ public static explicit operator Matrix2X2<int>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X2<long>(Matrix2X2<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>());
@@ -254,8 +254,8 @@ public static explicit operator Matrix2X2<long>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>());
@@ -263,8 +263,8 @@ public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>());
@@ -272,8 +272,8 @@ public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>());
@@ -281,8 +281,8 @@ public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X2<ulong>(Matrix2X2<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>());
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index d8d87fd30b..07f9ec51b9 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -200,8 +200,8 @@ public Matrix3X2<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>());
@@ -209,8 +209,8 @@ public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X3<float>(Matrix2X3<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>());
@@ -218,8 +218,8 @@ public static explicit operator Matrix2X3<float>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X3<double>(Matrix2X3<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>());
@@ -227,8 +227,8 @@ public static explicit operator Matrix2X3<double>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>());
@@ -236,8 +236,8 @@ public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>());
@@ -245,8 +245,8 @@ public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X3<short>(Matrix2X3<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>());
@@ -254,8 +254,8 @@ public static explicit operator Matrix2X3<short>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X3<int>(Matrix2X3<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>());
@@ -263,8 +263,8 @@ public static explicit operator Matrix2X3<int>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X3<long>(Matrix2X3<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>());
@@ -272,8 +272,8 @@ public static explicit operator Matrix2X3<long>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>());
@@ -281,8 +281,8 @@ public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>());
@@ -290,8 +290,8 @@ public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>());
@@ -299,8 +299,8 @@ public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X3<ulong>(Matrix2X3<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>());
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index 35573895a3..ee07f8dfee 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -224,8 +224,8 @@ public Matrix4X2<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>());
@@ -233,8 +233,8 @@ public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X4<float>(Matrix2X4<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>());
@@ -242,8 +242,8 @@ public static explicit operator Matrix2X4<float>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X4<double>(Matrix2X4<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>());
@@ -251,8 +251,8 @@ public static explicit operator Matrix2X4<double>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>());
@@ -260,8 +260,8 @@ public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>());
@@ -269,8 +269,8 @@ public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X4<short>(Matrix2X4<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>());
@@ -278,8 +278,8 @@ public static explicit operator Matrix2X4<short>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X4<int>(Matrix2X4<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>());
@@ -287,8 +287,8 @@ public static explicit operator Matrix2X4<int>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X4<long>(Matrix2X4<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>());
@@ -296,8 +296,8 @@ public static explicit operator Matrix2X4<long>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>());
@@ -305,8 +305,8 @@ public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>());
@@ -314,8 +314,8 @@ public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>());
@@ -323,8 +323,8 @@ public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X4<ulong>(Matrix2X4<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>());
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 2bb0ed9718..3c03e4b538 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -212,8 +212,8 @@ public Matrix2X3<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -222,8 +222,8 @@ public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X2<float>(Matrix3X2<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -232,8 +232,8 @@ public static explicit operator Matrix3X2<float>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X2<double>(Matrix3X2<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -242,8 +242,8 @@ public static explicit operator Matrix3X2<double>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -252,8 +252,8 @@ public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -262,8 +262,8 @@ public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X2<short>(Matrix3X2<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -272,8 +272,8 @@ public static explicit operator Matrix3X2<short>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X2<int>(Matrix3X2<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -282,8 +282,8 @@ public static explicit operator Matrix3X2<int>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X2<long>(Matrix3X2<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -292,8 +292,8 @@ public static explicit operator Matrix3X2<long>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -302,8 +302,8 @@ public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -312,8 +312,8 @@ public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -322,8 +322,8 @@ public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X2<ulong>(Matrix3X2<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index 0796c2baa5..6466c089d6 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -246,8 +246,8 @@ public Matrix3X3<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -256,8 +256,8 @@ public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X3<float>(Matrix3X3<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -266,8 +266,8 @@ public static explicit operator Matrix3X3<float>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X3<double>(Matrix3X3<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -276,8 +276,8 @@ public static explicit operator Matrix3X3<double>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -286,8 +286,8 @@ public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -296,8 +296,8 @@ public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X3<short>(Matrix3X3<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -306,8 +306,8 @@ public static explicit operator Matrix3X3<short>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X3<int>(Matrix3X3<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -316,8 +316,8 @@ public static explicit operator Matrix3X3<int>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X3<long>(Matrix3X3<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -326,8 +326,8 @@ public static explicit operator Matrix3X3<long>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -336,8 +336,8 @@ public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -346,8 +346,8 @@ public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -356,8 +356,8 @@ public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X3<ulong>(Matrix3X3<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index e662cce318..ce53d29ad9 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -269,8 +269,8 @@ public Matrix4X3<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -279,8 +279,8 @@ public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X4<float>(Matrix3X4<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -289,8 +289,8 @@ public static explicit operator Matrix3X4<float>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X4<double>(Matrix3X4<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -299,8 +299,8 @@ public static explicit operator Matrix3X4<double>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -309,8 +309,8 @@ public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -319,8 +319,8 @@ public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X4<short>(Matrix3X4<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -329,8 +329,8 @@ public static explicit operator Matrix3X4<short>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X4<int>(Matrix3X4<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -339,8 +339,8 @@ public static explicit operator Matrix3X4<int>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X4<long>(Matrix3X4<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -349,8 +349,8 @@ public static explicit operator Matrix3X4<long>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -359,8 +359,8 @@ public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -369,8 +369,8 @@ public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -379,8 +379,8 @@ public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X4<ulong>(Matrix3X4<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index e5f3a6cff8..0cda66d434 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -249,8 +249,8 @@ public Matrix2X4<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -260,8 +260,8 @@ public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X2<float>(Matrix4X2<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -271,8 +271,8 @@ public static explicit operator Matrix4X2<float>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X2<double>(Matrix4X2<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -282,8 +282,8 @@ public static explicit operator Matrix4X2<double>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -293,8 +293,8 @@ public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -304,8 +304,8 @@ public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X2<short>(Matrix4X2<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -315,8 +315,8 @@ public static explicit operator Matrix4X2<short>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X2<int>(Matrix4X2<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -326,8 +326,8 @@ public static explicit operator Matrix4X2<int>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X2<long>(Matrix4X2<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -337,8 +337,8 @@ public static explicit operator Matrix4X2<long>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -348,8 +348,8 @@ public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -359,8 +359,8 @@ public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -370,8 +370,8 @@ public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X2<ulong>(Matrix4X2<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index b21822d0f2..f5d3add102 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -282,8 +282,8 @@ public Matrix3X4<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -293,8 +293,8 @@ public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X3<float>(Matrix4X3<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -304,8 +304,8 @@ public static explicit operator Matrix4X3<float>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X3<double>(Matrix4X3<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -315,8 +315,8 @@ public static explicit operator Matrix4X3<double>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -326,8 +326,8 @@ public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -337,8 +337,8 @@ public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X3<short>(Matrix4X3<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -348,8 +348,8 @@ public static explicit operator Matrix4X3<short>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X3<int>(Matrix4X3<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -359,8 +359,8 @@ public static explicit operator Matrix4X3<int>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X3<long>(Matrix4X3<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -370,8 +370,8 @@ public static explicit operator Matrix4X3<long>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -381,8 +381,8 @@ public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -392,8 +392,8 @@ public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -403,8 +403,8 @@ public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X3<ulong>(Matrix4X3<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index c93d2d3804..c77c210af0 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -323,8 +323,8 @@ public Matrix4X4<T> Transpose() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -334,8 +334,8 @@ public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X4<float>(Matrix4X4<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -345,8 +345,8 @@ public static explicit operator Matrix4X4<float>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X4<double>(Matrix4X4<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -356,8 +356,8 @@ public static explicit operator Matrix4X4<double>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -367,8 +367,8 @@ public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -378,8 +378,8 @@ public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X4<short>(Matrix4X4<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -389,8 +389,8 @@ public static explicit operator Matrix4X4<short>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X4<int>(Matrix4X4<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -400,8 +400,8 @@ public static explicit operator Matrix4X4<int>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X4<long>(Matrix4X4<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -411,8 +411,8 @@ public static explicit operator Matrix4X4<long>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -422,8 +422,8 @@ public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -433,8 +433,8 @@ public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -444,8 +444,8 @@ public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X4<ulong>(Matrix4X4<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index def96a81ab..91ae1f4986 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -292,8 +292,8 @@ public override string ToString() =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="Half"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from) =>
             new(from.Row1.As<Half>(),
                 from.Row2.As<Half>(),
@@ -304,8 +304,8 @@ public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="float"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix5X4<float>(Matrix5X4<T> from) =>
             new(from.Row1.As<float>(),
                 from.Row2.As<float>(),
@@ -316,8 +316,8 @@ public static explicit operator Matrix5X4<float>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="double"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix5X4<double>(Matrix5X4<T> from) =>
             new(from.Row1.As<double>(),
                 from.Row2.As<double>(),
@@ -328,8 +328,8 @@ public static explicit operator Matrix5X4<double>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from) =>
             new(from.Row1.As<decimal>(),
                 from.Row2.As<decimal>(),
@@ -340,8 +340,8 @@ public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from) =>
             new(from.Row1.As<byte>(),
                 from.Row2.As<byte>(),
@@ -352,8 +352,8 @@ public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix5X4<short>(Matrix5X4<T> from) =>
             new(from.Row1.As<short>(),
                 from.Row2.As<short>(),
@@ -364,8 +364,8 @@ public static explicit operator Matrix5X4<short>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix5X4<int>(Matrix5X4<T> from) =>
             new(from.Row1.As<int>(),
                 from.Row2.As<int>(),
@@ -376,8 +376,8 @@ public static explicit operator Matrix5X4<int>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix5X4<long>(Matrix5X4<T> from) =>
             new(from.Row1.As<long>(),
                 from.Row2.As<long>(),
@@ -388,8 +388,8 @@ public static explicit operator Matrix5X4<long>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from) =>
             new(from.Row1.As<sbyte>(),
                 from.Row2.As<sbyte>(),
@@ -400,8 +400,8 @@ public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from) =>
             new(from.Row1.As<ushort>(),
                 from.Row2.As<ushort>(),
@@ -412,8 +412,8 @@ public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from) =>
             new(from.Row1.As<uint>(),
                 from.Row2.As<uint>(),
@@ -424,8 +424,8 @@ public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from) =>
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
         /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix5X4<ulong>(Matrix5X4<T> from) =>
             new(from.Row1.As<ulong>(),
                 from.Row2.As<ulong>(),
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index d62934f8fb..0b09be2ea6 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -356,6 +356,102 @@ public static implicit operator (T X, T Y)(Vector2D<T> v) =>
 
         public static Vector2D<T> operator /(Vector2D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator Vector2D<Half>(Vector2D<T> from) =>
+            from.As<Half>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator Vector2D<float>(Vector2D<T> from) =>
+            from.As<float>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator Vector2D<double>(Vector2D<T> from) =>
+            from.As<double>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator Vector2D<decimal>(Vector2D<T> from) =>
+            from.As<decimal>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator Vector2D<byte>(Vector2D<T> from) =>
+            from.As<byte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator Vector2D<short>(Vector2D<T> from) =>
+            from.As<short>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator Vector2D<int>(Vector2D<T> from) =>
+            from.As<int>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator Vector2D<long>(Vector2D<T> from) =>
+            from.As<long>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator Vector2D<sbyte>(Vector2D<T> from) =>
+            from.As<sbyte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator Vector2D<ushort>(Vector2D<T> from) =>
+            from.As<ushort>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator Vector2D<uint>(Vector2D<T> from) =>
+            from.As<uint>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator Vector2D<ulong>(Vector2D<T> from) =>
+            from.As<ulong>();
     }
 
     public static partial class Vector2D
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index f65b1522b7..ac758bac66 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -395,6 +395,102 @@ public static implicit operator (T X, T Y, T Z)(Vector3D<T> v) =>
 
         public static Vector3D<T> operator /(Vector3D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator Vector3D<Half>(Vector3D<T> from) =>
+            from.As<Half>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator Vector3D<float>(Vector3D<T> from) =>
+            from.As<float>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator Vector3D<double>(Vector3D<T> from) =>
+            from.As<double>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator Vector3D<decimal>(Vector3D<T> from) =>
+            from.As<decimal>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator Vector3D<byte>(Vector3D<T> from) =>
+            from.As<byte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator Vector3D<short>(Vector3D<T> from) =>
+            from.As<short>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator Vector3D<int>(Vector3D<T> from) =>
+            from.As<int>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator Vector3D<long>(Vector3D<T> from) =>
+            from.As<long>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator Vector3D<sbyte>(Vector3D<T> from) =>
+            from.As<sbyte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator Vector3D<ushort>(Vector3D<T> from) =>
+            from.As<ushort>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator Vector3D<uint>(Vector3D<T> from) =>
+            from.As<uint>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator Vector3D<ulong>(Vector3D<T> from) =>
+            from.As<ulong>();
     }
 
     public static partial class Vector3D
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index 1055a4c936..210e3a98b4 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -434,6 +434,102 @@ public static implicit operator (T X, T Y, T Z, T W)(Vector4D<T> v) =>
 
         public static Vector4D<T> operator /(Vector4D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator Vector4D<Half>(Vector4D<T> from) =>
+            from.As<Half>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator Vector4D<float>(Vector4D<T> from) =>
+            from.As<float>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator Vector4D<double>(Vector4D<T> from) =>
+            from.As<double>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator Vector4D<decimal>(Vector4D<T> from) =>
+            from.As<decimal>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator Vector4D<byte>(Vector4D<T> from) =>
+            from.As<byte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator Vector4D<short>(Vector4D<T> from) =>
+            from.As<short>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator Vector4D<int>(Vector4D<T> from) =>
+            from.As<int>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator Vector4D<long>(Vector4D<T> from) =>
+            from.As<long>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator Vector4D<sbyte>(Vector4D<T> from) =>
+            from.As<sbyte>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator Vector4D<ushort>(Vector4D<T> from) =>
+            from.As<ushort>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator Vector4D<uint>(Vector4D<T> from) =>
+            from.As<uint>();
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator Vector4D<ulong>(Vector4D<T> from) =>
+            from.As<ulong>();
     }
 
     public static partial class Vector4D

From 5e0e7d9cd9a88f316971d3b85ed9bb4d48a924f2 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 14:55:53 -0700
Subject: [PATCH 42/52] Use extension properties for LengthSquared and Length. 
 Use these for Normalize. Add DistanceSquared and Distance.

---
 sources/Maths/Maths/Silk.NET.Maths.csproj |  1 +
 sources/Maths/Maths/Vector2D.cs           | 37 ++++++-------------
 sources/Maths/Maths/Vector2D.gen.cs       | 44 ++++++++++++++++++-----
 sources/Maths/Maths/Vector3D.cs           | 29 ++++++---------
 sources/Maths/Maths/Vector3D.gen.cs       | 44 ++++++++++++++++++-----
 sources/Maths/Maths/Vector4D.cs           |  2 --
 sources/Maths/Maths/Vector4D.gen.cs       | 44 ++++++++++++++++++-----
 7 files changed, 127 insertions(+), 74 deletions(-)

diff --git a/sources/Maths/Maths/Silk.NET.Maths.csproj b/sources/Maths/Maths/Silk.NET.Maths.csproj
index dbfdad1475..c4a41cabc6 100644
--- a/sources/Maths/Maths/Silk.NET.Maths.csproj
+++ b/sources/Maths/Maths/Silk.NET.Maths.csproj
@@ -2,6 +2,7 @@
 
     <PropertyGroup>
         <TargetFramework>net8.0</TargetFramework>
+        <LangVersion>preview</LangVersion>
         <Nullable>enable</Nullable>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/sources/Maths/Maths/Vector2D.cs b/sources/Maths/Maths/Vector2D.cs
index dd577a241c..2f8e1cd237 100644
--- a/sources/Maths/Maths/Vector2D.cs
+++ b/sources/Maths/Maths/Vector2D.cs
@@ -14,12 +14,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 2D integer vector.</summary>
     public partial struct Vector2D<T>
     {
-        /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public T Cross(Vector2D<T> other) => (X * other.Y) - (Y * other.X);
-
-        /// <summary> Computes the cross product of two vectors. </summary>
-        public static T Cross(Vector2D<T> left, Vector2D<T> right) => (left.X * right.Y) - (left.Y * right.X);
-
         // Casts
 
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2D{T}"/>.</summary>
@@ -47,32 +41,21 @@ public static Vector2D<T> LerpClamped(Vector2D<T> a, Vector2D<T> b, Vector2D<T>
                 a.X + (b.X - a.X) * T.Clamp(t.X, T.Zero, T.One),
                 a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
             );
-
-        // IFloatingPointIeee754
-
-        public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos(Vector2D<T> x) =>
-            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
-
-        public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi(Vector2D<T> x) =>
-            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
-
-        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, Vector2D<T> right, Vector2D<T> addend) =>
-            new(T.FusedMultiplyAdd(left.X, right.X, addend.X), T.FusedMultiplyAdd(left.Y, right.Y, addend.Y));
-
-        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, Vector2D<T> right, T addend) =>
-            new(T.FusedMultiplyAdd(left.X, right.X, addend), T.FusedMultiplyAdd(left.Y, right.Y, addend));
-
-        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, T right, Vector2D<T> addend) =>
-            new(T.FusedMultiplyAdd(left.X, right, addend.X), T.FusedMultiplyAdd(left.Y, right, addend.Y));
-
-        public static Vector2D<T> FusedMultiplyAdd(Vector2D<T> left, T right, T addend) =>
-            new(T.FusedMultiplyAdd(left.X, right, addend), T.FusedMultiplyAdd(left.Y, right, addend));
     }
 
     public static partial class Vector2D
     {
         /// <summary> Computes the cross product of two vectors.</summary>
         public static T Cross<T>(this Vector2D<T> left, Vector2D<T> right)
-            where T : IFloatingPointIeee754<T> => (left.X * right.Y) - (left.Y * right.X);
+            where T : INumberBase<T> =>
+            (left.X * right.Y) - (left.Y * right.X);
+
+        public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos<T>(this Vector2D<T> x)
+            where T : INumberBase<T> =>
+            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
+
+        public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi<T>(this Vector2D<T> x)
+            where T : INumberBase<T> =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
     }
 }
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 0b09be2ea6..fb65471a0b 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -51,8 +51,6 @@ public Vector2D(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 1).</summary>
         public static Vector2D<T> UnitY => new(T.Zero, T.One);
 
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector2D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -456,6 +454,20 @@ public static explicit operator Vector2D<ulong>(Vector2D<T> from) =>
 
     public static partial class Vector2D
     {
+        extension<T>(Vector2D<T> vector)
+            where T : IRootFunctions<T>
+        {
+            /// <summary>Gets the length of the vector.</summary>
+            public T Length => T.Sqrt(vector.LengthSquared);
+        }
+
+        extension<T>(Vector2D<T> vector)
+            where T : INumberBase<T>
+        {
+            /// <summary>Gets the length squared of the vector.</summary>
+            public T LengthSquared => Vector2D.Dot(vector, vector);
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector2D<T> left, Vector2D<T> right)
             where T : INumberBase<T> =>
@@ -469,19 +481,33 @@ public static Vector2D<T> Reflect<T>(Vector2D<T> vector, Vector2D<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector2D<T> vector)
-            where T : IFloatingPointIeee754<T> =>
-            T.Sqrt(vector.LengthSquared);
-
         /// <summary>Normalizes a vector.</summary>
         public static Vector2D<T> Normalize<T>(this Vector2D<T> vector)
-            where T : IFloatingPointIeee754<T>
+            where T : IRootFunctions<T>
         {
-            T length = vector.GetLength();
+            T length = vector.Length;
             return length != T.Zero ? vector / length : Vector2D<T>.Zero;
         }
 
+        /// <summary>Returns the Euclidean distance between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance.</returns>
+        public static T Distance<T>(Vector2D<T> value1, Vector2D<T> value2)
+            where T : IRootFunctions<T> =>
+            T.Sqrt(DistanceSquared(value1, value2));
+
+        /// <summary>Returns the Euclidean distance squared between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance squared.</returns>
+        public static T DistanceSquared<T>(Vector2D<T> value1, Vector2D<T> value2)
+            where T : INumberBase<T>
+        {
+            var difference = value1 - value2;
+            return Dot(difference, difference);
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector2D<int> Sign<TSelf>(this Vector2D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector3D.cs b/sources/Maths/Maths/Vector3D.cs
index d1a2cdb784..3423cd71be 100644
--- a/sources/Maths/Maths/Vector3D.cs
+++ b/sources/Maths/Maths/Vector3D.cs
@@ -14,24 +14,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 3D integer vector.</summary>
     public partial struct Vector3D<T>
     {
-        /// <summary> Computes the cross product of this vector with another vector. </summary>
-        public Vector3D<T> Cross(Vector3D<T> other) =>
-            new Vector3D<T>(
-                (Y * other.Z) - (Z * other.Y),
-                (Z * other.X) - (X * other.Z),
-                (X * other.Y) - (Y * other.X)
-            );
-
-        /// <summary> Computes the cross product of two vectors. </summary>
-        public static Vector3D<T> Cross(Vector3D<T> left, Vector3D<T> right) =>
-            new Vector3D<T>(
-                (left.Y * right.Z) - (left.Z * right.Y),
-                (left.Z * right.X) - (left.X * right.Z),
-                (left.X * right.Y) - (left.Y * right.X)
-            );
-
-        // Casts
-
         /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3D{T}"/>.</summary>
         public static explicit operator Vector3D<T>(System.Numerics.Vector3 v) =>
             new Vector3D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
@@ -48,4 +30,15 @@ public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem(Vector3D<T> l
             return (new Vector3D<T>(qX, qY, qZ), new Vector3D<T>(rX, rY, rZ));
         }
     }
+
+    public static partial class Vector2D
+    {
+        /// <summary> Computes the cross product of two vectors. </summary>
+        public static Vector3D<T> Cross<T>(this Vector3D<T> left, Vector3D<T> right)
+            where T : INumberBase<T> =>
+            new Vector3D<T>(
+                (left.Y * right.Z) - (left.Z * right.Y),
+                (left.Z * right.X) - (left.X * right.Z),
+                (left.X * right.Y) - (left.Y * right.X));
+    }
 }
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index ac758bac66..368a08c31a 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -61,8 +61,6 @@ public Vector3D(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 0, 1).</summary>
         public static Vector3D<T> UnitZ => new(T.Zero, T.Zero, T.One);
 
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector3D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -495,6 +493,20 @@ public static explicit operator Vector3D<ulong>(Vector3D<T> from) =>
 
     public static partial class Vector3D
     {
+        extension<T>(Vector3D<T> vector)
+            where T : IRootFunctions<T>
+        {
+            /// <summary>Gets the length of the vector.</summary>
+            public T Length => T.Sqrt(vector.LengthSquared);
+        }
+
+        extension<T>(Vector3D<T> vector)
+            where T : INumberBase<T>
+        {
+            /// <summary>Gets the length squared of the vector.</summary>
+            public T LengthSquared => Vector3D.Dot(vector, vector);
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector3D<T> left, Vector3D<T> right)
             where T : INumberBase<T> =>
@@ -508,19 +520,33 @@ public static Vector3D<T> Reflect<T>(Vector3D<T> vector, Vector3D<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector3D<T> vector)
-            where T : IFloatingPointIeee754<T> =>
-            T.Sqrt(vector.LengthSquared);
-
         /// <summary>Normalizes a vector.</summary>
         public static Vector3D<T> Normalize<T>(this Vector3D<T> vector)
-            where T : IFloatingPointIeee754<T>
+            where T : IRootFunctions<T>
         {
-            T length = vector.GetLength();
+            T length = vector.Length;
             return length != T.Zero ? vector / length : Vector3D<T>.Zero;
         }
 
+        /// <summary>Returns the Euclidean distance between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance.</returns>
+        public static T Distance<T>(Vector3D<T> value1, Vector3D<T> value2)
+            where T : IRootFunctions<T> =>
+            T.Sqrt(DistanceSquared(value1, value2));
+
+        /// <summary>Returns the Euclidean distance squared between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance squared.</returns>
+        public static T DistanceSquared<T>(Vector3D<T> value1, Vector3D<T> value2)
+            where T : INumberBase<T>
+        {
+            var difference = value1 - value2;
+            return Dot(difference, difference);
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector3D<int> Sign<TSelf>(this Vector3D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector4D.cs b/sources/Maths/Maths/Vector4D.cs
index a50f79549d..b0ce4f0345 100644
--- a/sources/Maths/Maths/Vector4D.cs
+++ b/sources/Maths/Maths/Vector4D.cs
@@ -13,8 +13,6 @@ namespace Silk.NET.Maths
     /// <summary>A structure representing a 4D integer vector.</summary>
     public partial struct Vector4D<T>
     {
-        // Casts
-
         /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4D.</summary>
         public static explicit operator Vector4D<T>(System.Numerics.Vector4 v) =>
             new Vector4D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)), (T)Convert.ChangeType(v.W, typeof(T)));
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index 210e3a98b4..8b433d61c2 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -71,8 +71,6 @@ public Vector4D(ReadOnlySpan<T> values)
         /// <summary>Gets the vector (0, 0, 0, 1).</summary>
         public static Vector4D<T> UnitW => new(T.Zero, T.Zero, T.Zero, T.One);
 
-        /// <summary>Gets the squared length of the vector (dot product with itself).</summary>
-        public T LengthSquared => Vector4D.Dot(this, this);
 
         /// <inheritdoc/>
         T IReadOnlyList<T>.this[int index] => this[index];
@@ -534,6 +532,20 @@ public static explicit operator Vector4D<ulong>(Vector4D<T> from) =>
 
     public static partial class Vector4D
     {
+        extension<T>(Vector4D<T> vector)
+            where T : IRootFunctions<T>
+        {
+            /// <summary>Gets the length of the vector.</summary>
+            public T Length => T.Sqrt(vector.LengthSquared);
+        }
+
+        extension<T>(Vector4D<T> vector)
+            where T : INumberBase<T>
+        {
+            /// <summary>Gets the length squared of the vector.</summary>
+            public T LengthSquared => Vector4D.Dot(vector, vector);
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector4D<T> left, Vector4D<T> right)
             where T : INumberBase<T> =>
@@ -547,19 +559,33 @@ public static Vector4D<T> Reflect<T>(Vector4D<T> vector, Vector4D<T> normal)
             return vector - (normal * (dot + dot));
         }
 
-        /// <summary>Computes the length of the vector.</summary>
-        public static T GetLength<T>(this Vector4D<T> vector)
-            where T : IFloatingPointIeee754<T> =>
-            T.Sqrt(vector.LengthSquared);
-
         /// <summary>Normalizes a vector.</summary>
         public static Vector4D<T> Normalize<T>(this Vector4D<T> vector)
-            where T : IFloatingPointIeee754<T>
+            where T : IRootFunctions<T>
         {
-            T length = vector.GetLength();
+            T length = vector.Length;
             return length != T.Zero ? vector / length : Vector4D<T>.Zero;
         }
 
+        /// <summary>Returns the Euclidean distance between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance.</returns>
+        public static T Distance<T>(Vector4D<T> value1, Vector4D<T> value2)
+            where T : IRootFunctions<T> =>
+            T.Sqrt(DistanceSquared(value1, value2));
+
+        /// <summary>Returns the Euclidean distance squared between the two given points.</summary>
+        /// <param name="value1">The first point.</param>
+        /// <param name="value2">The second point.</param>
+        /// <returns>The distance squared.</returns>
+        public static T DistanceSquared<T>(Vector4D<T> value1, Vector4D<T> value2)
+            where T : INumberBase<T>
+        {
+            var difference = value1 - value2;
+            return Dot(difference, difference);
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector4D<int> Sign<TSelf>(this Vector4D<TSelf> value)

From 5973151c022420dccf9ba432b80391dd792eb091 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 15:31:36 -0700
Subject: [PATCH 43/52] Generate more vector functions and reorganize.

---
 sources/Maths/Maths/Vector2D.cs     | 44 ++++-------------------------
 sources/Maths/Maths/Vector2D.gen.cs | 27 ++++++++++++++++++
 sources/Maths/Maths/Vector3D.cs     | 26 ++++-------------
 sources/Maths/Maths/Vector3D.gen.cs | 29 +++++++++++++++++++
 sources/Maths/Maths/Vector4D.cs     | 24 ++++------------
 sources/Maths/Maths/Vector4D.gen.cs | 31 ++++++++++++++++++++
 6 files changed, 103 insertions(+), 78 deletions(-)

diff --git a/sources/Maths/Maths/Vector2D.cs b/sources/Maths/Maths/Vector2D.cs
index 2f8e1cd237..5ade5f68db 100644
--- a/sources/Maths/Maths/Vector2D.cs
+++ b/sources/Maths/Maths/Vector2D.cs
@@ -1,46 +1,20 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-
-using System.Collections;
-using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
 
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 2D integer vector.</summary>
     public partial struct Vector2D<T>
     {
-        // Casts
-
-        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector2"/> to a <see cref="Vector2D{T}"/>.</summary>
-        public static explicit operator Vector2D<T>(System.Numerics.Vector2 v) =>
+        /// <summary>Explicitly casts a <see cref="Vector2"/> to a <see cref="Vector2D{T}"/>.</summary>
+        public static explicit operator Vector2D<T>(Vector2 v) =>
             new Vector2D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)));
 
-        /// <summary>Explicitly casts a <see cref="Vector2D{T}"/> to <see cref="System.Numerics.Vector2"/>.</summary>
-        public static explicit operator System.Numerics.Vector2(Vector2D<T> v) =>
-            new System.Numerics.Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
-
-        public static (Vector2D<T> Quotient, Vector2D<T> Remainder) DivRem(Vector2D<T> left, Vector2D<T> right)
-        {
-            var (qX, rX) = T.DivRem(left.X, right.X);
-            var (qY, rY) = T.DivRem(left.Y, right.Y);
-            return (new Vector2D<T>(qX, qY), new Vector2D<T>(rX, rY));
-        }
-
-        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
-        public static Vector2D<T> LerpClamped(Vector2D<T> a, Vector2D<T> b, T t) =>
-            Vector2D.Lerp(a, b, T.Clamp(t, T.Zero, T.One));
-
-        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
-        public static Vector2D<T> LerpClamped(Vector2D<T> a, Vector2D<T> b, Vector2D<T> t) =>
-            new(
-                a.X + (b.X - a.X) * T.Clamp(t.X, T.Zero, T.One),
-                a.Y + (b.Y - a.Y) * T.Clamp(t.Y, T.Zero, T.One)
-            );
+        /// <summary>Explicitly casts a <see cref="Vector2D{T}"/> to <see cref="Vector2"/>.</summary>
+        public static explicit operator Vector2(Vector2D<T> v) =>
+            new Vector2(Convert.ToSingle(v.X), Convert.ToSingle(v.Y));
     }
 
     public static partial class Vector2D
@@ -49,13 +23,5 @@ public static partial class Vector2D
         public static T Cross<T>(this Vector2D<T> left, Vector2D<T> right)
             where T : INumberBase<T> =>
             (left.X * right.Y) - (left.Y * right.X);
-
-        public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos<T>(this Vector2D<T> x)
-            where T : INumberBase<T> =>
-            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
-
-        public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi<T>(this Vector2D<T> x)
-            where T : INumberBase<T> =>
-            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
     }
 }
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index fb65471a0b..474b209e2f 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -508,6 +508,33 @@ public static T DistanceSquared<T>(Vector2D<T> value1, Vector2D<T> value2)
             return Dot(difference, difference);
         }
 
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
+        public static Vector2D<T> LerpClamped<T>(Vector2D<T> a, Vector2D<T> b, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            Lerp(a, b, T.Clamp(amount, T.Zero, T.One));
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
+        public static Vector2D<T> LerpClamped<T>(Vector2D<T> a, Vector2D<T> b, Vector2D<T> amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(T.Lerp(a.X, b.X, T.Clamp(amount.X, T.Zero, T.One)),
+                T.Lerp(a.Y, b.Y, T.Clamp(amount.Y, T.Zero, T.One)));
+
+        public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos<T>(this Vector2D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
+
+        public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi<T>(this Vector2D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
+
+        public static (Vector2D<T> Quotient, Vector2D<T> Remainder) DivRem<T>(Vector2D<T> left, Vector2D<T> right)
+            where T : IBinaryInteger<T>
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            return (new Vector2D<T>(qX, qY), new Vector2D<T>(rX, rY));
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector2D<int> Sign<TSelf>(this Vector2D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector3D.cs b/sources/Maths/Maths/Vector3D.cs
index 3423cd71be..6e70b85bd8 100644
--- a/sources/Maths/Maths/Vector3D.cs
+++ b/sources/Maths/Maths/Vector3D.cs
@@ -1,37 +1,23 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-
-using System.Collections;
-using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
 
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 3D integer vector.</summary>
     public partial struct Vector3D<T>
     {
-        /// <summary>Explicitly casts a <see cref="System.Numerics.Vector3"/> to a <see cref="Vector3D{T}"/>.</summary>
-        public static explicit operator Vector3D<T>(System.Numerics.Vector3 v) =>
+        /// <summary>Explicitly casts a <see cref="Vector3"/> to a <see cref="Vector3D{T}"/>.</summary>
+        public static explicit operator Vector3D<T>(Vector3 v) =>
             new Vector3D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)));
 
-        /// <summary>Explicitly casts a <see cref="Vector3D{T}"/> to <see cref="System.Numerics.Vector3"/>.</summary>
-        public static explicit operator System.Numerics.Vector3(Vector3D<T> v) =>
-            new System.Numerics.Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
-
-        public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem(Vector3D<T> left, Vector3D<T> right)
-        {
-            var (qX, rX) = T.DivRem(left.X, right.X);
-            var (qY, rY) = T.DivRem(left.Y, right.Y);
-            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
-            return (new Vector3D<T>(qX, qY, qZ), new Vector3D<T>(rX, rY, rZ));
-        }
+        /// <summary>Explicitly casts a <see cref="Vector3D{T}"/> to <see cref="Vector3"/>.</summary>
+        public static explicit operator Vector3(Vector3D<T> v) =>
+            new Vector3(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z));
     }
 
-    public static partial class Vector2D
+    public static partial class Vector3D
     {
         /// <summary> Computes the cross product of two vectors. </summary>
         public static Vector3D<T> Cross<T>(this Vector3D<T> left, Vector3D<T> right)
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index 368a08c31a..e915fd65bf 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -547,6 +547,35 @@ public static T DistanceSquared<T>(Vector3D<T> value1, Vector3D<T> value2)
             return Dot(difference, difference);
         }
 
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
+        public static Vector3D<T> LerpClamped<T>(Vector3D<T> a, Vector3D<T> b, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            Lerp(a, b, T.Clamp(amount, T.Zero, T.One));
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
+        public static Vector3D<T> LerpClamped<T>(Vector3D<T> a, Vector3D<T> b, Vector3D<T> amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(T.Lerp(a.X, b.X, T.Clamp(amount.X, T.Zero, T.One)),
+                T.Lerp(a.Y, b.Y, T.Clamp(amount.Y, T.Zero, T.One)),
+                T.Lerp(a.Z, b.Z, T.Clamp(amount.Z, T.Zero, T.One)));
+
+        public static (Vector3D<T> Sin, Vector3D<T> Cos) SinCos<T>(this Vector3D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.Sin(x.X), T.Sin(x.Y), T.Sin(x.Z)), new(T.Cos(x.X), T.Cos(x.Y), T.Cos(x.Z)));
+
+        public static (Vector3D<T> SinPi, Vector3D<T> CosPi) SinCosPi<T>(this Vector3D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y), T.SinPi(x.Z)), new(T.CosPi(x.X), T.CosPi(x.Y), T.CosPi(x.Z)));
+
+        public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem<T>(Vector3D<T> left, Vector3D<T> right)
+            where T : IBinaryInteger<T>
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
+            return (new Vector3D<T>(qX, qY, qZ), new Vector3D<T>(rX, rY, rZ));
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector3D<int> Sign<TSelf>(this Vector3D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector4D.cs b/sources/Maths/Maths/Vector4D.cs
index b0ce4f0345..8a11841c66 100644
--- a/sources/Maths/Maths/Vector4D.cs
+++ b/sources/Maths/Maths/Vector4D.cs
@@ -1,33 +1,19 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-
-using System.Collections;
-using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
-using System.Runtime.InteropServices;
-using System.Text;
 
 namespace Silk.NET.Maths
 {
     /// <summary>A structure representing a 4D integer vector.</summary>
     public partial struct Vector4D<T>
     {
-        /// <summary>Explicitly casts a System.Numerics.Vector4 to a Vector4D.</summary>
-        public static explicit operator Vector4D<T>(System.Numerics.Vector4 v) =>
+        /// <summary>Explicitly casts a <see cref="Vector4"/> to a <see cref="Vector4D{T}"/>.</summary>
+        public static explicit operator Vector4D<T>(Vector4 v) =>
             new Vector4D<T>((T)Convert.ChangeType(v.X, typeof(T)), (T)Convert.ChangeType(v.Y, typeof(T)), (T)Convert.ChangeType(v.Z, typeof(T)), (T)Convert.ChangeType(v.W, typeof(T)));
 
-        /// <summary>Explicitly casts a Vector4D to System.Numerics.Vector4.</summary>
-        public static explicit operator System.Numerics.Vector4(Vector4D<T> v) =>
-            new System.Numerics.Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
-
-        public static (Vector4D<T> Quotient, Vector4D<T> Remainder) DivRem(Vector4D<T> left, Vector4D<T> right)
-        {
-            var (qX, rX) = T.DivRem(left.X, right.X);
-            var (qY, rY) = T.DivRem(left.Y, right.Y);
-            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
-            var (qW, rW) = T.DivRem(left.W, right.W);
-            return (new Vector4D<T>(qX, qY, qZ, qW), new Vector4D<T>(rX, rY, rZ, rW));
-        }
+        /// <summary>Explicitly casts a <see cref="Vector4D{T}"/> to <see cref="Vector4"/>.</summary>
+        public static explicit operator Vector4(Vector4D<T> v) =>
+            new Vector4(Convert.ToSingle(v.X), Convert.ToSingle(v.Y), Convert.ToSingle(v.Z), Convert.ToSingle(v.W));
     }
 }
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index 8b433d61c2..04cf959ede 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -586,6 +586,37 @@ public static T DistanceSquared<T>(Vector4D<T> value1, Vector4D<T> value2)
             return Dot(difference, difference);
         }
 
+        /// <summary>Linearly interpolates between two vectors using a scalar t-value (clamped between 0 and 1).</summary>
+        public static Vector4D<T> LerpClamped<T>(Vector4D<T> a, Vector4D<T> b, T amount)
+            where T : IFloatingPointIeee754<T> =>
+            Lerp(a, b, T.Clamp(amount, T.Zero, T.One));
+
+        /// <summary>Linearly interpolates between two vectors using a vector t-value (clamped between 0 and 1).</summary>
+        public static Vector4D<T> LerpClamped<T>(Vector4D<T> a, Vector4D<T> b, Vector4D<T> amount)
+            where T : IFloatingPointIeee754<T> =>
+            new(T.Lerp(a.X, b.X, T.Clamp(amount.X, T.Zero, T.One)),
+                T.Lerp(a.Y, b.Y, T.Clamp(amount.Y, T.Zero, T.One)),
+                T.Lerp(a.Z, b.Z, T.Clamp(amount.Z, T.Zero, T.One)),
+                T.Lerp(a.W, b.W, T.Clamp(amount.W, T.Zero, T.One)));
+
+        public static (Vector4D<T> Sin, Vector4D<T> Cos) SinCos<T>(this Vector4D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.Sin(x.X), T.Sin(x.Y), T.Sin(x.Z), T.Sin(x.W)), new(T.Cos(x.X), T.Cos(x.Y), T.Cos(x.Z), T.Cos(x.W)));
+
+        public static (Vector4D<T> SinPi, Vector4D<T> CosPi) SinCosPi<T>(this Vector4D<T> x)
+            where T : ITrigonometricFunctions<T> =>
+            (new(T.SinPi(x.X), T.SinPi(x.Y), T.SinPi(x.Z), T.SinPi(x.W)), new(T.CosPi(x.X), T.CosPi(x.Y), T.CosPi(x.Z), T.CosPi(x.W)));
+
+        public static (Vector4D<T> Quotient, Vector4D<T> Remainder) DivRem<T>(Vector4D<T> left, Vector4D<T> right)
+            where T : IBinaryInteger<T>
+        {
+            var (qX, rX) = T.DivRem(left.X, right.X);
+            var (qY, rY) = T.DivRem(left.Y, right.Y);
+            var (qZ, rZ) = T.DivRem(left.Z, right.Z);
+            var (qW, rW) = T.DivRem(left.W, right.W);
+            return (new Vector4D<T>(qX, qY, qZ, qW), new Vector4D<T>(rX, rY, rZ, rW));
+        }
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector4D<int> Sign<TSelf>(this Vector4D<TSelf> value)

From 69be9de99547f689e869339a15d47af1efc787ee Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 15:32:06 -0700
Subject: [PATCH 44/52] Fix type constraints.

---
 sources/Maths/Maths/Circle.cs        | 4 ++--
 sources/Maths/Maths/Matrix2X3.Ops.cs | 2 +-
 sources/Maths/Maths/Matrix3X3.Ops.cs | 2 +-
 sources/Maths/Maths/Matrix4X4.Ops.cs | 8 ++++----
 sources/Maths/Maths/Sphere.cs        | 6 ++++--
 5 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/sources/Maths/Maths/Circle.cs b/sources/Maths/Maths/Circle.cs
index fd0a4ff342..4be7fcc35e 100644
--- a/sources/Maths/Maths/Circle.cs
+++ b/sources/Maths/Maths/Circle.cs
@@ -14,7 +14,7 @@ namespace Silk.NET.Maths
     [DataContract]
     public struct Circle<T>
         : IEquatable<Circle<T>>
-        where T : INumberBase<T>
+        where T : IRootFunctions<T>
     {
         /// <summary>
         /// The center.
@@ -174,7 +174,7 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted circle</returns>
-        public Circle<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Circle<TOther> As<TOther>() where TOther : IRootFunctions<TOther>
         {
             return new(Center.As<TOther>(), Scalar.As<T, TOther>(Radius));
         }
diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index cd5d662780..81cae99cff 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -32,7 +32,7 @@ public static Matrix2X3<T> Add<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix2X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index e955b5c9bb..3f1dcf198d 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -53,7 +53,7 @@ public static Matrix3X3<T> Add<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix3X3<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index d44381a2c8..450925695d 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -58,7 +58,7 @@ public static Matrix4X4<T> Add<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
         /// <param name="cameraForwardVector">The forward vector of the camera.</param>
         /// <returns>The created billboard matrix</returns>
         public static Matrix4X4<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> cameraUpVector, Vector3D<T> cameraForwardVector)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             Vector3D<T> zaxis = objectPosition - cameraPosition;
             var norm = zaxis.LengthSquared;
@@ -90,7 +90,7 @@ public static Matrix4X4<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector
         /// <param name="objectForwardVector">Forward vector of the object.</param>
         /// <returns>The created billboard matrix.</returns>
         public static Matrix4X4<T> CreateConstrainedBillboard<T>(Vector3D<T> objectPosition, Vector3D<T> cameraPosition, Vector3D<T> rotateAxis, Vector3D<T> cameraForwardVector, Vector3D<T> objectForwardVector)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             // Treat the case when object and camera positions are too close.
             Vector3D<T> faceDir = objectPosition - cameraPosition;
@@ -250,7 +250,7 @@ public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
         /// <param name="cameraUpVector">The direction that is "up" from the camera's point of view.</param>
         /// <returns>The view matrix.</returns>
         public static Matrix4X4<T> CreateLookAt<T>(Vector3D<T> cameraPosition, Vector3D<T> cameraTarget, Vector3D<T> cameraUpVector)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             Vector3D<T> zaxis = Vector3D.Normalize(cameraPosition - cameraTarget);
             Vector3D<T> xaxis = Vector3D.Normalize(Vector3D.Cross(cameraUpVector, zaxis));
@@ -814,7 +814,7 @@ public static Matrix4X4<T> CreateTranslation<T>(T xPosition, T yPosition, T zPos
         /// <param name="up">Upward direction of the object; usually [0, 1, 0].</param>
         /// <returns>The world matrix.</returns>
         public static Matrix4X4<T> CreateWorld<T>(Vector3D<T> position, Vector3D<T> forward, Vector3D<T> up)
-            where T : INumberBase<T>
+            where T : IRootFunctions<T>
         {
             Vector3D<T> zaxis = Vector3D.Normalize(-forward);
             Vector3D<T> xaxis = Vector3D.Normalize(Vector3D.Cross(up, zaxis));
diff --git a/sources/Maths/Maths/Sphere.cs b/sources/Maths/Maths/Sphere.cs
index 91bce6e0f2..759a13290a 100644
--- a/sources/Maths/Maths/Sphere.cs
+++ b/sources/Maths/Maths/Sphere.cs
@@ -13,7 +13,8 @@ namespace Silk.NET.Maths
     [Serializable]
     [DataContract]
     public struct Sphere<T>
-        : IEquatable<Sphere<T>> where T : INumberBase<T>
+        : IEquatable<Sphere<T>>
+        where T : IRootFunctions<T>
     {
         /// <summary>
         /// The center.
@@ -169,7 +170,8 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted sphere</returns>
-        public Sphere<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Sphere<TOther> As<TOther>()
+            where TOther : IRootFunctions<TOther>
         {
             return new(Center.As<TOther>(), Scalar.As<T, TOther>(Radius));
         }

From 75b1c5de6a3b20785330c7f5a9b3fa9c739a3d48 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 16:31:17 -0700
Subject: [PATCH 45/52] Overloads for casts, As, CreateChecked,
 CreateSaturating, and CreateTruncating.

---
 sources/Maths/Maths/Matrix2X2.cs     |  10 -
 sources/Maths/Maths/Matrix2X2.gen.cs | 178 ++++++++++++++---
 sources/Maths/Maths/Matrix2X3.cs     |  10 -
 sources/Maths/Maths/Matrix2X3.gen.cs | 178 ++++++++++++++---
 sources/Maths/Maths/Matrix2X4.cs     |  10 -
 sources/Maths/Maths/Matrix2X4.gen.cs | 178 ++++++++++++++---
 sources/Maths/Maths/Matrix3X2.cs     |  10 -
 sources/Maths/Maths/Matrix3X2.gen.cs | 214 ++++++++++++++++----
 sources/Maths/Maths/Matrix3X3.cs     |  10 -
 sources/Maths/Maths/Matrix3X3.gen.cs | 214 ++++++++++++++++----
 sources/Maths/Maths/Matrix3X4.cs     |  10 -
 sources/Maths/Maths/Matrix3X4.gen.cs | 214 ++++++++++++++++----
 sources/Maths/Maths/Matrix4X2.cs     |  10 -
 sources/Maths/Maths/Matrix4X2.gen.cs | 250 ++++++++++++++++++-----
 sources/Maths/Maths/Matrix4X3.cs     |  10 -
 sources/Maths/Maths/Matrix4X3.gen.cs | 250 ++++++++++++++++++-----
 sources/Maths/Maths/Matrix4X4.cs     |  10 -
 sources/Maths/Maths/Matrix4X4.gen.cs | 250 ++++++++++++++++++-----
 sources/Maths/Maths/Matrix5X4.cs     |  10 -
 sources/Maths/Maths/Matrix5X4.gen.cs | 286 +++++++++++++++++++++------
 sources/Maths/Maths/Vector2D.gen.cs  | 155 +++++++++++++--
 sources/Maths/Maths/Vector3D.gen.cs  | 159 ++++++++++++---
 sources/Maths/Maths/Vector4D.gen.cs  | 163 ++++++++++++---
 23 files changed, 2236 insertions(+), 553 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X2.cs b/sources/Maths/Maths/Matrix2X2.cs
index ada5e31b39..c1af4faa51 100644
--- a/sources/Maths/Maths/Matrix2X2.cs
+++ b/sources/Maths/Maths/Matrix2X2.cs
@@ -81,15 +81,5 @@ public readonly T GetDeterminant()
 
             return Scalar.Subtract(Scalar.Multiply(a, d), Scalar.Multiply(b, c));
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix2X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index d1490acf18..0a61042a45 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -114,6 +114,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X2<T> CreateChecked<TOther>(Matrix2X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X2<T> CreateSaturating<TOther>(Matrix2X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X2<T> CreateTruncating<TOther>(Matrix2X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix2X2<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X2<T> Transpose() =>
             new(new(M11, M21),
@@ -179,14 +200,24 @@ public Matrix2X2<T> Transpose() =>
         public static Matrix2X2<T> operator *(Matrix2X2<T> left, Matrix2X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>());
+            new(Vector2D<Half>.CreateTruncating(from.Row1),
+                Vector2D<Half>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<Half>(Matrix2X2<T> from) =>
+            new(Vector2D<Half>.CreateChecked(from.Row1),
+                Vector2D<Half>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -194,8 +225,17 @@ public static explicit operator Matrix2X2<Half>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X2<float>(Matrix2X2<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>());
+            new(Vector2D<float>.CreateTruncating(from.Row1),
+                Vector2D<float>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<float>(Matrix2X2<T> from) =>
+            new(Vector2D<float>.CreateChecked(from.Row1),
+                Vector2D<float>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -203,8 +243,17 @@ public static explicit operator Matrix2X2<float>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X2<double>(Matrix2X2<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>());
+            new(Vector2D<double>.CreateTruncating(from.Row1),
+                Vector2D<double>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<double>(Matrix2X2<T> from) =>
+            new(Vector2D<double>.CreateChecked(from.Row1),
+                Vector2D<double>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -212,8 +261,17 @@ public static explicit operator Matrix2X2<double>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>());
+            new(Vector2D<decimal>.CreateTruncating(from.Row1),
+                Vector2D<decimal>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<decimal>(Matrix2X2<T> from) =>
+            new(Vector2D<decimal>.CreateChecked(from.Row1),
+                Vector2D<decimal>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -221,8 +279,17 @@ public static explicit operator Matrix2X2<decimal>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>());
+            new(Vector2D<byte>.CreateTruncating(from.Row1),
+                Vector2D<byte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<byte>(Matrix2X2<T> from) =>
+            new(Vector2D<byte>.CreateChecked(from.Row1),
+                Vector2D<byte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -230,8 +297,17 @@ public static explicit operator Matrix2X2<byte>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X2<short>(Matrix2X2<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>());
+            new(Vector2D<short>.CreateTruncating(from.Row1),
+                Vector2D<short>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<short>(Matrix2X2<T> from) =>
+            new(Vector2D<short>.CreateChecked(from.Row1),
+                Vector2D<short>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -239,8 +315,17 @@ public static explicit operator Matrix2X2<short>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X2<int>(Matrix2X2<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>());
+            new(Vector2D<int>.CreateTruncating(from.Row1),
+                Vector2D<int>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<int>(Matrix2X2<T> from) =>
+            new(Vector2D<int>.CreateChecked(from.Row1),
+                Vector2D<int>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -248,8 +333,17 @@ public static explicit operator Matrix2X2<int>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X2<long>(Matrix2X2<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>());
+            new(Vector2D<long>.CreateTruncating(from.Row1),
+                Vector2D<long>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<long>(Matrix2X2<T> from) =>
+            new(Vector2D<long>.CreateChecked(from.Row1),
+                Vector2D<long>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -257,8 +351,17 @@ public static explicit operator Matrix2X2<long>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>());
+            new(Vector2D<sbyte>.CreateTruncating(from.Row1),
+                Vector2D<sbyte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<sbyte>(Matrix2X2<T> from) =>
+            new(Vector2D<sbyte>.CreateChecked(from.Row1),
+                Vector2D<sbyte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -266,8 +369,17 @@ public static explicit operator Matrix2X2<sbyte>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>());
+            new(Vector2D<ushort>.CreateTruncating(from.Row1),
+                Vector2D<ushort>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<ushort>(Matrix2X2<T> from) =>
+            new(Vector2D<ushort>.CreateChecked(from.Row1),
+                Vector2D<ushort>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -275,8 +387,17 @@ public static explicit operator Matrix2X2<ushort>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>());
+            new(Vector2D<uint>.CreateTruncating(from.Row1),
+                Vector2D<uint>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<uint>(Matrix2X2<T> from) =>
+            new(Vector2D<uint>.CreateChecked(from.Row1),
+                Vector2D<uint>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -284,8 +405,17 @@ public static explicit operator Matrix2X2<uint>(Matrix2X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X2<ulong>(Matrix2X2<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>());
+            new(Vector2D<ulong>.CreateTruncating(from.Row1),
+                Vector2D<ulong>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix2X2<ulong>(Matrix2X2<T> from) =>
+            new(Vector2D<ulong>.CreateChecked(from.Row1),
+                Vector2D<ulong>.CreateChecked(from.Row2));
     }
 
     public static partial class Matrix2X2
diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index 884d142dd2..75e94fa6ed 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -79,15 +79,5 @@ public readonly bool IsIdentity
         {
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix2X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index 07f9ec51b9..cd3fd0c468 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -123,6 +123,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X3<T> CreateChecked<TOther>(Matrix2X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X3<T> CreateSaturating<TOther>(Matrix2X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X3<T> CreateTruncating<TOther>(Matrix2X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix2X3<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X2<T> Transpose() =>
             new(new(M11, M21),
@@ -197,14 +218,24 @@ public Matrix3X2<T> Transpose() =>
         public static Matrix2X2<T> operator *(Matrix2X3<T> left, Matrix3X2<T> right) =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>());
+            new(Vector3D<Half>.CreateTruncating(from.Row1),
+                Vector3D<Half>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<Half>(Matrix2X3<T> from) =>
+            new(Vector3D<Half>.CreateChecked(from.Row1),
+                Vector3D<Half>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -212,8 +243,17 @@ public static explicit operator Matrix2X3<Half>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X3<float>(Matrix2X3<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>());
+            new(Vector3D<float>.CreateTruncating(from.Row1),
+                Vector3D<float>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<float>(Matrix2X3<T> from) =>
+            new(Vector3D<float>.CreateChecked(from.Row1),
+                Vector3D<float>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -221,8 +261,17 @@ public static explicit operator Matrix2X3<float>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X3<double>(Matrix2X3<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>());
+            new(Vector3D<double>.CreateTruncating(from.Row1),
+                Vector3D<double>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<double>(Matrix2X3<T> from) =>
+            new(Vector3D<double>.CreateChecked(from.Row1),
+                Vector3D<double>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -230,8 +279,17 @@ public static explicit operator Matrix2X3<double>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>());
+            new(Vector3D<decimal>.CreateTruncating(from.Row1),
+                Vector3D<decimal>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<decimal>(Matrix2X3<T> from) =>
+            new(Vector3D<decimal>.CreateChecked(from.Row1),
+                Vector3D<decimal>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -239,8 +297,17 @@ public static explicit operator Matrix2X3<decimal>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>());
+            new(Vector3D<byte>.CreateTruncating(from.Row1),
+                Vector3D<byte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<byte>(Matrix2X3<T> from) =>
+            new(Vector3D<byte>.CreateChecked(from.Row1),
+                Vector3D<byte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -248,8 +315,17 @@ public static explicit operator Matrix2X3<byte>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X3<short>(Matrix2X3<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>());
+            new(Vector3D<short>.CreateTruncating(from.Row1),
+                Vector3D<short>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<short>(Matrix2X3<T> from) =>
+            new(Vector3D<short>.CreateChecked(from.Row1),
+                Vector3D<short>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -257,8 +333,17 @@ public static explicit operator Matrix2X3<short>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X3<int>(Matrix2X3<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>());
+            new(Vector3D<int>.CreateTruncating(from.Row1),
+                Vector3D<int>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<int>(Matrix2X3<T> from) =>
+            new(Vector3D<int>.CreateChecked(from.Row1),
+                Vector3D<int>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -266,8 +351,17 @@ public static explicit operator Matrix2X3<int>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X3<long>(Matrix2X3<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>());
+            new(Vector3D<long>.CreateTruncating(from.Row1),
+                Vector3D<long>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<long>(Matrix2X3<T> from) =>
+            new(Vector3D<long>.CreateChecked(from.Row1),
+                Vector3D<long>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -275,8 +369,17 @@ public static explicit operator Matrix2X3<long>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>());
+            new(Vector3D<sbyte>.CreateTruncating(from.Row1),
+                Vector3D<sbyte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<sbyte>(Matrix2X3<T> from) =>
+            new(Vector3D<sbyte>.CreateChecked(from.Row1),
+                Vector3D<sbyte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -284,8 +387,17 @@ public static explicit operator Matrix2X3<sbyte>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>());
+            new(Vector3D<ushort>.CreateTruncating(from.Row1),
+                Vector3D<ushort>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<ushort>(Matrix2X3<T> from) =>
+            new(Vector3D<ushort>.CreateChecked(from.Row1),
+                Vector3D<ushort>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -293,8 +405,17 @@ public static explicit operator Matrix2X3<ushort>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>());
+            new(Vector3D<uint>.CreateTruncating(from.Row1),
+                Vector3D<uint>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<uint>(Matrix2X3<T> from) =>
+            new(Vector3D<uint>.CreateChecked(from.Row1),
+                Vector3D<uint>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -302,8 +423,17 @@ public static explicit operator Matrix2X3<uint>(Matrix2X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X3<ulong>(Matrix2X3<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>());
+            new(Vector3D<ulong>.CreateTruncating(from.Row1),
+                Vector3D<ulong>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix2X3<ulong>(Matrix2X3<T> from) =>
+            new(Vector3D<ulong>.CreateChecked(from.Row1),
+                Vector3D<ulong>.CreateChecked(from.Row2));
     }
 
     public static partial class Matrix2X3
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index d6d530eb34..fb82209033 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -80,15 +80,5 @@ public readonly bool IsIdentity
         {
             return value1.X * value2.Row1 + value1.Y * value2.Row2;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix2X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index ee07f8dfee..2e8af8f158 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -137,6 +137,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X4<T> CreateChecked<TOther>(Matrix2X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X4<T> CreateSaturating<TOther>(Matrix2X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix2X4<T> CreateTruncating<TOther>(Matrix2X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix2X4<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X2<T> Transpose() =>
             new(new(M11, M21),
@@ -221,14 +242,24 @@ public Matrix4X2<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>());
+            new(Vector4D<Half>.CreateTruncating(from.Row1),
+                Vector4D<Half>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<Half>(Matrix2X4<T> from) =>
+            new(Vector4D<Half>.CreateChecked(from.Row1),
+                Vector4D<Half>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -236,8 +267,17 @@ public static explicit operator Matrix2X4<Half>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix2X4<float>(Matrix2X4<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>());
+            new(Vector4D<float>.CreateTruncating(from.Row1),
+                Vector4D<float>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<float>(Matrix2X4<T> from) =>
+            new(Vector4D<float>.CreateChecked(from.Row1),
+                Vector4D<float>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -245,8 +285,17 @@ public static explicit operator Matrix2X4<float>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix2X4<double>(Matrix2X4<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>());
+            new(Vector4D<double>.CreateTruncating(from.Row1),
+                Vector4D<double>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<double>(Matrix2X4<T> from) =>
+            new(Vector4D<double>.CreateChecked(from.Row1),
+                Vector4D<double>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -254,8 +303,17 @@ public static explicit operator Matrix2X4<double>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>());
+            new(Vector4D<decimal>.CreateTruncating(from.Row1),
+                Vector4D<decimal>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<decimal>(Matrix2X4<T> from) =>
+            new(Vector4D<decimal>.CreateChecked(from.Row1),
+                Vector4D<decimal>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -263,8 +321,17 @@ public static explicit operator Matrix2X4<decimal>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>());
+            new(Vector4D<byte>.CreateTruncating(from.Row1),
+                Vector4D<byte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<byte>(Matrix2X4<T> from) =>
+            new(Vector4D<byte>.CreateChecked(from.Row1),
+                Vector4D<byte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -272,8 +339,17 @@ public static explicit operator Matrix2X4<byte>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix2X4<short>(Matrix2X4<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>());
+            new(Vector4D<short>.CreateTruncating(from.Row1),
+                Vector4D<short>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<short>(Matrix2X4<T> from) =>
+            new(Vector4D<short>.CreateChecked(from.Row1),
+                Vector4D<short>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -281,8 +357,17 @@ public static explicit operator Matrix2X4<short>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix2X4<int>(Matrix2X4<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>());
+            new(Vector4D<int>.CreateTruncating(from.Row1),
+                Vector4D<int>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<int>(Matrix2X4<T> from) =>
+            new(Vector4D<int>.CreateChecked(from.Row1),
+                Vector4D<int>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -290,8 +375,17 @@ public static explicit operator Matrix2X4<int>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix2X4<long>(Matrix2X4<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>());
+            new(Vector4D<long>.CreateTruncating(from.Row1),
+                Vector4D<long>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<long>(Matrix2X4<T> from) =>
+            new(Vector4D<long>.CreateChecked(from.Row1),
+                Vector4D<long>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -299,8 +393,17 @@ public static explicit operator Matrix2X4<long>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>());
+            new(Vector4D<sbyte>.CreateTruncating(from.Row1),
+                Vector4D<sbyte>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<sbyte>(Matrix2X4<T> from) =>
+            new(Vector4D<sbyte>.CreateChecked(from.Row1),
+                Vector4D<sbyte>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -308,8 +411,17 @@ public static explicit operator Matrix2X4<sbyte>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>());
+            new(Vector4D<ushort>.CreateTruncating(from.Row1),
+                Vector4D<ushort>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<ushort>(Matrix2X4<T> from) =>
+            new(Vector4D<ushort>.CreateChecked(from.Row1),
+                Vector4D<ushort>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -317,8 +429,17 @@ public static explicit operator Matrix2X4<ushort>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>());
+            new(Vector4D<uint>.CreateTruncating(from.Row1),
+                Vector4D<uint>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<uint>(Matrix2X4<T> from) =>
+            new(Vector4D<uint>.CreateChecked(from.Row1),
+                Vector4D<uint>.CreateChecked(from.Row2));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -326,8 +447,17 @@ public static explicit operator Matrix2X4<uint>(Matrix2X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix2X4<ulong>(Matrix2X4<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>());
+            new(Vector4D<ulong>.CreateTruncating(from.Row1),
+                Vector4D<ulong>.CreateTruncating(from.Row2));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix2X4<ulong>(Matrix2X4<T> from) =>
+            new(Vector4D<ulong>.CreateChecked(from.Row1),
+                Vector4D<ulong>.CreateChecked(from.Row2));
     }
 
     public static partial class Matrix2X4
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index 2ec8ed1612..95bd53d619 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -116,15 +116,5 @@ public static explicit operator System.Numerics.Matrix3x2(Matrix3X2<T> from)
                 Scalar.As<T, float>(from.M21), Scalar.As<T, float>(from.M22),
                 Scalar.As<T, float>(from.M31), Scalar.As<T, float>(from.M32)
             );
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix3X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 3c03e4b538..3afe6bdefa 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -128,6 +128,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X2<T> CreateChecked<TOther>(Matrix3X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2), Vector2D<T>.CreateChecked(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X2<T> CreateSaturating<TOther>(Matrix3X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2), Vector2D<T>.CreateSaturating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X2<T> CreateTruncating<TOther>(Matrix3X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2), Vector2D<T>.CreateTruncating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix3X2<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X3<T> Transpose() =>
             new(new(M11, M21, M31),
@@ -209,15 +230,26 @@ public Matrix2X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2,
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>());
+            new(Vector2D<Half>.CreateTruncating(from.Row1),
+                Vector2D<Half>.CreateTruncating(from.Row2),
+                Vector2D<Half>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<Half>(Matrix3X2<T> from) =>
+            new(Vector2D<Half>.CreateChecked(from.Row1),
+                Vector2D<Half>.CreateChecked(from.Row2),
+                Vector2D<Half>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -225,9 +257,19 @@ public static explicit operator Matrix3X2<Half>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X2<float>(Matrix3X2<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>());
+            new(Vector2D<float>.CreateTruncating(from.Row1),
+                Vector2D<float>.CreateTruncating(from.Row2),
+                Vector2D<float>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<float>(Matrix3X2<T> from) =>
+            new(Vector2D<float>.CreateChecked(from.Row1),
+                Vector2D<float>.CreateChecked(from.Row2),
+                Vector2D<float>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -235,9 +277,19 @@ public static explicit operator Matrix3X2<float>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X2<double>(Matrix3X2<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>());
+            new(Vector2D<double>.CreateTruncating(from.Row1),
+                Vector2D<double>.CreateTruncating(from.Row2),
+                Vector2D<double>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<double>(Matrix3X2<T> from) =>
+            new(Vector2D<double>.CreateChecked(from.Row1),
+                Vector2D<double>.CreateChecked(from.Row2),
+                Vector2D<double>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -245,9 +297,19 @@ public static explicit operator Matrix3X2<double>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>());
+            new(Vector2D<decimal>.CreateTruncating(from.Row1),
+                Vector2D<decimal>.CreateTruncating(from.Row2),
+                Vector2D<decimal>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<decimal>(Matrix3X2<T> from) =>
+            new(Vector2D<decimal>.CreateChecked(from.Row1),
+                Vector2D<decimal>.CreateChecked(from.Row2),
+                Vector2D<decimal>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -255,9 +317,19 @@ public static explicit operator Matrix3X2<decimal>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>());
+            new(Vector2D<byte>.CreateTruncating(from.Row1),
+                Vector2D<byte>.CreateTruncating(from.Row2),
+                Vector2D<byte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<byte>(Matrix3X2<T> from) =>
+            new(Vector2D<byte>.CreateChecked(from.Row1),
+                Vector2D<byte>.CreateChecked(from.Row2),
+                Vector2D<byte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -265,9 +337,19 @@ public static explicit operator Matrix3X2<byte>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X2<short>(Matrix3X2<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>());
+            new(Vector2D<short>.CreateTruncating(from.Row1),
+                Vector2D<short>.CreateTruncating(from.Row2),
+                Vector2D<short>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<short>(Matrix3X2<T> from) =>
+            new(Vector2D<short>.CreateChecked(from.Row1),
+                Vector2D<short>.CreateChecked(from.Row2),
+                Vector2D<short>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -275,9 +357,19 @@ public static explicit operator Matrix3X2<short>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X2<int>(Matrix3X2<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>());
+            new(Vector2D<int>.CreateTruncating(from.Row1),
+                Vector2D<int>.CreateTruncating(from.Row2),
+                Vector2D<int>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<int>(Matrix3X2<T> from) =>
+            new(Vector2D<int>.CreateChecked(from.Row1),
+                Vector2D<int>.CreateChecked(from.Row2),
+                Vector2D<int>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -285,9 +377,19 @@ public static explicit operator Matrix3X2<int>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X2<long>(Matrix3X2<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>());
+            new(Vector2D<long>.CreateTruncating(from.Row1),
+                Vector2D<long>.CreateTruncating(from.Row2),
+                Vector2D<long>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<long>(Matrix3X2<T> from) =>
+            new(Vector2D<long>.CreateChecked(from.Row1),
+                Vector2D<long>.CreateChecked(from.Row2),
+                Vector2D<long>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -295,9 +397,19 @@ public static explicit operator Matrix3X2<long>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>());
+            new(Vector2D<sbyte>.CreateTruncating(from.Row1),
+                Vector2D<sbyte>.CreateTruncating(from.Row2),
+                Vector2D<sbyte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<sbyte>(Matrix3X2<T> from) =>
+            new(Vector2D<sbyte>.CreateChecked(from.Row1),
+                Vector2D<sbyte>.CreateChecked(from.Row2),
+                Vector2D<sbyte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -305,9 +417,19 @@ public static explicit operator Matrix3X2<sbyte>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>());
+            new(Vector2D<ushort>.CreateTruncating(from.Row1),
+                Vector2D<ushort>.CreateTruncating(from.Row2),
+                Vector2D<ushort>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<ushort>(Matrix3X2<T> from) =>
+            new(Vector2D<ushort>.CreateChecked(from.Row1),
+                Vector2D<ushort>.CreateChecked(from.Row2),
+                Vector2D<ushort>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -315,9 +437,19 @@ public static explicit operator Matrix3X2<ushort>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>());
+            new(Vector2D<uint>.CreateTruncating(from.Row1),
+                Vector2D<uint>.CreateTruncating(from.Row2),
+                Vector2D<uint>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<uint>(Matrix3X2<T> from) =>
+            new(Vector2D<uint>.CreateChecked(from.Row1),
+                Vector2D<uint>.CreateChecked(from.Row2),
+                Vector2D<uint>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -325,9 +457,19 @@ public static explicit operator Matrix3X2<uint>(Matrix3X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X2<ulong>(Matrix3X2<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>());
+            new(Vector2D<ulong>.CreateTruncating(from.Row1),
+                Vector2D<ulong>.CreateTruncating(from.Row2),
+                Vector2D<ulong>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix3X2<ulong>(Matrix3X2<T> from) =>
+            new(Vector2D<ulong>.CreateChecked(from.Row1),
+                Vector2D<ulong>.CreateChecked(from.Row2),
+                Vector2D<ulong>.CreateChecked(from.Row3));
     }
 
     public static partial class Matrix3X2
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index 69e0db0bd1..27cf5a9bf6 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -113,15 +113,5 @@ public readonly T GetDeterminant()
                     Scalar.Multiply(b, Scalar.Subtract(Scalar.Multiply(d, i), Scalar.Multiply(f, g)))),
                 Scalar.Multiply(c, Scalar.Subtract(Scalar.Multiply(d, h), Scalar.Multiply(e, g))));
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix3X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index 6466c089d6..4b039ee5b5 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -153,6 +153,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X3<T> CreateChecked<TOther>(Matrix3X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2), Vector3D<T>.CreateChecked(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X3<T> CreateSaturating<TOther>(Matrix3X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2), Vector3D<T>.CreateSaturating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X3<T> CreateTruncating<TOther>(Matrix3X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2), Vector3D<T>.CreateTruncating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix3X3<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X3<T> Transpose() =>
             new(new(M11, M21, M31),
@@ -243,15 +264,26 @@ public Matrix3X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>());
+            new(Vector3D<Half>.CreateTruncating(from.Row1),
+                Vector3D<Half>.CreateTruncating(from.Row2),
+                Vector3D<Half>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<Half>(Matrix3X3<T> from) =>
+            new(Vector3D<Half>.CreateChecked(from.Row1),
+                Vector3D<Half>.CreateChecked(from.Row2),
+                Vector3D<Half>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -259,9 +291,19 @@ public static explicit operator Matrix3X3<Half>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X3<float>(Matrix3X3<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>());
+            new(Vector3D<float>.CreateTruncating(from.Row1),
+                Vector3D<float>.CreateTruncating(from.Row2),
+                Vector3D<float>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<float>(Matrix3X3<T> from) =>
+            new(Vector3D<float>.CreateChecked(from.Row1),
+                Vector3D<float>.CreateChecked(from.Row2),
+                Vector3D<float>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -269,9 +311,19 @@ public static explicit operator Matrix3X3<float>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X3<double>(Matrix3X3<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>());
+            new(Vector3D<double>.CreateTruncating(from.Row1),
+                Vector3D<double>.CreateTruncating(from.Row2),
+                Vector3D<double>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<double>(Matrix3X3<T> from) =>
+            new(Vector3D<double>.CreateChecked(from.Row1),
+                Vector3D<double>.CreateChecked(from.Row2),
+                Vector3D<double>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -279,9 +331,19 @@ public static explicit operator Matrix3X3<double>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>());
+            new(Vector3D<decimal>.CreateTruncating(from.Row1),
+                Vector3D<decimal>.CreateTruncating(from.Row2),
+                Vector3D<decimal>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<decimal>(Matrix3X3<T> from) =>
+            new(Vector3D<decimal>.CreateChecked(from.Row1),
+                Vector3D<decimal>.CreateChecked(from.Row2),
+                Vector3D<decimal>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -289,9 +351,19 @@ public static explicit operator Matrix3X3<decimal>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>());
+            new(Vector3D<byte>.CreateTruncating(from.Row1),
+                Vector3D<byte>.CreateTruncating(from.Row2),
+                Vector3D<byte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<byte>(Matrix3X3<T> from) =>
+            new(Vector3D<byte>.CreateChecked(from.Row1),
+                Vector3D<byte>.CreateChecked(from.Row2),
+                Vector3D<byte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -299,9 +371,19 @@ public static explicit operator Matrix3X3<byte>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X3<short>(Matrix3X3<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>());
+            new(Vector3D<short>.CreateTruncating(from.Row1),
+                Vector3D<short>.CreateTruncating(from.Row2),
+                Vector3D<short>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<short>(Matrix3X3<T> from) =>
+            new(Vector3D<short>.CreateChecked(from.Row1),
+                Vector3D<short>.CreateChecked(from.Row2),
+                Vector3D<short>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -309,9 +391,19 @@ public static explicit operator Matrix3X3<short>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X3<int>(Matrix3X3<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>());
+            new(Vector3D<int>.CreateTruncating(from.Row1),
+                Vector3D<int>.CreateTruncating(from.Row2),
+                Vector3D<int>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<int>(Matrix3X3<T> from) =>
+            new(Vector3D<int>.CreateChecked(from.Row1),
+                Vector3D<int>.CreateChecked(from.Row2),
+                Vector3D<int>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -319,9 +411,19 @@ public static explicit operator Matrix3X3<int>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X3<long>(Matrix3X3<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>());
+            new(Vector3D<long>.CreateTruncating(from.Row1),
+                Vector3D<long>.CreateTruncating(from.Row2),
+                Vector3D<long>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<long>(Matrix3X3<T> from) =>
+            new(Vector3D<long>.CreateChecked(from.Row1),
+                Vector3D<long>.CreateChecked(from.Row2),
+                Vector3D<long>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -329,9 +431,19 @@ public static explicit operator Matrix3X3<long>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>());
+            new(Vector3D<sbyte>.CreateTruncating(from.Row1),
+                Vector3D<sbyte>.CreateTruncating(from.Row2),
+                Vector3D<sbyte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<sbyte>(Matrix3X3<T> from) =>
+            new(Vector3D<sbyte>.CreateChecked(from.Row1),
+                Vector3D<sbyte>.CreateChecked(from.Row2),
+                Vector3D<sbyte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -339,9 +451,19 @@ public static explicit operator Matrix3X3<sbyte>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>());
+            new(Vector3D<ushort>.CreateTruncating(from.Row1),
+                Vector3D<ushort>.CreateTruncating(from.Row2),
+                Vector3D<ushort>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<ushort>(Matrix3X3<T> from) =>
+            new(Vector3D<ushort>.CreateChecked(from.Row1),
+                Vector3D<ushort>.CreateChecked(from.Row2),
+                Vector3D<ushort>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -349,9 +471,19 @@ public static explicit operator Matrix3X3<ushort>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>());
+            new(Vector3D<uint>.CreateTruncating(from.Row1),
+                Vector3D<uint>.CreateTruncating(from.Row2),
+                Vector3D<uint>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<uint>(Matrix3X3<T> from) =>
+            new(Vector3D<uint>.CreateChecked(from.Row1),
+                Vector3D<uint>.CreateChecked(from.Row2),
+                Vector3D<uint>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -359,9 +491,19 @@ public static explicit operator Matrix3X3<uint>(Matrix3X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X3<ulong>(Matrix3X3<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>());
+            new(Vector3D<ulong>.CreateTruncating(from.Row1),
+                Vector3D<ulong>.CreateTruncating(from.Row2),
+                Vector3D<ulong>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix3X3<ulong>(Matrix3X3<T> from) =>
+            new(Vector3D<ulong>.CreateChecked(from.Row1),
+                Vector3D<ulong>.CreateChecked(from.Row2),
+                Vector3D<ulong>.CreateChecked(from.Row3));
     }
 
     public static partial class Matrix3X3
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index b84ae7b298..ed6c1c1193 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -97,15 +97,5 @@ public readonly bool IsIdentity
         {
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix3X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index ce53d29ad9..640fe89ad4 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -166,6 +166,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X4<T> CreateChecked<TOther>(Matrix3X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X4<T> CreateSaturating<TOther>(Matrix3X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix3X4<T> CreateTruncating<TOther>(Matrix3X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix3X4<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X3<T> Transpose() =>
             new(new(M11, M21, M31),
@@ -266,15 +287,26 @@ public Matrix4X3<T> Transpose() =>
             new(left.M11 * right.Row1 + left.M12 * right.Row2 + left.M13 * right.Row3 + left.M14 * right.Row4,
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>());
+            new(Vector4D<Half>.CreateTruncating(from.Row1),
+                Vector4D<Half>.CreateTruncating(from.Row2),
+                Vector4D<Half>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<Half>(Matrix3X4<T> from) =>
+            new(Vector4D<Half>.CreateChecked(from.Row1),
+                Vector4D<Half>.CreateChecked(from.Row2),
+                Vector4D<Half>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -282,9 +314,19 @@ public static explicit operator Matrix3X4<Half>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix3X4<float>(Matrix3X4<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>());
+            new(Vector4D<float>.CreateTruncating(from.Row1),
+                Vector4D<float>.CreateTruncating(from.Row2),
+                Vector4D<float>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<float>(Matrix3X4<T> from) =>
+            new(Vector4D<float>.CreateChecked(from.Row1),
+                Vector4D<float>.CreateChecked(from.Row2),
+                Vector4D<float>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -292,9 +334,19 @@ public static explicit operator Matrix3X4<float>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix3X4<double>(Matrix3X4<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>());
+            new(Vector4D<double>.CreateTruncating(from.Row1),
+                Vector4D<double>.CreateTruncating(from.Row2),
+                Vector4D<double>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<double>(Matrix3X4<T> from) =>
+            new(Vector4D<double>.CreateChecked(from.Row1),
+                Vector4D<double>.CreateChecked(from.Row2),
+                Vector4D<double>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -302,9 +354,19 @@ public static explicit operator Matrix3X4<double>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>());
+            new(Vector4D<decimal>.CreateTruncating(from.Row1),
+                Vector4D<decimal>.CreateTruncating(from.Row2),
+                Vector4D<decimal>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<decimal>(Matrix3X4<T> from) =>
+            new(Vector4D<decimal>.CreateChecked(from.Row1),
+                Vector4D<decimal>.CreateChecked(from.Row2),
+                Vector4D<decimal>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -312,9 +374,19 @@ public static explicit operator Matrix3X4<decimal>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>());
+            new(Vector4D<byte>.CreateTruncating(from.Row1),
+                Vector4D<byte>.CreateTruncating(from.Row2),
+                Vector4D<byte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<byte>(Matrix3X4<T> from) =>
+            new(Vector4D<byte>.CreateChecked(from.Row1),
+                Vector4D<byte>.CreateChecked(from.Row2),
+                Vector4D<byte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -322,9 +394,19 @@ public static explicit operator Matrix3X4<byte>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix3X4<short>(Matrix3X4<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>());
+            new(Vector4D<short>.CreateTruncating(from.Row1),
+                Vector4D<short>.CreateTruncating(from.Row2),
+                Vector4D<short>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<short>(Matrix3X4<T> from) =>
+            new(Vector4D<short>.CreateChecked(from.Row1),
+                Vector4D<short>.CreateChecked(from.Row2),
+                Vector4D<short>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -332,9 +414,19 @@ public static explicit operator Matrix3X4<short>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix3X4<int>(Matrix3X4<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>());
+            new(Vector4D<int>.CreateTruncating(from.Row1),
+                Vector4D<int>.CreateTruncating(from.Row2),
+                Vector4D<int>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<int>(Matrix3X4<T> from) =>
+            new(Vector4D<int>.CreateChecked(from.Row1),
+                Vector4D<int>.CreateChecked(from.Row2),
+                Vector4D<int>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -342,9 +434,19 @@ public static explicit operator Matrix3X4<int>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix3X4<long>(Matrix3X4<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>());
+            new(Vector4D<long>.CreateTruncating(from.Row1),
+                Vector4D<long>.CreateTruncating(from.Row2),
+                Vector4D<long>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<long>(Matrix3X4<T> from) =>
+            new(Vector4D<long>.CreateChecked(from.Row1),
+                Vector4D<long>.CreateChecked(from.Row2),
+                Vector4D<long>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -352,9 +454,19 @@ public static explicit operator Matrix3X4<long>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>());
+            new(Vector4D<sbyte>.CreateTruncating(from.Row1),
+                Vector4D<sbyte>.CreateTruncating(from.Row2),
+                Vector4D<sbyte>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<sbyte>(Matrix3X4<T> from) =>
+            new(Vector4D<sbyte>.CreateChecked(from.Row1),
+                Vector4D<sbyte>.CreateChecked(from.Row2),
+                Vector4D<sbyte>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -362,9 +474,19 @@ public static explicit operator Matrix3X4<sbyte>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>());
+            new(Vector4D<ushort>.CreateTruncating(from.Row1),
+                Vector4D<ushort>.CreateTruncating(from.Row2),
+                Vector4D<ushort>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<ushort>(Matrix3X4<T> from) =>
+            new(Vector4D<ushort>.CreateChecked(from.Row1),
+                Vector4D<ushort>.CreateChecked(from.Row2),
+                Vector4D<ushort>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -372,9 +494,19 @@ public static explicit operator Matrix3X4<ushort>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>());
+            new(Vector4D<uint>.CreateTruncating(from.Row1),
+                Vector4D<uint>.CreateTruncating(from.Row2),
+                Vector4D<uint>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<uint>(Matrix3X4<T> from) =>
+            new(Vector4D<uint>.CreateChecked(from.Row1),
+                Vector4D<uint>.CreateChecked(from.Row2),
+                Vector4D<uint>.CreateChecked(from.Row3));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -382,9 +514,19 @@ public static explicit operator Matrix3X4<uint>(Matrix3X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix3X4<ulong>(Matrix3X4<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>());
+            new(Vector4D<ulong>.CreateTruncating(from.Row1),
+                Vector4D<ulong>.CreateTruncating(from.Row2),
+                Vector4D<ulong>.CreateTruncating(from.Row3));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix3X4<ulong>(Matrix3X4<T> from) =>
+            new(Vector4D<ulong>.CreateChecked(from.Row1),
+                Vector4D<ulong>.CreateChecked(from.Row2),
+                Vector4D<ulong>.CreateChecked(from.Row3));
     }
 
     public static partial class Matrix3X4
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index 606ca14133..32aa778cd5 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -93,15 +93,5 @@ public readonly bool IsIdentity
         {
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix4X2<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index 0cda66d434..2cad4a3085 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -147,6 +147,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X2<T> CreateChecked<TOther>(Matrix4X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2), Vector2D<T>.CreateChecked(other.Row3), Vector2D<T>.CreateChecked(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X2<T> CreateSaturating<TOther>(Matrix4X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2), Vector2D<T>.CreateSaturating(other.Row3), Vector2D<T>.CreateSaturating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X2<T> CreateTruncating<TOther>(Matrix4X2<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2), Vector2D<T>.CreateTruncating(other.Row3), Vector2D<T>.CreateTruncating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix4X2<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
@@ -246,16 +267,28 @@ public Matrix2X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2,
                 left.M31 * right.Row1 + left.M32 * right.Row2,
                 left.M41 * right.Row1 + left.M42 * right.Row2);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>(),
-                from.Row4.As<Half>());
+            new(Vector2D<Half>.CreateTruncating(from.Row1),
+                Vector2D<Half>.CreateTruncating(from.Row2),
+                Vector2D<Half>.CreateTruncating(from.Row3),
+                Vector2D<Half>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<Half>(Matrix4X2<T> from) =>
+            new(Vector2D<Half>.CreateChecked(from.Row1),
+                Vector2D<Half>.CreateChecked(from.Row2),
+                Vector2D<Half>.CreateChecked(from.Row3),
+                Vector2D<Half>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -263,10 +296,21 @@ public static explicit operator Matrix4X2<Half>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X2<float>(Matrix4X2<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>(),
-                from.Row4.As<float>());
+            new(Vector2D<float>.CreateTruncating(from.Row1),
+                Vector2D<float>.CreateTruncating(from.Row2),
+                Vector2D<float>.CreateTruncating(from.Row3),
+                Vector2D<float>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<float>(Matrix4X2<T> from) =>
+            new(Vector2D<float>.CreateChecked(from.Row1),
+                Vector2D<float>.CreateChecked(from.Row2),
+                Vector2D<float>.CreateChecked(from.Row3),
+                Vector2D<float>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -274,10 +318,21 @@ public static explicit operator Matrix4X2<float>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X2<double>(Matrix4X2<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>(),
-                from.Row4.As<double>());
+            new(Vector2D<double>.CreateTruncating(from.Row1),
+                Vector2D<double>.CreateTruncating(from.Row2),
+                Vector2D<double>.CreateTruncating(from.Row3),
+                Vector2D<double>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<double>(Matrix4X2<T> from) =>
+            new(Vector2D<double>.CreateChecked(from.Row1),
+                Vector2D<double>.CreateChecked(from.Row2),
+                Vector2D<double>.CreateChecked(from.Row3),
+                Vector2D<double>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -285,10 +340,21 @@ public static explicit operator Matrix4X2<double>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>(),
-                from.Row4.As<decimal>());
+            new(Vector2D<decimal>.CreateTruncating(from.Row1),
+                Vector2D<decimal>.CreateTruncating(from.Row2),
+                Vector2D<decimal>.CreateTruncating(from.Row3),
+                Vector2D<decimal>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<decimal>(Matrix4X2<T> from) =>
+            new(Vector2D<decimal>.CreateChecked(from.Row1),
+                Vector2D<decimal>.CreateChecked(from.Row2),
+                Vector2D<decimal>.CreateChecked(from.Row3),
+                Vector2D<decimal>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -296,10 +362,21 @@ public static explicit operator Matrix4X2<decimal>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>(),
-                from.Row4.As<byte>());
+            new(Vector2D<byte>.CreateTruncating(from.Row1),
+                Vector2D<byte>.CreateTruncating(from.Row2),
+                Vector2D<byte>.CreateTruncating(from.Row3),
+                Vector2D<byte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<byte>(Matrix4X2<T> from) =>
+            new(Vector2D<byte>.CreateChecked(from.Row1),
+                Vector2D<byte>.CreateChecked(from.Row2),
+                Vector2D<byte>.CreateChecked(from.Row3),
+                Vector2D<byte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -307,10 +384,21 @@ public static explicit operator Matrix4X2<byte>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X2<short>(Matrix4X2<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>(),
-                from.Row4.As<short>());
+            new(Vector2D<short>.CreateTruncating(from.Row1),
+                Vector2D<short>.CreateTruncating(from.Row2),
+                Vector2D<short>.CreateTruncating(from.Row3),
+                Vector2D<short>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<short>(Matrix4X2<T> from) =>
+            new(Vector2D<short>.CreateChecked(from.Row1),
+                Vector2D<short>.CreateChecked(from.Row2),
+                Vector2D<short>.CreateChecked(from.Row3),
+                Vector2D<short>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -318,10 +406,21 @@ public static explicit operator Matrix4X2<short>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X2<int>(Matrix4X2<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>(),
-                from.Row4.As<int>());
+            new(Vector2D<int>.CreateTruncating(from.Row1),
+                Vector2D<int>.CreateTruncating(from.Row2),
+                Vector2D<int>.CreateTruncating(from.Row3),
+                Vector2D<int>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<int>(Matrix4X2<T> from) =>
+            new(Vector2D<int>.CreateChecked(from.Row1),
+                Vector2D<int>.CreateChecked(from.Row2),
+                Vector2D<int>.CreateChecked(from.Row3),
+                Vector2D<int>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -329,10 +428,21 @@ public static explicit operator Matrix4X2<int>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X2<long>(Matrix4X2<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>(),
-                from.Row4.As<long>());
+            new(Vector2D<long>.CreateTruncating(from.Row1),
+                Vector2D<long>.CreateTruncating(from.Row2),
+                Vector2D<long>.CreateTruncating(from.Row3),
+                Vector2D<long>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<long>(Matrix4X2<T> from) =>
+            new(Vector2D<long>.CreateChecked(from.Row1),
+                Vector2D<long>.CreateChecked(from.Row2),
+                Vector2D<long>.CreateChecked(from.Row3),
+                Vector2D<long>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -340,10 +450,21 @@ public static explicit operator Matrix4X2<long>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>(),
-                from.Row4.As<sbyte>());
+            new(Vector2D<sbyte>.CreateTruncating(from.Row1),
+                Vector2D<sbyte>.CreateTruncating(from.Row2),
+                Vector2D<sbyte>.CreateTruncating(from.Row3),
+                Vector2D<sbyte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<sbyte>(Matrix4X2<T> from) =>
+            new(Vector2D<sbyte>.CreateChecked(from.Row1),
+                Vector2D<sbyte>.CreateChecked(from.Row2),
+                Vector2D<sbyte>.CreateChecked(from.Row3),
+                Vector2D<sbyte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -351,10 +472,21 @@ public static explicit operator Matrix4X2<sbyte>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>(),
-                from.Row4.As<ushort>());
+            new(Vector2D<ushort>.CreateTruncating(from.Row1),
+                Vector2D<ushort>.CreateTruncating(from.Row2),
+                Vector2D<ushort>.CreateTruncating(from.Row3),
+                Vector2D<ushort>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<ushort>(Matrix4X2<T> from) =>
+            new(Vector2D<ushort>.CreateChecked(from.Row1),
+                Vector2D<ushort>.CreateChecked(from.Row2),
+                Vector2D<ushort>.CreateChecked(from.Row3),
+                Vector2D<ushort>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -362,10 +494,21 @@ public static explicit operator Matrix4X2<ushort>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>(),
-                from.Row4.As<uint>());
+            new(Vector2D<uint>.CreateTruncating(from.Row1),
+                Vector2D<uint>.CreateTruncating(from.Row2),
+                Vector2D<uint>.CreateTruncating(from.Row3),
+                Vector2D<uint>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<uint>(Matrix4X2<T> from) =>
+            new(Vector2D<uint>.CreateChecked(from.Row1),
+                Vector2D<uint>.CreateChecked(from.Row2),
+                Vector2D<uint>.CreateChecked(from.Row3),
+                Vector2D<uint>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -373,10 +516,21 @@ public static explicit operator Matrix4X2<uint>(Matrix4X2<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X2<ulong>(Matrix4X2<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>(),
-                from.Row4.As<ulong>());
+            new(Vector2D<ulong>.CreateTruncating(from.Row1),
+                Vector2D<ulong>.CreateTruncating(from.Row2),
+                Vector2D<ulong>.CreateTruncating(from.Row3),
+                Vector2D<ulong>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix4X2<ulong>(Matrix4X2<T> from) =>
+            new(Vector2D<ulong>.CreateChecked(from.Row1),
+                Vector2D<ulong>.CreateChecked(from.Row2),
+                Vector2D<ulong>.CreateChecked(from.Row3),
+                Vector2D<ulong>.CreateChecked(from.Row4));
     }
 
     public static partial class Matrix4X2
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index 7e69e7d550..b6d740fcc5 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -116,15 +116,5 @@ public readonly bool IsIdentity
         {
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix4X3<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index f5d3add102..bb4c1216ff 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -171,6 +171,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X3<T> CreateChecked<TOther>(Matrix4X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2), Vector3D<T>.CreateChecked(other.Row3), Vector3D<T>.CreateChecked(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X3<T> CreateSaturating<TOther>(Matrix4X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2), Vector3D<T>.CreateSaturating(other.Row3), Vector3D<T>.CreateSaturating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X3<T> CreateTruncating<TOther>(Matrix4X3<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2), Vector3D<T>.CreateTruncating(other.Row3), Vector3D<T>.CreateTruncating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix4X3<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
@@ -279,16 +300,28 @@ public Matrix3X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>(),
-                from.Row4.As<Half>());
+            new(Vector3D<Half>.CreateTruncating(from.Row1),
+                Vector3D<Half>.CreateTruncating(from.Row2),
+                Vector3D<Half>.CreateTruncating(from.Row3),
+                Vector3D<Half>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<Half>(Matrix4X3<T> from) =>
+            new(Vector3D<Half>.CreateChecked(from.Row1),
+                Vector3D<Half>.CreateChecked(from.Row2),
+                Vector3D<Half>.CreateChecked(from.Row3),
+                Vector3D<Half>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -296,10 +329,21 @@ public static explicit operator Matrix4X3<Half>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X3<float>(Matrix4X3<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>(),
-                from.Row4.As<float>());
+            new(Vector3D<float>.CreateTruncating(from.Row1),
+                Vector3D<float>.CreateTruncating(from.Row2),
+                Vector3D<float>.CreateTruncating(from.Row3),
+                Vector3D<float>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<float>(Matrix4X3<T> from) =>
+            new(Vector3D<float>.CreateChecked(from.Row1),
+                Vector3D<float>.CreateChecked(from.Row2),
+                Vector3D<float>.CreateChecked(from.Row3),
+                Vector3D<float>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -307,10 +351,21 @@ public static explicit operator Matrix4X3<float>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X3<double>(Matrix4X3<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>(),
-                from.Row4.As<double>());
+            new(Vector3D<double>.CreateTruncating(from.Row1),
+                Vector3D<double>.CreateTruncating(from.Row2),
+                Vector3D<double>.CreateTruncating(from.Row3),
+                Vector3D<double>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<double>(Matrix4X3<T> from) =>
+            new(Vector3D<double>.CreateChecked(from.Row1),
+                Vector3D<double>.CreateChecked(from.Row2),
+                Vector3D<double>.CreateChecked(from.Row3),
+                Vector3D<double>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -318,10 +373,21 @@ public static explicit operator Matrix4X3<double>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>(),
-                from.Row4.As<decimal>());
+            new(Vector3D<decimal>.CreateTruncating(from.Row1),
+                Vector3D<decimal>.CreateTruncating(from.Row2),
+                Vector3D<decimal>.CreateTruncating(from.Row3),
+                Vector3D<decimal>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<decimal>(Matrix4X3<T> from) =>
+            new(Vector3D<decimal>.CreateChecked(from.Row1),
+                Vector3D<decimal>.CreateChecked(from.Row2),
+                Vector3D<decimal>.CreateChecked(from.Row3),
+                Vector3D<decimal>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -329,10 +395,21 @@ public static explicit operator Matrix4X3<decimal>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>(),
-                from.Row4.As<byte>());
+            new(Vector3D<byte>.CreateTruncating(from.Row1),
+                Vector3D<byte>.CreateTruncating(from.Row2),
+                Vector3D<byte>.CreateTruncating(from.Row3),
+                Vector3D<byte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<byte>(Matrix4X3<T> from) =>
+            new(Vector3D<byte>.CreateChecked(from.Row1),
+                Vector3D<byte>.CreateChecked(from.Row2),
+                Vector3D<byte>.CreateChecked(from.Row3),
+                Vector3D<byte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -340,10 +417,21 @@ public static explicit operator Matrix4X3<byte>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X3<short>(Matrix4X3<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>(),
-                from.Row4.As<short>());
+            new(Vector3D<short>.CreateTruncating(from.Row1),
+                Vector3D<short>.CreateTruncating(from.Row2),
+                Vector3D<short>.CreateTruncating(from.Row3),
+                Vector3D<short>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<short>(Matrix4X3<T> from) =>
+            new(Vector3D<short>.CreateChecked(from.Row1),
+                Vector3D<short>.CreateChecked(from.Row2),
+                Vector3D<short>.CreateChecked(from.Row3),
+                Vector3D<short>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -351,10 +439,21 @@ public static explicit operator Matrix4X3<short>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X3<int>(Matrix4X3<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>(),
-                from.Row4.As<int>());
+            new(Vector3D<int>.CreateTruncating(from.Row1),
+                Vector3D<int>.CreateTruncating(from.Row2),
+                Vector3D<int>.CreateTruncating(from.Row3),
+                Vector3D<int>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<int>(Matrix4X3<T> from) =>
+            new(Vector3D<int>.CreateChecked(from.Row1),
+                Vector3D<int>.CreateChecked(from.Row2),
+                Vector3D<int>.CreateChecked(from.Row3),
+                Vector3D<int>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -362,10 +461,21 @@ public static explicit operator Matrix4X3<int>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X3<long>(Matrix4X3<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>(),
-                from.Row4.As<long>());
+            new(Vector3D<long>.CreateTruncating(from.Row1),
+                Vector3D<long>.CreateTruncating(from.Row2),
+                Vector3D<long>.CreateTruncating(from.Row3),
+                Vector3D<long>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<long>(Matrix4X3<T> from) =>
+            new(Vector3D<long>.CreateChecked(from.Row1),
+                Vector3D<long>.CreateChecked(from.Row2),
+                Vector3D<long>.CreateChecked(from.Row3),
+                Vector3D<long>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -373,10 +483,21 @@ public static explicit operator Matrix4X3<long>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>(),
-                from.Row4.As<sbyte>());
+            new(Vector3D<sbyte>.CreateTruncating(from.Row1),
+                Vector3D<sbyte>.CreateTruncating(from.Row2),
+                Vector3D<sbyte>.CreateTruncating(from.Row3),
+                Vector3D<sbyte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<sbyte>(Matrix4X3<T> from) =>
+            new(Vector3D<sbyte>.CreateChecked(from.Row1),
+                Vector3D<sbyte>.CreateChecked(from.Row2),
+                Vector3D<sbyte>.CreateChecked(from.Row3),
+                Vector3D<sbyte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -384,10 +505,21 @@ public static explicit operator Matrix4X3<sbyte>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>(),
-                from.Row4.As<ushort>());
+            new(Vector3D<ushort>.CreateTruncating(from.Row1),
+                Vector3D<ushort>.CreateTruncating(from.Row2),
+                Vector3D<ushort>.CreateTruncating(from.Row3),
+                Vector3D<ushort>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<ushort>(Matrix4X3<T> from) =>
+            new(Vector3D<ushort>.CreateChecked(from.Row1),
+                Vector3D<ushort>.CreateChecked(from.Row2),
+                Vector3D<ushort>.CreateChecked(from.Row3),
+                Vector3D<ushort>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -395,10 +527,21 @@ public static explicit operator Matrix4X3<ushort>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>(),
-                from.Row4.As<uint>());
+            new(Vector3D<uint>.CreateTruncating(from.Row1),
+                Vector3D<uint>.CreateTruncating(from.Row2),
+                Vector3D<uint>.CreateTruncating(from.Row3),
+                Vector3D<uint>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<uint>(Matrix4X3<T> from) =>
+            new(Vector3D<uint>.CreateChecked(from.Row1),
+                Vector3D<uint>.CreateChecked(from.Row2),
+                Vector3D<uint>.CreateChecked(from.Row3),
+                Vector3D<uint>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -406,10 +549,21 @@ public static explicit operator Matrix4X3<uint>(Matrix4X3<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X3<ulong>(Matrix4X3<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>(),
-                from.Row4.As<ulong>());
+            new(Vector3D<ulong>.CreateTruncating(from.Row1),
+                Vector3D<ulong>.CreateTruncating(from.Row2),
+                Vector3D<ulong>.CreateTruncating(from.Row3),
+                Vector3D<ulong>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix4X3<ulong>(Matrix4X3<T> from) =>
+            new(Vector3D<ulong>.CreateChecked(from.Row1),
+                Vector3D<ulong>.CreateChecked(from.Row2),
+                Vector3D<ulong>.CreateChecked(from.Row3),
+                Vector3D<ulong>.CreateChecked(from.Row4));
     }
 
     public static partial class Matrix4X3
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index 2a5149bd5b..61118d8d30 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -160,15 +160,5 @@ public readonly T GetDeterminant()
                             Scalar.Subtract(Scalar.Multiply(e, jo_kn), Scalar.Multiply(f, io_km)),
                             Scalar.Multiply(g, in_jm)))));
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix4X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index c77c210af0..046b54feda 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -202,6 +202,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X4<T> CreateChecked<TOther>(Matrix4X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3), Vector4D<T>.CreateChecked(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X4<T> CreateSaturating<TOther>(Matrix4X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3), Vector4D<T>.CreateSaturating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix4X4<T> CreateTruncating<TOther>(Matrix4X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3), Vector4D<T>.CreateTruncating(other.Row4));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix4X4<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
@@ -320,16 +341,28 @@ public Matrix4X4<T> Transpose() =>
                 left.M21 * right.Row1 + left.M22 * right.Row2 + left.M23 * right.Row3 + left.M24 * right.Row4,
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>(),
-                from.Row4.As<Half>());
+            new(Vector4D<Half>.CreateTruncating(from.Row1),
+                Vector4D<Half>.CreateTruncating(from.Row2),
+                Vector4D<Half>.CreateTruncating(from.Row3),
+                Vector4D<Half>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<Half>(Matrix4X4<T> from) =>
+            new(Vector4D<Half>.CreateChecked(from.Row1),
+                Vector4D<Half>.CreateChecked(from.Row2),
+                Vector4D<Half>.CreateChecked(from.Row3),
+                Vector4D<Half>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -337,10 +370,21 @@ public static explicit operator Matrix4X4<Half>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix4X4<float>(Matrix4X4<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>(),
-                from.Row4.As<float>());
+            new(Vector4D<float>.CreateTruncating(from.Row1),
+                Vector4D<float>.CreateTruncating(from.Row2),
+                Vector4D<float>.CreateTruncating(from.Row3),
+                Vector4D<float>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<float>(Matrix4X4<T> from) =>
+            new(Vector4D<float>.CreateChecked(from.Row1),
+                Vector4D<float>.CreateChecked(from.Row2),
+                Vector4D<float>.CreateChecked(from.Row3),
+                Vector4D<float>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -348,10 +392,21 @@ public static explicit operator Matrix4X4<float>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix4X4<double>(Matrix4X4<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>(),
-                from.Row4.As<double>());
+            new(Vector4D<double>.CreateTruncating(from.Row1),
+                Vector4D<double>.CreateTruncating(from.Row2),
+                Vector4D<double>.CreateTruncating(from.Row3),
+                Vector4D<double>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<double>(Matrix4X4<T> from) =>
+            new(Vector4D<double>.CreateChecked(from.Row1),
+                Vector4D<double>.CreateChecked(from.Row2),
+                Vector4D<double>.CreateChecked(from.Row3),
+                Vector4D<double>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -359,10 +414,21 @@ public static explicit operator Matrix4X4<double>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>(),
-                from.Row4.As<decimal>());
+            new(Vector4D<decimal>.CreateTruncating(from.Row1),
+                Vector4D<decimal>.CreateTruncating(from.Row2),
+                Vector4D<decimal>.CreateTruncating(from.Row3),
+                Vector4D<decimal>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<decimal>(Matrix4X4<T> from) =>
+            new(Vector4D<decimal>.CreateChecked(from.Row1),
+                Vector4D<decimal>.CreateChecked(from.Row2),
+                Vector4D<decimal>.CreateChecked(from.Row3),
+                Vector4D<decimal>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -370,10 +436,21 @@ public static explicit operator Matrix4X4<decimal>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>(),
-                from.Row4.As<byte>());
+            new(Vector4D<byte>.CreateTruncating(from.Row1),
+                Vector4D<byte>.CreateTruncating(from.Row2),
+                Vector4D<byte>.CreateTruncating(from.Row3),
+                Vector4D<byte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<byte>(Matrix4X4<T> from) =>
+            new(Vector4D<byte>.CreateChecked(from.Row1),
+                Vector4D<byte>.CreateChecked(from.Row2),
+                Vector4D<byte>.CreateChecked(from.Row3),
+                Vector4D<byte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -381,10 +458,21 @@ public static explicit operator Matrix4X4<byte>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix4X4<short>(Matrix4X4<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>(),
-                from.Row4.As<short>());
+            new(Vector4D<short>.CreateTruncating(from.Row1),
+                Vector4D<short>.CreateTruncating(from.Row2),
+                Vector4D<short>.CreateTruncating(from.Row3),
+                Vector4D<short>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<short>(Matrix4X4<T> from) =>
+            new(Vector4D<short>.CreateChecked(from.Row1),
+                Vector4D<short>.CreateChecked(from.Row2),
+                Vector4D<short>.CreateChecked(from.Row3),
+                Vector4D<short>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -392,10 +480,21 @@ public static explicit operator Matrix4X4<short>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix4X4<int>(Matrix4X4<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>(),
-                from.Row4.As<int>());
+            new(Vector4D<int>.CreateTruncating(from.Row1),
+                Vector4D<int>.CreateTruncating(from.Row2),
+                Vector4D<int>.CreateTruncating(from.Row3),
+                Vector4D<int>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<int>(Matrix4X4<T> from) =>
+            new(Vector4D<int>.CreateChecked(from.Row1),
+                Vector4D<int>.CreateChecked(from.Row2),
+                Vector4D<int>.CreateChecked(from.Row3),
+                Vector4D<int>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -403,10 +502,21 @@ public static explicit operator Matrix4X4<int>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix4X4<long>(Matrix4X4<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>(),
-                from.Row4.As<long>());
+            new(Vector4D<long>.CreateTruncating(from.Row1),
+                Vector4D<long>.CreateTruncating(from.Row2),
+                Vector4D<long>.CreateTruncating(from.Row3),
+                Vector4D<long>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<long>(Matrix4X4<T> from) =>
+            new(Vector4D<long>.CreateChecked(from.Row1),
+                Vector4D<long>.CreateChecked(from.Row2),
+                Vector4D<long>.CreateChecked(from.Row3),
+                Vector4D<long>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -414,10 +524,21 @@ public static explicit operator Matrix4X4<long>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>(),
-                from.Row4.As<sbyte>());
+            new(Vector4D<sbyte>.CreateTruncating(from.Row1),
+                Vector4D<sbyte>.CreateTruncating(from.Row2),
+                Vector4D<sbyte>.CreateTruncating(from.Row3),
+                Vector4D<sbyte>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<sbyte>(Matrix4X4<T> from) =>
+            new(Vector4D<sbyte>.CreateChecked(from.Row1),
+                Vector4D<sbyte>.CreateChecked(from.Row2),
+                Vector4D<sbyte>.CreateChecked(from.Row3),
+                Vector4D<sbyte>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -425,10 +546,21 @@ public static explicit operator Matrix4X4<sbyte>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>(),
-                from.Row4.As<ushort>());
+            new(Vector4D<ushort>.CreateTruncating(from.Row1),
+                Vector4D<ushort>.CreateTruncating(from.Row2),
+                Vector4D<ushort>.CreateTruncating(from.Row3),
+                Vector4D<ushort>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<ushort>(Matrix4X4<T> from) =>
+            new(Vector4D<ushort>.CreateChecked(from.Row1),
+                Vector4D<ushort>.CreateChecked(from.Row2),
+                Vector4D<ushort>.CreateChecked(from.Row3),
+                Vector4D<ushort>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -436,10 +568,21 @@ public static explicit operator Matrix4X4<ushort>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>(),
-                from.Row4.As<uint>());
+            new(Vector4D<uint>.CreateTruncating(from.Row1),
+                Vector4D<uint>.CreateTruncating(from.Row2),
+                Vector4D<uint>.CreateTruncating(from.Row3),
+                Vector4D<uint>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<uint>(Matrix4X4<T> from) =>
+            new(Vector4D<uint>.CreateChecked(from.Row1),
+                Vector4D<uint>.CreateChecked(from.Row2),
+                Vector4D<uint>.CreateChecked(from.Row3),
+                Vector4D<uint>.CreateChecked(from.Row4));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -447,10 +590,21 @@ public static explicit operator Matrix4X4<uint>(Matrix4X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix4X4<ulong>(Matrix4X4<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>(),
-                from.Row4.As<ulong>());
+            new(Vector4D<ulong>.CreateTruncating(from.Row1),
+                Vector4D<ulong>.CreateTruncating(from.Row2),
+                Vector4D<ulong>.CreateTruncating(from.Row3),
+                Vector4D<ulong>.CreateTruncating(from.Row4));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix4X4<ulong>(Matrix4X4<T> from) =>
+            new(Vector4D<ulong>.CreateChecked(from.Row1),
+                Vector4D<ulong>.CreateChecked(from.Row2),
+                Vector4D<ulong>.CreateChecked(from.Row3),
+                Vector4D<ulong>.CreateChecked(from.Row4));
     }
 
     public static partial class Matrix4X4
diff --git a/sources/Maths/Maths/Matrix5X4.cs b/sources/Maths/Maths/Matrix5X4.cs
index 8f624e5b99..71ab1fd0eb 100644
--- a/sources/Maths/Maths/Matrix5X4.cs
+++ b/sources/Maths/Maths/Matrix5X4.cs
@@ -127,15 +127,5 @@ public readonly bool IsIdentity
             return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 +
                    value1.W * value2.Row4 + value2.Row5;
         }
-
-        /// <summary>
-        /// Returns this matrix casted to <typeparamref name="TOther"></typeparamref>
-        /// </summary>
-        /// <typeparam name="TOther">The type to cast to</typeparam>
-        /// <returns>The casted matrix</returns>
-        public Matrix5X4<TOther> As<TOther>() where TOther : INumberBase<TOther>
-        {
-            return new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>(), Row5.As<TOther>());
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index 91ae1f4986..a294471477 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -208,6 +208,27 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix5X4<T> CreateChecked<TOther>(Matrix5X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3), Vector4D<T>.CreateChecked(other.Row4), Vector4D<T>.CreateChecked(other.Row5));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix5X4<T> CreateSaturating<TOther>(Matrix5X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3), Vector4D<T>.CreateSaturating(other.Row4), Vector4D<T>.CreateSaturating(other.Row5));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Matrix5X4<T> CreateTruncating<TOther>(Matrix5X4<TOther> other)
+            where TOther : INumberBase<TOther> =>
+            new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3), Vector4D<T>.CreateTruncating(other.Row4), Vector4D<T>.CreateTruncating(other.Row5));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        public Matrix5X4<TOther> As<TOther>()
+            where TOther : INumberBase<TOther> =>
+            new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>(), Row5.As<TOther>());
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
@@ -289,17 +310,30 @@ public override string ToString() =>
                 left.M31 * right.Row1 + left.M32 * right.Row2 + left.M33 * right.Row3 + left.M34 * right.Row4,
                 left.M41 * right.Row1 + left.M42 * right.Row2 + left.M43 * right.Row3 + left.M44 * right.Row4,
                 left.M51 * right.Row1 + left.M52 * right.Row2 + left.M53 * right.Row3 + left.M54 * right.Row4);
+
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
         /// </summary>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="Half"/> matrix.</returns>
         public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from) =>
-            new(from.Row1.As<Half>(),
-                from.Row2.As<Half>(),
-                from.Row3.As<Half>(),
-                from.Row4.As<Half>(),
-                from.Row5.As<Half>());
+            new(Vector4D<Half>.CreateTruncating(from.Row1),
+                Vector4D<Half>.CreateTruncating(from.Row2),
+                Vector4D<Half>.CreateTruncating(from.Row3),
+                Vector4D<Half>.CreateTruncating(from.Row4),
+                Vector4D<Half>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="Half"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<Half>(Matrix5X4<T> from) =>
+            new(Vector4D<Half>.CreateChecked(from.Row1),
+                Vector4D<Half>.CreateChecked(from.Row2),
+                Vector4D<Half>.CreateChecked(from.Row3),
+                Vector4D<Half>.CreateChecked(from.Row4),
+                Vector4D<Half>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -307,11 +341,23 @@ public static explicit operator Matrix5X4<Half>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="float"/> matrix.</returns>
         public static explicit operator Matrix5X4<float>(Matrix5X4<T> from) =>
-            new(from.Row1.As<float>(),
-                from.Row2.As<float>(),
-                from.Row3.As<float>(),
-                from.Row4.As<float>(),
-                from.Row5.As<float>());
+            new(Vector4D<float>.CreateTruncating(from.Row1),
+                Vector4D<float>.CreateTruncating(from.Row2),
+                Vector4D<float>.CreateTruncating(from.Row3),
+                Vector4D<float>.CreateTruncating(from.Row4),
+                Vector4D<float>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="float"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<float>(Matrix5X4<T> from) =>
+            new(Vector4D<float>.CreateChecked(from.Row1),
+                Vector4D<float>.CreateChecked(from.Row2),
+                Vector4D<float>.CreateChecked(from.Row3),
+                Vector4D<float>.CreateChecked(from.Row4),
+                Vector4D<float>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -319,11 +365,23 @@ public static explicit operator Matrix5X4<float>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="double"/> matrix.</returns>
         public static explicit operator Matrix5X4<double>(Matrix5X4<T> from) =>
-            new(from.Row1.As<double>(),
-                from.Row2.As<double>(),
-                from.Row3.As<double>(),
-                from.Row4.As<double>(),
-                from.Row5.As<double>());
+            new(Vector4D<double>.CreateTruncating(from.Row1),
+                Vector4D<double>.CreateTruncating(from.Row2),
+                Vector4D<double>.CreateTruncating(from.Row3),
+                Vector4D<double>.CreateTruncating(from.Row4),
+                Vector4D<double>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="double"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<double>(Matrix5X4<T> from) =>
+            new(Vector4D<double>.CreateChecked(from.Row1),
+                Vector4D<double>.CreateChecked(from.Row2),
+                Vector4D<double>.CreateChecked(from.Row3),
+                Vector4D<double>.CreateChecked(from.Row4),
+                Vector4D<double>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -331,11 +389,23 @@ public static explicit operator Matrix5X4<double>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="decimal"/> matrix.</returns>
         public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from) =>
-            new(from.Row1.As<decimal>(),
-                from.Row2.As<decimal>(),
-                from.Row3.As<decimal>(),
-                from.Row4.As<decimal>(),
-                from.Row5.As<decimal>());
+            new(Vector4D<decimal>.CreateTruncating(from.Row1),
+                Vector4D<decimal>.CreateTruncating(from.Row2),
+                Vector4D<decimal>.CreateTruncating(from.Row3),
+                Vector4D<decimal>.CreateTruncating(from.Row4),
+                Vector4D<decimal>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="decimal"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<decimal>(Matrix5X4<T> from) =>
+            new(Vector4D<decimal>.CreateChecked(from.Row1),
+                Vector4D<decimal>.CreateChecked(from.Row2),
+                Vector4D<decimal>.CreateChecked(from.Row3),
+                Vector4D<decimal>.CreateChecked(from.Row4),
+                Vector4D<decimal>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -343,11 +413,23 @@ public static explicit operator Matrix5X4<decimal>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="byte"/> matrix.</returns>
         public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from) =>
-            new(from.Row1.As<byte>(),
-                from.Row2.As<byte>(),
-                from.Row3.As<byte>(),
-                from.Row4.As<byte>(),
-                from.Row5.As<byte>());
+            new(Vector4D<byte>.CreateTruncating(from.Row1),
+                Vector4D<byte>.CreateTruncating(from.Row2),
+                Vector4D<byte>.CreateTruncating(from.Row3),
+                Vector4D<byte>.CreateTruncating(from.Row4),
+                Vector4D<byte>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="byte"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<byte>(Matrix5X4<T> from) =>
+            new(Vector4D<byte>.CreateChecked(from.Row1),
+                Vector4D<byte>.CreateChecked(from.Row2),
+                Vector4D<byte>.CreateChecked(from.Row3),
+                Vector4D<byte>.CreateChecked(from.Row4),
+                Vector4D<byte>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -355,11 +437,23 @@ public static explicit operator Matrix5X4<byte>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="short"/> matrix.</returns>
         public static explicit operator Matrix5X4<short>(Matrix5X4<T> from) =>
-            new(from.Row1.As<short>(),
-                from.Row2.As<short>(),
-                from.Row3.As<short>(),
-                from.Row4.As<short>(),
-                from.Row5.As<short>());
+            new(Vector4D<short>.CreateTruncating(from.Row1),
+                Vector4D<short>.CreateTruncating(from.Row2),
+                Vector4D<short>.CreateTruncating(from.Row3),
+                Vector4D<short>.CreateTruncating(from.Row4),
+                Vector4D<short>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="short"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<short>(Matrix5X4<T> from) =>
+            new(Vector4D<short>.CreateChecked(from.Row1),
+                Vector4D<short>.CreateChecked(from.Row2),
+                Vector4D<short>.CreateChecked(from.Row3),
+                Vector4D<short>.CreateChecked(from.Row4),
+                Vector4D<short>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -367,11 +461,23 @@ public static explicit operator Matrix5X4<short>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="int"/> matrix.</returns>
         public static explicit operator Matrix5X4<int>(Matrix5X4<T> from) =>
-            new(from.Row1.As<int>(),
-                from.Row2.As<int>(),
-                from.Row3.As<int>(),
-                from.Row4.As<int>(),
-                from.Row5.As<int>());
+            new(Vector4D<int>.CreateTruncating(from.Row1),
+                Vector4D<int>.CreateTruncating(from.Row2),
+                Vector4D<int>.CreateTruncating(from.Row3),
+                Vector4D<int>.CreateTruncating(from.Row4),
+                Vector4D<int>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="int"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<int>(Matrix5X4<T> from) =>
+            new(Vector4D<int>.CreateChecked(from.Row1),
+                Vector4D<int>.CreateChecked(from.Row2),
+                Vector4D<int>.CreateChecked(from.Row3),
+                Vector4D<int>.CreateChecked(from.Row4),
+                Vector4D<int>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -379,11 +485,23 @@ public static explicit operator Matrix5X4<int>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="long"/> matrix.</returns>
         public static explicit operator Matrix5X4<long>(Matrix5X4<T> from) =>
-            new(from.Row1.As<long>(),
-                from.Row2.As<long>(),
-                from.Row3.As<long>(),
-                from.Row4.As<long>(),
-                from.Row5.As<long>());
+            new(Vector4D<long>.CreateTruncating(from.Row1),
+                Vector4D<long>.CreateTruncating(from.Row2),
+                Vector4D<long>.CreateTruncating(from.Row3),
+                Vector4D<long>.CreateTruncating(from.Row4),
+                Vector4D<long>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="long"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<long>(Matrix5X4<T> from) =>
+            new(Vector4D<long>.CreateChecked(from.Row1),
+                Vector4D<long>.CreateChecked(from.Row2),
+                Vector4D<long>.CreateChecked(from.Row3),
+                Vector4D<long>.CreateChecked(from.Row4),
+                Vector4D<long>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -391,11 +509,23 @@ public static explicit operator Matrix5X4<long>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="sbyte"/> matrix.</returns>
         public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from) =>
-            new(from.Row1.As<sbyte>(),
-                from.Row2.As<sbyte>(),
-                from.Row3.As<sbyte>(),
-                from.Row4.As<sbyte>(),
-                from.Row5.As<sbyte>());
+            new(Vector4D<sbyte>.CreateTruncating(from.Row1),
+                Vector4D<sbyte>.CreateTruncating(from.Row2),
+                Vector4D<sbyte>.CreateTruncating(from.Row3),
+                Vector4D<sbyte>.CreateTruncating(from.Row4),
+                Vector4D<sbyte>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="sbyte"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<sbyte>(Matrix5X4<T> from) =>
+            new(Vector4D<sbyte>.CreateChecked(from.Row1),
+                Vector4D<sbyte>.CreateChecked(from.Row2),
+                Vector4D<sbyte>.CreateChecked(from.Row3),
+                Vector4D<sbyte>.CreateChecked(from.Row4),
+                Vector4D<sbyte>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -403,11 +533,23 @@ public static explicit operator Matrix5X4<sbyte>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ushort"/> matrix.</returns>
         public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from) =>
-            new(from.Row1.As<ushort>(),
-                from.Row2.As<ushort>(),
-                from.Row3.As<ushort>(),
-                from.Row4.As<ushort>(),
-                from.Row5.As<ushort>());
+            new(Vector4D<ushort>.CreateTruncating(from.Row1),
+                Vector4D<ushort>.CreateTruncating(from.Row2),
+                Vector4D<ushort>.CreateTruncating(from.Row3),
+                Vector4D<ushort>.CreateTruncating(from.Row4),
+                Vector4D<ushort>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ushort"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<ushort>(Matrix5X4<T> from) =>
+            new(Vector4D<ushort>.CreateChecked(from.Row1),
+                Vector4D<ushort>.CreateChecked(from.Row2),
+                Vector4D<ushort>.CreateChecked(from.Row3),
+                Vector4D<ushort>.CreateChecked(from.Row4),
+                Vector4D<ushort>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -415,11 +557,23 @@ public static explicit operator Matrix5X4<ushort>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="uint"/> matrix.</returns>
         public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from) =>
-            new(from.Row1.As<uint>(),
-                from.Row2.As<uint>(),
-                from.Row3.As<uint>(),
-                from.Row4.As<uint>(),
-                from.Row5.As<uint>());
+            new(Vector4D<uint>.CreateTruncating(from.Row1),
+                Vector4D<uint>.CreateTruncating(from.Row2),
+                Vector4D<uint>.CreateTruncating(from.Row3),
+                Vector4D<uint>.CreateTruncating(from.Row4),
+                Vector4D<uint>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="uint"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<uint>(Matrix5X4<T> from) =>
+            new(Vector4D<uint>.CreateChecked(from.Row1),
+                Vector4D<uint>.CreateChecked(from.Row2),
+                Vector4D<uint>.CreateChecked(from.Row3),
+                Vector4D<uint>.CreateChecked(from.Row4),
+                Vector4D<uint>.CreateChecked(from.Row5));
 
         /// <summary>
         /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -427,11 +581,23 @@ public static explicit operator Matrix5X4<uint>(Matrix5X4<T> from) =>
         /// <param name="from">The source matrix.</param>
         /// <returns>The <see cref="ulong"/> matrix.</returns>
         public static explicit operator Matrix5X4<ulong>(Matrix5X4<T> from) =>
-            new(from.Row1.As<ulong>(),
-                from.Row2.As<ulong>(),
-                from.Row3.As<ulong>(),
-                from.Row4.As<ulong>(),
-                from.Row5.As<ulong>());
+            new(Vector4D<ulong>.CreateTruncating(from.Row1),
+                Vector4D<ulong>.CreateTruncating(from.Row2),
+                Vector4D<ulong>.CreateTruncating(from.Row3),
+                Vector4D<ulong>.CreateTruncating(from.Row4),
+                Vector4D<ulong>.CreateTruncating(from.Row5));
+
+        /// <summary>
+        /// Converts a matrix of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source matrix.</param>
+        /// <returns>The <see cref="ulong"/> matrix.</returns>
+        public static explicit operator checked Matrix5X4<ulong>(Matrix5X4<T> from) =>
+            new(Vector4D<ulong>.CreateChecked(from.Row1),
+                Vector4D<ulong>.CreateChecked(from.Row2),
+                Vector4D<ulong>.CreateChecked(from.Row3),
+                Vector4D<ulong>.CreateChecked(from.Row4),
+                Vector4D<ulong>.CreateChecked(from.Row5));
     }
 
     public static partial class Matrix5X4
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 474b209e2f..09e6b203bc 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -300,19 +300,26 @@ static bool IParsable<Vector2D<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y);
 
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        public void Deconstruct(out T x, out T y)
-        {
-            x = X;
-            y = Y;
-        }
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector2D<T> CreateChecked<TOther>(Vector2D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateChecked(source.X), T.CreateChecked(source.Y));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector2D<T> CreateSaturating<TOther>(Vector2D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateSaturating(source.X), T.CreateSaturating(source.Y));
 
         /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector2D<T> CreateTruncating<TOther>(Vector2D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
         public Vector2D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
-            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y));
+            Vector2D<TOther>.CreateTruncating(this);
 
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2D{T}"/>.</summary>
         public static implicit operator Vector2D<T>((T X, T Y) v) =>
@@ -361,7 +368,15 @@ public static implicit operator (T X, T Y)(Vector2D<T> v) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="Half"/> vector.</returns>
         public static explicit operator Vector2D<Half>(Vector2D<T> from) =>
-            from.As<Half>();
+            Vector2D<Half>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator checked Vector2D<Half>(Vector2D<T> from) =>
+            Vector2D<Half>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -369,7 +384,15 @@ public static explicit operator Vector2D<Half>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="float"/> vector.</returns>
         public static explicit operator Vector2D<float>(Vector2D<T> from) =>
-            from.As<float>();
+            Vector2D<float>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator checked Vector2D<float>(Vector2D<T> from) =>
+            Vector2D<float>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -377,7 +400,15 @@ public static explicit operator Vector2D<float>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="double"/> vector.</returns>
         public static explicit operator Vector2D<double>(Vector2D<T> from) =>
-            from.As<double>();
+            Vector2D<double>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator checked Vector2D<double>(Vector2D<T> from) =>
+            Vector2D<double>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -385,7 +416,15 @@ public static explicit operator Vector2D<double>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="decimal"/> vector.</returns>
         public static explicit operator Vector2D<decimal>(Vector2D<T> from) =>
-            from.As<decimal>();
+            Vector2D<decimal>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator checked Vector2D<decimal>(Vector2D<T> from) =>
+            Vector2D<decimal>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -393,7 +432,15 @@ public static explicit operator Vector2D<decimal>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="byte"/> vector.</returns>
         public static explicit operator Vector2D<byte>(Vector2D<T> from) =>
-            from.As<byte>();
+            Vector2D<byte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator checked Vector2D<byte>(Vector2D<T> from) =>
+            Vector2D<byte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -401,7 +448,15 @@ public static explicit operator Vector2D<byte>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="short"/> vector.</returns>
         public static explicit operator Vector2D<short>(Vector2D<T> from) =>
-            from.As<short>();
+            Vector2D<short>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator checked Vector2D<short>(Vector2D<T> from) =>
+            Vector2D<short>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -409,7 +464,15 @@ public static explicit operator Vector2D<short>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="int"/> vector.</returns>
         public static explicit operator Vector2D<int>(Vector2D<T> from) =>
-            from.As<int>();
+            Vector2D<int>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator checked Vector2D<int>(Vector2D<T> from) =>
+            Vector2D<int>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -417,7 +480,15 @@ public static explicit operator Vector2D<int>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="long"/> vector.</returns>
         public static explicit operator Vector2D<long>(Vector2D<T> from) =>
-            from.As<long>();
+            Vector2D<long>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator checked Vector2D<long>(Vector2D<T> from) =>
+            Vector2D<long>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -425,7 +496,15 @@ public static explicit operator Vector2D<long>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="sbyte"/> vector.</returns>
         public static explicit operator Vector2D<sbyte>(Vector2D<T> from) =>
-            from.As<sbyte>();
+            Vector2D<sbyte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator checked Vector2D<sbyte>(Vector2D<T> from) =>
+            Vector2D<sbyte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -433,7 +512,15 @@ public static explicit operator Vector2D<sbyte>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ushort"/> vector.</returns>
         public static explicit operator Vector2D<ushort>(Vector2D<T> from) =>
-            from.As<ushort>();
+            Vector2D<ushort>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator checked Vector2D<ushort>(Vector2D<T> from) =>
+            Vector2D<ushort>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -441,7 +528,15 @@ public static explicit operator Vector2D<ushort>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="uint"/> vector.</returns>
         public static explicit operator Vector2D<uint>(Vector2D<T> from) =>
-            from.As<uint>();
+            Vector2D<uint>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator checked Vector2D<uint>(Vector2D<T> from) =>
+            Vector2D<uint>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -449,7 +544,15 @@ public static explicit operator Vector2D<uint>(Vector2D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ulong"/> vector.</returns>
         public static explicit operator Vector2D<ulong>(Vector2D<T> from) =>
-            from.As<ulong>();
+            Vector2D<ulong>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator checked Vector2D<ulong>(Vector2D<T> from) =>
+            Vector2D<ulong>.CreateChecked(from);
     }
 
     public static partial class Vector2D
@@ -468,6 +571,16 @@ public static partial class Vector2D
             public T LengthSquared => Vector2D.Dot(vector, vector);
         }
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        public static void Deconstruct<T>(this Vector2D<T> vector, out T x, out T y)
+            where T : INumberBase<T>
+        {
+            x = vector.X;
+            y = vector.Y;
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector2D<T> left, Vector2D<T> right)
             where T : INumberBase<T> =>
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index e915fd65bf..cb34c6f13f 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -337,21 +337,26 @@ static bool IParsable<Vector3D<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z);
 
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        /// <param name="z">The Z component.</param>
-        public void Deconstruct(out T x, out T y, out T z)
-        {
-            x = X;
-            y = Y;
-            z = Z;
-        }
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector3D<T> CreateChecked<TOther>(Vector3D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateChecked(source.X), T.CreateChecked(source.Y), T.CreateChecked(source.Z));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector3D<T> CreateSaturating<TOther>(Vector3D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateSaturating(source.X), T.CreateSaturating(source.Y), T.CreateSaturating(source.Z));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector3D<T> CreateTruncating<TOther>(Vector3D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y), T.CreateTruncating(source.Z));
 
         /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
         public Vector3D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
-            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y), TOther.CreateSaturating(Z));
+            Vector3D<TOther>.CreateTruncating(this);
 
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3D{T}"/>.</summary>
         public static implicit operator Vector3D<T>((T X, T Y, T Z) v) =>
@@ -400,7 +405,15 @@ public static implicit operator (T X, T Y, T Z)(Vector3D<T> v) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="Half"/> vector.</returns>
         public static explicit operator Vector3D<Half>(Vector3D<T> from) =>
-            from.As<Half>();
+            Vector3D<Half>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator checked Vector3D<Half>(Vector3D<T> from) =>
+            Vector3D<Half>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -408,7 +421,15 @@ public static explicit operator Vector3D<Half>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="float"/> vector.</returns>
         public static explicit operator Vector3D<float>(Vector3D<T> from) =>
-            from.As<float>();
+            Vector3D<float>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator checked Vector3D<float>(Vector3D<T> from) =>
+            Vector3D<float>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -416,7 +437,15 @@ public static explicit operator Vector3D<float>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="double"/> vector.</returns>
         public static explicit operator Vector3D<double>(Vector3D<T> from) =>
-            from.As<double>();
+            Vector3D<double>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator checked Vector3D<double>(Vector3D<T> from) =>
+            Vector3D<double>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -424,7 +453,15 @@ public static explicit operator Vector3D<double>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="decimal"/> vector.</returns>
         public static explicit operator Vector3D<decimal>(Vector3D<T> from) =>
-            from.As<decimal>();
+            Vector3D<decimal>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator checked Vector3D<decimal>(Vector3D<T> from) =>
+            Vector3D<decimal>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -432,7 +469,15 @@ public static explicit operator Vector3D<decimal>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="byte"/> vector.</returns>
         public static explicit operator Vector3D<byte>(Vector3D<T> from) =>
-            from.As<byte>();
+            Vector3D<byte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator checked Vector3D<byte>(Vector3D<T> from) =>
+            Vector3D<byte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -440,7 +485,15 @@ public static explicit operator Vector3D<byte>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="short"/> vector.</returns>
         public static explicit operator Vector3D<short>(Vector3D<T> from) =>
-            from.As<short>();
+            Vector3D<short>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator checked Vector3D<short>(Vector3D<T> from) =>
+            Vector3D<short>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -448,7 +501,15 @@ public static explicit operator Vector3D<short>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="int"/> vector.</returns>
         public static explicit operator Vector3D<int>(Vector3D<T> from) =>
-            from.As<int>();
+            Vector3D<int>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator checked Vector3D<int>(Vector3D<T> from) =>
+            Vector3D<int>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -456,7 +517,15 @@ public static explicit operator Vector3D<int>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="long"/> vector.</returns>
         public static explicit operator Vector3D<long>(Vector3D<T> from) =>
-            from.As<long>();
+            Vector3D<long>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator checked Vector3D<long>(Vector3D<T> from) =>
+            Vector3D<long>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -464,7 +533,15 @@ public static explicit operator Vector3D<long>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="sbyte"/> vector.</returns>
         public static explicit operator Vector3D<sbyte>(Vector3D<T> from) =>
-            from.As<sbyte>();
+            Vector3D<sbyte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator checked Vector3D<sbyte>(Vector3D<T> from) =>
+            Vector3D<sbyte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -472,7 +549,15 @@ public static explicit operator Vector3D<sbyte>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ushort"/> vector.</returns>
         public static explicit operator Vector3D<ushort>(Vector3D<T> from) =>
-            from.As<ushort>();
+            Vector3D<ushort>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator checked Vector3D<ushort>(Vector3D<T> from) =>
+            Vector3D<ushort>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -480,7 +565,15 @@ public static explicit operator Vector3D<ushort>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="uint"/> vector.</returns>
         public static explicit operator Vector3D<uint>(Vector3D<T> from) =>
-            from.As<uint>();
+            Vector3D<uint>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator checked Vector3D<uint>(Vector3D<T> from) =>
+            Vector3D<uint>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -488,7 +581,15 @@ public static explicit operator Vector3D<uint>(Vector3D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ulong"/> vector.</returns>
         public static explicit operator Vector3D<ulong>(Vector3D<T> from) =>
-            from.As<ulong>();
+            Vector3D<ulong>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator checked Vector3D<ulong>(Vector3D<T> from) =>
+            Vector3D<ulong>.CreateChecked(from);
     }
 
     public static partial class Vector3D
@@ -507,6 +608,18 @@ public static partial class Vector3D
             public T LengthSquared => Vector3D.Dot(vector, vector);
         }
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        public static void Deconstruct<T>(this Vector3D<T> vector, out T x, out T y, out T z)
+            where T : INumberBase<T>
+        {
+            x = vector.X;
+            y = vector.Y;
+            z = vector.Z;
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector3D<T> left, Vector3D<T> right)
             where T : INumberBase<T> =>
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index 04cf959ede..bfdfbecb07 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -374,23 +374,26 @@ static bool IParsable<Vector4D<T>>.TryParse([NotNullWhen(true)] string? s, IForm
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(X, Y, Z, W);
 
-        /// <summary>Desconstructs a vector into its components.</summary>
-        /// <param name="x">The X component.</param>
-        /// <param name="y">The Y component.</param>
-        /// <param name="z">The Z component.</param>
-        /// <param name="w">The W component.</param>
-        public void Deconstruct(out T x, out T y, out T z, out T w)
-        {
-            x = X;
-            y = Y;
-            z = Z;
-            w = W;
-        }
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector4D<T> CreateChecked<TOther>(Vector4D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateChecked(source.X), T.CreateChecked(source.Y), T.CreateChecked(source.Z), T.CreateChecked(source.W));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector4D<T> CreateSaturating<TOther>(Vector4D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateSaturating(source.X), T.CreateSaturating(source.Y), T.CreateSaturating(source.Z), T.CreateSaturating(source.W));
 
         /// <summary>Converts the components of this vector to another type.</summary>
+        public static Vector4D<T> CreateTruncating<TOther>(Vector4D<TOther> source)
+            where TOther : INumberBase<TOther> =>
+            new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y), T.CreateTruncating(source.Z), T.CreateTruncating(source.W));
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
         public Vector4D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
-            new(TOther.CreateSaturating(X), TOther.CreateSaturating(Y), TOther.CreateSaturating(Z), TOther.CreateSaturating(W));
+            Vector4D<TOther>.CreateTruncating(this);
 
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4D{T}"/>.</summary>
         public static implicit operator Vector4D<T>((T X, T Y, T Z, T W) v) =>
@@ -439,7 +442,15 @@ public static implicit operator (T X, T Y, T Z, T W)(Vector4D<T> v) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="Half"/> vector.</returns>
         public static explicit operator Vector4D<Half>(Vector4D<T> from) =>
-            from.As<Half>();
+            Vector4D<Half>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="Half"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="Half"/> vector.</returns>
+        public static explicit operator checked Vector4D<Half>(Vector4D<T> from) =>
+            Vector4D<Half>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
@@ -447,7 +458,15 @@ public static explicit operator Vector4D<Half>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="float"/> vector.</returns>
         public static explicit operator Vector4D<float>(Vector4D<T> from) =>
-            from.As<float>();
+            Vector4D<float>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="float"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="float"/> vector.</returns>
+        public static explicit operator checked Vector4D<float>(Vector4D<T> from) =>
+            Vector4D<float>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
@@ -455,7 +474,15 @@ public static explicit operator Vector4D<float>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="double"/> vector.</returns>
         public static explicit operator Vector4D<double>(Vector4D<T> from) =>
-            from.As<double>();
+            Vector4D<double>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="double"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="double"/> vector.</returns>
+        public static explicit operator checked Vector4D<double>(Vector4D<T> from) =>
+            Vector4D<double>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
@@ -463,7 +490,15 @@ public static explicit operator Vector4D<double>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="decimal"/> vector.</returns>
         public static explicit operator Vector4D<decimal>(Vector4D<T> from) =>
-            from.As<decimal>();
+            Vector4D<decimal>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="decimal"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="decimal"/> vector.</returns>
+        public static explicit operator checked Vector4D<decimal>(Vector4D<T> from) =>
+            Vector4D<decimal>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
@@ -471,7 +506,15 @@ public static explicit operator Vector4D<decimal>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="byte"/> vector.</returns>
         public static explicit operator Vector4D<byte>(Vector4D<T> from) =>
-            from.As<byte>();
+            Vector4D<byte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="byte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="byte"/> vector.</returns>
+        public static explicit operator checked Vector4D<byte>(Vector4D<T> from) =>
+            Vector4D<byte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
@@ -479,7 +522,15 @@ public static explicit operator Vector4D<byte>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="short"/> vector.</returns>
         public static explicit operator Vector4D<short>(Vector4D<T> from) =>
-            from.As<short>();
+            Vector4D<short>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="short"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="short"/> vector.</returns>
+        public static explicit operator checked Vector4D<short>(Vector4D<T> from) =>
+            Vector4D<short>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
@@ -487,7 +538,15 @@ public static explicit operator Vector4D<short>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="int"/> vector.</returns>
         public static explicit operator Vector4D<int>(Vector4D<T> from) =>
-            from.As<int>();
+            Vector4D<int>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="int"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="int"/> vector.</returns>
+        public static explicit operator checked Vector4D<int>(Vector4D<T> from) =>
+            Vector4D<int>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
@@ -495,7 +554,15 @@ public static explicit operator Vector4D<int>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="long"/> vector.</returns>
         public static explicit operator Vector4D<long>(Vector4D<T> from) =>
-            from.As<long>();
+            Vector4D<long>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="long"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="long"/> vector.</returns>
+        public static explicit operator checked Vector4D<long>(Vector4D<T> from) =>
+            Vector4D<long>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
@@ -503,7 +570,15 @@ public static explicit operator Vector4D<long>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="sbyte"/> vector.</returns>
         public static explicit operator Vector4D<sbyte>(Vector4D<T> from) =>
-            from.As<sbyte>();
+            Vector4D<sbyte>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="sbyte"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="sbyte"/> vector.</returns>
+        public static explicit operator checked Vector4D<sbyte>(Vector4D<T> from) =>
+            Vector4D<sbyte>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
@@ -511,7 +586,15 @@ public static explicit operator Vector4D<sbyte>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ushort"/> vector.</returns>
         public static explicit operator Vector4D<ushort>(Vector4D<T> from) =>
-            from.As<ushort>();
+            Vector4D<ushort>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ushort"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ushort"/> vector.</returns>
+        public static explicit operator checked Vector4D<ushort>(Vector4D<T> from) =>
+            Vector4D<ushort>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
@@ -519,7 +602,15 @@ public static explicit operator Vector4D<ushort>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="uint"/> vector.</returns>
         public static explicit operator Vector4D<uint>(Vector4D<T> from) =>
-            from.As<uint>();
+            Vector4D<uint>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="uint"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="uint"/> vector.</returns>
+        public static explicit operator checked Vector4D<uint>(Vector4D<T> from) =>
+            Vector4D<uint>.CreateChecked(from);
 
         /// <summary>
         /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
@@ -527,7 +618,15 @@ public static explicit operator Vector4D<uint>(Vector4D<T> from) =>
         /// <param name="from">The source vector.</param>
         /// <returns>The <see cref="ulong"/> vector.</returns>
         public static explicit operator Vector4D<ulong>(Vector4D<T> from) =>
-            from.As<ulong>();
+            Vector4D<ulong>.CreateTruncating(from);
+
+        /// <summary>
+        /// Converts a vector of <typeparamref name="T"/> into one with an underlying type of <see cref="ulong"/>.
+        /// </summary>
+        /// <param name="from">The source vector.</param>
+        /// <returns>The <see cref="ulong"/> vector.</returns>
+        public static explicit operator checked Vector4D<ulong>(Vector4D<T> from) =>
+            Vector4D<ulong>.CreateChecked(from);
     }
 
     public static partial class Vector4D
@@ -546,6 +645,20 @@ public static partial class Vector4D
             public T LengthSquared => Vector4D.Dot(vector, vector);
         }
 
+        /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="x">The X component.</param>
+        /// <param name="y">The Y component.</param>
+        /// <param name="z">The Z component.</param>
+        /// <param name="w">The W component.</param>
+        public static void Deconstruct<T>(this Vector4D<T> vector, out T x, out T y, out T z, out T w)
+            where T : INumberBase<T>
+        {
+            x = vector.X;
+            y = vector.Y;
+            z = vector.Z;
+            w = vector.W;
+        }
+
         /// <summary>Computes the dot product of two vectors.</summary>
         public static T Dot<T>(this Vector4D<T> left, Vector4D<T> right)
             where T : INumberBase<T> =>

From ac8e94ef8cfef1e8c0e16cf60840b3880e69936c Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 16:47:12 -0700
Subject: [PATCH 46/52] Handle IsIdentity and GetDeterminant errors.

---
 sources/Maths/Maths/Matrix2X2.cs     | 10 ++--------
 sources/Maths/Maths/Matrix2X2.gen.cs |  4 ++++
 sources/Maths/Maths/Matrix2X3.cs     |  6 +-----
 sources/Maths/Maths/Matrix2X4.cs     |  7 +------
 sources/Maths/Maths/Matrix3X2.cs     |  4 +++-
 sources/Maths/Maths/Matrix3X3.cs     | 15 +++------------
 sources/Maths/Maths/Matrix3X3.gen.cs |  4 ++++
 sources/Maths/Maths/Matrix3X4.cs     |  9 +--------
 sources/Maths/Maths/Matrix4X2.cs     |  7 +------
 sources/Maths/Maths/Matrix4X3.cs     |  9 +--------
 sources/Maths/Maths/Matrix4X4.cs     | 21 ++++-----------------
 sources/Maths/Maths/Matrix4X4.gen.cs |  4 ++++
 sources/Maths/Maths/Matrix5X4.cs     | 13 +------------
 13 files changed, 30 insertions(+), 83 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X2.cs b/sources/Maths/Maths/Matrix2X2.cs
index c1af4faa51..5085e8de98 100644
--- a/sources/Maths/Maths/Matrix2X2.cs
+++ b/sources/Maths/Maths/Matrix2X2.cs
@@ -54,12 +54,6 @@ public Matrix2X2(Matrix4X2<T> value)
             Row2 = new(value.M21, value.M22);
         }
 
-        /// <summary>Returns whether the matrix is the identity matrix.</summary>
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) &&
-               Scalar.Equal(M22, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero);
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -76,8 +70,8 @@ public readonly T GetDeterminant()
             //   | a b |
             //   | c d | = ad - bc
 
-            T a = M11, b = M12;
-            T d = M21, c = M22;
+            T a = Row1.X, b = Row1.Y;
+            T d = Row2.X, c = Row1.Y;
 
             return Scalar.Subtract(Scalar.Multiply(a, d), Scalar.Multiply(b, c));
         }
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index 0a61042a45..16706b400d 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -14,6 +14,10 @@ public partial struct Matrix2X2<T> :
             new(T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.MultiplicativeIdentity));
 
+        /// <summary>Returns whether the matrix is the identity matrix.</summary>
+        [IgnoreDataMember]
+        public readonly bool IsIdentity => this == Identity;
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         [IgnoreDataMember]
         public Vector2D<T> Row1;
diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index 75e94fa6ed..6309127676 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -65,11 +65,7 @@ public Matrix2X3(Matrix4X2<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) &&
-               Scalar.Equal(M22, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M21, Scalar<T>.Zero) && Scalar.Equal(M23, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index fb82209033..72401a53c5 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -65,12 +65,7 @@ public Matrix2X4(Matrix4X2<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) &&
-               Scalar.Equal(M22, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M14, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
-               Scalar.Equal(M23, Scalar<T>.Zero) && Scalar.Equal(M24, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index 95bd53d619..fe2716e323 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -102,7 +102,9 @@ public readonly T GetDeterminant()
             //
             // Collapse out the constants and oh look, this is just a 2x2 determinant!
 
-            return Scalar.Subtract(Scalar.Multiply(M11, M22), Scalar.Multiply(M21, M12));
+            return Scalar.Subtract(
+                Scalar.Multiply(Row1.X, Row2.Y),
+                Scalar.Multiply(Row2.X, Row1.Y));
         }
 
         /// <summary>
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index 27cf5a9bf6..39fff98e60 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -77,15 +77,6 @@ public Matrix3X3(Matrix4X4<T> value)
             Row3 = new(value.M31, value.M32, value.M33);
         }
 
-        /// <summary>Returns whether the matrix is the identity matrix.</summary>
-        [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) && Scalar.Equal(M22, Scalar<T>.One) &&
-               Scalar.Equal(M33, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M21, Scalar<T>.Zero) && Scalar.Equal(M23, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero);
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -103,9 +94,9 @@ public readonly T GetDeterminant()
             //   | d e f | = ( a ( ei - fh ) - b ( di - fg ) + c ( dh - eg ) )
             //   | g h i |
 
-            T a = M11, b = M12, c = M13;
-            T d = M21, e = M22, f = M23;
-            T g = M31, h = M32, i = M33;
+            T a = Row1.X, b = Row1.Y, c = Row1.Z;
+            T d = Row2.X, e = Row2.Y, f = Row2.Z;
+            T g = Row3.X, h = Row3.Y, i = Row3.Z;
 
             return Scalar.Add(
                 Scalar.Subtract(
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index 4b039ee5b5..33e2f9db96 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -15,6 +15,10 @@ public partial struct Matrix3X3<T> :
             new(T.Zero, T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.Zero, T.MultiplicativeIdentity));
 
+        /// <summary>Returns whether the matrix is the identity matrix.</summary>
+        [IgnoreDataMember]
+        public readonly bool IsIdentity => this == Identity;
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         [IgnoreDataMember]
         public Vector3D<T> Row1;
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index ed6c1c1193..84076d5572 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -80,14 +80,7 @@ public Matrix3X4(Matrix4X2<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) && Scalar.Equal(M22, Scalar<T>.One) &&
-               Scalar.Equal(M33, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M14, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
-               Scalar.Equal(M23, Scalar<T>.Zero) && Scalar.Equal(M24, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
-               Scalar.Equal(M34, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index 32aa778cd5..6086ca84b4 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -78,12 +78,7 @@ public Matrix4X2(Matrix2X4<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) &&
-               Scalar.Equal(M22, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
-               Scalar.Equal(M41, Scalar<T>.Zero) && Scalar.Equal(M42, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index b6d740fcc5..1611662778 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -99,14 +99,7 @@ public Matrix4X3(Matrix4X4<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) && Scalar.Equal(M22, Scalar<T>.One) &&
-               Scalar.Equal(M33, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M21, Scalar<T>.Zero) && Scalar.Equal(M23, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
-               Scalar.Equal(M41, Scalar<T>.Zero) && Scalar.Equal(M42, Scalar<T>.Zero) &&
-               Scalar.Equal(M43, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index 61118d8d30..c951ad86b9 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -74,19 +74,6 @@ public Matrix4X4(Matrix4X2<T> value)
             Row4 = new(value.M41, value.M42, default, Scalar<T>.One);
         }
 
-        /// <summary>Returns whether the matrix is the identity matrix.</summary>
-        [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) && Scalar.Equal(M22, Scalar<T>.One) &&
-               Scalar.Equal(M33, Scalar<T>.One) &&
-               Scalar.Equal(M44, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M14, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
-               Scalar.Equal(M23, Scalar<T>.Zero) && Scalar.Equal(M24, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
-               Scalar.Equal(M34, Scalar<T>.Zero) && Scalar.Equal(M41, Scalar<T>.Zero) &&
-               Scalar.Equal(M42, Scalar<T>.Zero) && Scalar.Equal(M43, Scalar<T>.Zero);
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -128,10 +115,10 @@ public readonly T GetDeterminant()
             // add: 6 + 8 + 3 = 17
             // mul: 12 + 16 = 28
 
-            T a = M11, b = M12, c = M13, d = M14;
-            T e = M21, f = M22, g = M23, h = M24;
-            T i = M31, j = M32, k = M33, l = M34;
-            T m = M41, n = M42, o = M43, p = M44;
+            T a = Row1.X, b = Row1.Y, c = Row1.Z, d = Row1.W;
+            T e = Row2.X, f = Row2.Y, g = Row2.Z, h = Row2.W;
+            T i = Row3.X, j = Row3.Y, k = Row3.Z, l = Row3.W;
+            T m = Row4.X, n = Row4.Y, o = Row4.Z, p = Row4.W;
 
             T kp_lo = Scalar.Subtract(Scalar.Multiply(k, p), Scalar.Multiply(l, o));
             T jp_ln = Scalar.Subtract(Scalar.Multiply(j, p), Scalar.Multiply(l, n));
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index 046b54feda..5346ae1daf 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -16,6 +16,10 @@ public partial struct Matrix4X4<T> :
             new(T.Zero, T.Zero, T.MultiplicativeIdentity, T.Zero),
             new(T.Zero, T.Zero, T.Zero, T.MultiplicativeIdentity));
 
+        /// <summary>Returns whether the matrix is the identity matrix.</summary>
+        [IgnoreDataMember]
+        public readonly bool IsIdentity => this == Identity;
+
         /// <summary>The 1st row of the matrix represented as a vector.</summary>
         [IgnoreDataMember]
         public Vector4D<T> Row1;
diff --git a/sources/Maths/Maths/Matrix5X4.cs b/sources/Maths/Maths/Matrix5X4.cs
index 71ab1fd0eb..0d6e940a43 100644
--- a/sources/Maths/Maths/Matrix5X4.cs
+++ b/sources/Maths/Maths/Matrix5X4.cs
@@ -105,18 +105,7 @@ public Matrix5X4(Matrix4X2<T> value)
 
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
-        public readonly bool IsIdentity
-            => Scalar.Equal(M11, Scalar<T>.One) && Scalar.Equal(M22, Scalar<T>.One) &&
-               Scalar.Equal(M33, Scalar<T>.One) &&
-               Scalar.Equal(M44, Scalar<T>.One) && // Check diagonal element first for early out.
-               Scalar.Equal(M12, Scalar<T>.Zero) && Scalar.Equal(M13, Scalar<T>.Zero) &&
-               Scalar.Equal(M14, Scalar<T>.Zero) && Scalar.Equal(M21, Scalar<T>.Zero) &&
-               Scalar.Equal(M23, Scalar<T>.Zero) && Scalar.Equal(M24, Scalar<T>.Zero) &&
-               Scalar.Equal(M31, Scalar<T>.Zero) && Scalar.Equal(M32, Scalar<T>.Zero) &&
-               Scalar.Equal(M34, Scalar<T>.Zero) && Scalar.Equal(M41, Scalar<T>.Zero) &&
-               Scalar.Equal(M42, Scalar<T>.Zero) && Scalar.Equal(M43, Scalar<T>.Zero) &&
-               Scalar.Equal(M51, Scalar<T>.Zero) && Scalar.Equal(M52, Scalar<T>.Zero) &&
-               Scalar.Equal(M53, Scalar<T>.Zero) && Scalar.Equal(M54, Scalar<T>.Zero);
+        public readonly bool IsIdentity => this == Identity;
 
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>

From f71206cc6cb9313b7b6c9f978b6a1b08289d8eb6 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 16:58:16 -0700
Subject: [PATCH 47/52] Use T.Zero instead of default to avoid NRE.

---
 sources/Maths/Maths/Matrix2X3.cs     |  8 +++---
 sources/Maths/Maths/Matrix2X4.cs     | 20 +++++++--------
 sources/Maths/Maths/Matrix3X3.cs     | 12 ++++-----
 sources/Maths/Maths/Matrix3X4.cs     | 30 +++++++++++-----------
 sources/Maths/Maths/Matrix4X3.cs     | 12 ++++-----
 sources/Maths/Maths/Matrix4X4.Ops.cs | 12 ++++-----
 sources/Maths/Maths/Matrix4X4.cs     | 32 +++++++++++------------
 sources/Maths/Maths/Matrix5X4.cs     | 38 ++++++++++++++--------------
 8 files changed, 82 insertions(+), 82 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index 6309127676..e1e4df98a8 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -24,8 +24,8 @@ public partial struct Matrix2X3<T>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix2X3(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default);
-            Row2 = new(value.M21, value.M22, default);
+            Row1 = new(value.M11, value.M12, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix2X3{T}"/> from the given <see cref="Matrix4X3{T}"/>.</summary>
@@ -56,8 +56,8 @@ public Matrix2X3(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix2X3(Matrix4X2<T> value)
         {
-            Row1 = new Vector3D<T>(value.M11, value.M12, default);
-            Row2 = new Vector3D<T>(value.M21, value.M22, default);
+            Row1 = new Vector3D<T>(value.M11, value.M12, T.Zero);
+            Row2 = new Vector3D<T>(value.M21, value.M22, T.Zero);
         }
 
         /// <summary>Returns the multiplicative identity matrix.</summary>
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index 72401a53c5..838b0902cb 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -16,24 +16,24 @@ public partial struct Matrix2X4<T>
     {
         private static readonly Matrix2X4<T> _identity = new
         (
-            Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero
+            T.One, T.Zero, T.Zero, T.Zero,
+            T.Zero, T.One, T.Zero, T.Zero
         );
 
         /// <summary>Constructs a <see cref="Matrix2X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix2X4(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix2X4{T}"/> from the given Matrix4x3.</summary>
         /// <param name="value">The source Matrix4x3.</param>
         public Matrix2X4(Matrix4X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix2X4{T}"/> from the given <see cref="Matrix3X4{T}"/>.</summary>
@@ -48,16 +48,16 @@ public Matrix2X4(Matrix3X4<T> value)
         /// <param name="value">The source <see cref="Matrix3X3{T}"/>.</param>
         public Matrix2X4(Matrix3X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
         }
 
         /// <summary>Constructs a Matrix2x4 from the given <see cref="Matrix4X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix2X4(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
         }
 
         /// <summary>Returns the multiplicative identity matrix.</summary>
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index 39fff98e60..d98120c478 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -18,9 +18,9 @@ public partial struct Matrix3X3<T>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix3X3(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default);
-            Row2 = new(value.M21, value.M22, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One);
         }
 
         /// <summary>Constructs a <see cref="Matrix3X3{T}"/> from the given <see cref="Matrix4X3{T}"/>.</summary>
@@ -63,9 +63,9 @@ public Matrix3X3(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix3X3(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default);
-            Row2 = new(value.M21, value.M22, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One);
         }
 
         /// <summary>Constructs a <see cref="Matrix3X3{T}"/> from the given <see cref="Matrix4X4{T}"/>.</summary>
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index 84076d5572..82ed67a171 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -16,27 +16,27 @@ public partial struct Matrix3X4<T>
     {
         private static readonly Matrix3X4<T> _identity = new
         (
-            Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero
+            T.One, T.Zero, T.Zero, T.Zero,
+            T.Zero, T.One, T.Zero, T.Zero,
+            T.Zero, T.Zero, T.One, T.Zero
         );
 
         /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix3X4(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given <see cref="Matrix4X3{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix4X3{T}"/>.</param>
         public Matrix3X4(Matrix4X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row3 = new(value.M31, value.M32, value.M33, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row3 = new(value.M31, value.M32, value.M33, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given <see cref="Matrix3X4{T}"/>.</summary>
@@ -52,9 +52,9 @@ public Matrix3X4(Matrix3X4<T> value)
         /// <param name="value">The source <see cref="Matrix3X3{T}"/>.</param>
         public Matrix3X4(Matrix3X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row3 = new(value.M31, value.M32, value.M33, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row3 = new(value.M31, value.M32, value.M33, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix3X4{T}"/> from the given <see cref="Matrix2X4{T}"/>.</summary>
@@ -70,9 +70,9 @@ public Matrix3X4(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix3X4(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One, T.Zero);
         }
 
         /// <summary>Returns the multiplicative identity matrix.</summary>
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index 1611662778..607aa46115 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -28,10 +28,10 @@ public partial struct Matrix4X3<T>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix4X3(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default);
-            Row2 = new(value.M21, value.M22, default);
+            Row1 = new(value.M11, value.M12, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero);
             Row3 = Vector3D<T>.UnitZ;
-            Row4 = new(value.M31, value.M32, default);
+            Row4 = new(value.M31, value.M32, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix4X3{T}"/> from the given <see cref="Matrix4X3{T}"/>.</summary>
@@ -78,9 +78,9 @@ public Matrix4X3(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix4X3(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default);
-            Row2 = new(value.M21, value.M22, default);
-            Row3 = new(value.M31, value.M32, default);
+            Row1 = new(value.M11, value.M12, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero);
+            Row3 = new(value.M31, value.M32, T.Zero);
             Row4 = new(value.M41, value.M42, Scalar<T>.One);
         }
 
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index 450925695d..83e8e3dc15 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -76,9 +76,9 @@ public static Matrix4X4<T> CreateBillboard<T>(Vector3D<T> objectPosition, Vector
             Vector3D<T> yaxis = Vector3D.Cross(zaxis, xaxis);
 
             return new(
-                new(xaxis, default),
-                new(yaxis, default),
-                new(zaxis, default),
+                new(xaxis, T.Zero),
+                new(yaxis, T.Zero),
+                new(zaxis, T.Zero),
                 new(objectPosition, Scalar<T>.One));
         }
 
@@ -137,9 +137,9 @@ public static Matrix4X4<T> CreateConstrainedBillboard<T>(Vector3D<T> objectPosit
             }
 
             return new(
-                new(xaxis, default),
-                new(yaxis, default),
-                new(zaxis, default),
+                new(xaxis, T.Zero),
+                new(yaxis, T.Zero),
+                new(zaxis, T.Zero),
                 new(objectPosition, Scalar<T>.One));
         }
 
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index c951ad86b9..b9e06be306 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -18,20 +18,20 @@ public partial struct Matrix4X4<T>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix4X4(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row4 = new(value.M31, value.M32, default, Scalar<T>.One);
-            Row3 = new(default, default, Scalar<T>.One, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row4 = new(value.M31, value.M32, T.Zero, T.One);
+            Row3 = new(T.Zero, T.Zero, T.One, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix4X4{T}"/> from the given <see cref="Matrix4X3{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix4X3{T}"/>.</param>
         public Matrix4X4(Matrix4X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row3 = new(value.M31, value.M32, value.M33, default);
-            Row4 = new(value.M41, value.M42, value.M43, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row3 = new(value.M31, value.M32, value.M33, T.Zero);
+            Row4 = new(value.M41, value.M42, value.M43, T.One);
         }
 
         /// <summary>Constructs a <see cref="Matrix4X4{T}"/> from the given <see cref="Matrix3X4{T}"/>.</summary>
@@ -48,10 +48,10 @@ public Matrix4X4(Matrix3X4<T> value)
         /// <param name="value">The source <see cref="Matrix3X3{T}"/>.</param>
         public Matrix4X4(Matrix3X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row4 = new(value.M31, value.M32, value.M33, Scalar<T>.One);
-            Row3 = new(default, default, Scalar<T>.One, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row4 = new(value.M31, value.M32, value.M33, T.One);
+            Row3 = new(T.Zero, T.Zero, T.One, T.Zero);
         }
 
         /// <summary>Constructs a <see cref="Matrix4X4{T}"/> from the given <see cref="Matrix2X4{T}"/>.</summary>
@@ -68,10 +68,10 @@ public Matrix4X4(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix4X4(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One, default);
-            Row4 = new(value.M41, value.M42, default, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One, T.Zero);
+            Row4 = new(value.M41, value.M42, T.Zero, T.One);
         }
 
         /// <summary>Multiplies a vector by a matrix.</summary>
diff --git a/sources/Maths/Maths/Matrix5X4.cs b/sources/Maths/Maths/Matrix5X4.cs
index 0d6e940a43..555c6582b7 100644
--- a/sources/Maths/Maths/Matrix5X4.cs
+++ b/sources/Maths/Maths/Matrix5X4.cs
@@ -16,20 +16,20 @@ public partial struct Matrix5X4<T>
     {
         private static readonly Matrix5X4<T> _identity = new
         (
-            Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One, Scalar<T>.Zero,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One,
-            Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero
+            T.One, T.Zero, T.Zero, T.Zero,
+            T.Zero, T.One, T.Zero, T.Zero,
+            T.Zero, T.Zero, T.One, T.Zero,
+            T.Zero, T.Zero, T.Zero, T.One,
+            T.Zero, T.Zero, T.Zero, T.Zero
         );
 
         /// <summary>Constructs a <see cref="Matrix5X4{T}"/> from the given <see cref="Matrix3X2{T}"/>.</summary>
         /// <param name="value">The source <see cref="Matrix3X2{T}"/>.</param>
         public Matrix5X4(Matrix3X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row5 = new(value.M31, value.M32, default, default);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row5 = new(value.M31, value.M32, T.Zero, T.Zero);
             Row3 = Vector4D<T>.UnitZ;
             Row4 = Vector4D<T>.UnitW;
         }
@@ -49,10 +49,10 @@ public Matrix5X4(Matrix4X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X3{T}"/>.</param>
         public Matrix5X4(Matrix4X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row3 = new(value.M31, value.M32, value.M33, default);
-            Row4 = new(value.M41, value.M42, value.M43, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row3 = new(value.M31, value.M32, value.M33, T.Zero);
+            Row4 = new(value.M41, value.M42, value.M43, T.One);
             Row5 = default;
         }
 
@@ -71,9 +71,9 @@ public Matrix5X4(Matrix3X4<T> value)
         /// <param name="value">The source <see cref="Matrix3X3{T}"/>.</param>
         public Matrix5X4(Matrix3X3<T> value)
         {
-            Row1 = new(value.M11, value.M12, value.M13, default);
-            Row2 = new(value.M21, value.M22, value.M23, default);
-            Row5 = new(value.M31, value.M32, value.M33, default);
+            Row1 = new(value.M11, value.M12, value.M13, T.Zero);
+            Row2 = new(value.M21, value.M22, value.M23, T.Zero);
+            Row5 = new(value.M31, value.M32, value.M33, T.Zero);
             Row3 = Vector4D<T>.UnitZ;
             Row4 = Vector4D<T>.UnitW;
         }
@@ -93,10 +93,10 @@ public Matrix5X4(Matrix2X4<T> value)
         /// <param name="value">The source <see cref="Matrix4X2{T}"/>.</param>
         public Matrix5X4(Matrix4X2<T> value)
         {
-            Row1 = new(value.M11, value.M12, default, default);
-            Row2 = new(value.M21, value.M22, default, default);
-            Row3 = new(value.M31, value.M32, Scalar<T>.One, default);
-            Row4 = new(value.M41, value.M42, default, Scalar<T>.One);
+            Row1 = new(value.M11, value.M12, T.Zero, T.Zero);
+            Row2 = new(value.M21, value.M22, T.Zero, T.Zero);
+            Row3 = new(value.M31, value.M32, T.One, T.Zero);
+            Row4 = new(value.M41, value.M42, T.Zero, T.One);
             Row5 = default;
         }
 

From 0345ba56312fad178a192a82f63544ad3fcfea0d Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 19:41:03 -0700
Subject: [PATCH 48/52] Code-gen multiply operators.

---
 sources/Maths/Maths/Matrix2X2.Ops.cs |  81 ------------------
 sources/Maths/Maths/Matrix2X2.cs     |   9 --
 sources/Maths/Maths/Matrix2X2.gen.cs | 113 ++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix2X3.Ops.cs |  74 ----------------
 sources/Maths/Maths/Matrix2X3.cs     |   9 --
 sources/Maths/Maths/Matrix2X3.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix2X4.Ops.cs |  91 --------------------
 sources/Maths/Maths/Matrix2X4.cs     |   9 --
 sources/Maths/Maths/Matrix2X4.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix3X2.Ops.cs |  80 ------------------
 sources/Maths/Maths/Matrix3X2.cs     |   9 --
 sources/Maths/Maths/Matrix3X2.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix3X3.Ops.cs |  94 ---------------------
 sources/Maths/Maths/Matrix3X3.cs     |   9 --
 sources/Maths/Maths/Matrix3X3.gen.cs | 113 ++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix3X4.Ops.cs |  98 ----------------------
 sources/Maths/Maths/Matrix3X4.cs     |   9 --
 sources/Maths/Maths/Matrix3X4.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix4X2.Ops.cs |  91 --------------------
 sources/Maths/Maths/Matrix4X2.cs     |   9 --
 sources/Maths/Maths/Matrix4X2.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix4X3.Ops.cs |  97 ---------------------
 sources/Maths/Maths/Matrix4X3.cs     |   9 --
 sources/Maths/Maths/Matrix4X3.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix4X4.Ops.cs |  73 ----------------
 sources/Maths/Maths/Matrix4X4.cs     |  10 ---
 sources/Maths/Maths/Matrix4X4.gen.cs | 121 ++++++++++++++++++++++++++-
 sources/Maths/Maths/Matrix5X4.Ops.cs |  37 --------
 sources/Maths/Maths/Matrix5X4.gen.cs |  51 ++++++++++-
 sources/Maths/Maths/Vector2D.gen.cs  |  16 ++++
 sources/Maths/Maths/Vector3D.gen.cs  |  16 ++++
 sources/Maths/Maths/Vector4D.gen.cs  |  16 ++++
 32 files changed, 1162 insertions(+), 908 deletions(-)
 delete mode 100644 sources/Maths/Maths/Matrix2X2.Ops.cs
 delete mode 100644 sources/Maths/Maths/Matrix2X4.Ops.cs
 delete mode 100644 sources/Maths/Maths/Matrix3X4.Ops.cs
 delete mode 100644 sources/Maths/Maths/Matrix4X3.Ops.cs

diff --git a/sources/Maths/Maths/Matrix2X2.Ops.cs b/sources/Maths/Maths/Matrix2X2.Ops.cs
deleted file mode 100644
index e7f5828da8..0000000000
--- a/sources/Maths/Maths/Matrix2X2.Ops.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Matrix2X2{T}"/>
-    /// </summary>
-    public static partial class Matrix2X2
-    {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Add<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T> => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T> => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T> => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> value1, T value2)
-            where T : INumberBase<T> => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector2D<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T> => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Negate<T>(Matrix2X2<T> value)
-            where T : INumberBase<T> => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Subtract<T>(Matrix2X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T> => value1 - value2;
-    }
-}
diff --git a/sources/Maths/Maths/Matrix2X2.cs b/sources/Maths/Maths/Matrix2X2.cs
index 5085e8de98..25d3a702ca 100644
--- a/sources/Maths/Maths/Matrix2X2.cs
+++ b/sources/Maths/Maths/Matrix2X2.cs
@@ -54,15 +54,6 @@ public Matrix2X2(Matrix4X2<T> value)
             Row2 = new(value.M21, value.M22);
         }
 
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector2D<T> operator *(Vector2D<T> value1, Matrix2X2<T> value2)
-        {
-            return value1 * value2.Row1 + value1 * value2.Row2;
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index 16706b400d..154f2572ba 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -109,7 +109,6 @@ public override string ToString() =>
                 Row2.X, Row2.Y);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -197,6 +196,20 @@ public Matrix2X2<T> Transpose() =>
             new(left.Row1 * right,
                 left.Row2 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> operator *(Vector2D<T> rowVector, Matrix2X2<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> operator *(Matrix2X2<T> matrix, Vector2D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -422,6 +435,9 @@ public static explicit operator checked Matrix2X2<ulong>(Matrix2X2<T> from) =>
                 Vector2D<ulong>.CreateChecked(from.Row2));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix2X2{T}"/>
+    /// </summary>
     public static partial class Matrix2X2
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -433,5 +449,100 @@ public static Matrix2X2<T> Lerp<T>(Matrix2X2<T> value1, Matrix2X2<T> value2, T a
             where T : IFloatingPointIeee754<T> =>
             new(Vector2D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector2D.Lerp(value1.Row2, value2.Row2, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2X2<T> Add<T>(Matrix2X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2X2<T> Negate<T>(Matrix2X2<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2X2<T> Subtract<T>(Matrix2X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X2<T> Multiply<T>(T left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> Multiply<T>(Vector2D<T> rowVector, Matrix2X2<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> Multiply<T>(Matrix2X2<T> matrix, Vector2D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index 81cae99cff..d9cd1234fc 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -14,17 +14,6 @@ public static partial class Matrix2X3
     {
         private const float BillboardEpsilon = 1e-4f;
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Add<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
         /// <summary>Creates a spherical billboard that rotates around a specified object position.</summary>
         /// <param name="objectPosition">Position of the object the billboard will rotate around.</param>
         /// <param name="cameraPosition">Position of the camera.</param>
@@ -145,69 +134,6 @@ public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
             return CreateFromQuaternion(q);
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector2D<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Negate<T>(Matrix2X3<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Subtract<T>(Matrix2X3<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-
         /// <summary>Transforms the given matrix by applying the given Quaternion rotation.</summary>
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
diff --git a/sources/Maths/Maths/Matrix2X3.cs b/sources/Maths/Maths/Matrix2X3.cs
index e1e4df98a8..1f9c06fc6e 100644
--- a/sources/Maths/Maths/Matrix2X3.cs
+++ b/sources/Maths/Maths/Matrix2X3.cs
@@ -66,14 +66,5 @@ public Matrix2X3(Matrix4X2<T> value)
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector3D<T> operator *(Vector2D<T> value1, Matrix2X3<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2;
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index cd3fd0c468..c5d7f73970 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -114,7 +114,6 @@ public override string ToString() =>
                 Row2.X, Row2.Y, Row2.Z);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -203,6 +202,20 @@ public Matrix3X2<T> Transpose() =>
             new(left.Row1 * right,
                 left.Row2 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> operator *(Vector2D<T> rowVector, Matrix2X3<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> operator *(Matrix2X3<T> matrix, Vector3D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -436,6 +449,9 @@ public static explicit operator checked Matrix2X3<ulong>(Matrix2X3<T> from) =>
                 Vector3D<ulong>.CreateChecked(from.Row2));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix2X3{T}"/>
+    /// </summary>
     public static partial class Matrix2X3
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -447,5 +463,108 @@ public static Matrix2X3<T> Lerp<T>(Matrix2X3<T> value1, Matrix2X3<T> value2, T a
             where T : IFloatingPointIeee754<T> =>
             new(Vector3D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector3D.Lerp(value1.Row2, value2.Row2, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2X3<T> Add<T>(Matrix2X3<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2X3<T> Negate<T>(Matrix2X3<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2X3<T> Subtract<T>(Matrix2X3<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X3<T> Multiply<T>(T left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> Multiply<T>(Vector2D<T> rowVector, Matrix2X3<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> Multiply<T>(Matrix2X3<T> matrix, Vector3D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X4.Ops.cs b/sources/Maths/Maths/Matrix2X4.Ops.cs
deleted file mode 100644
index 4d0f06cbd4..0000000000
--- a/sources/Maths/Maths/Matrix2X4.Ops.cs
+++ /dev/null
@@ -1,91 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Matrix2X4{T}"/>
-    /// </summary>
-    public static partial class Matrix2X4
-    {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X4<T> Add<T>(Matrix2X4<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X4<T> Multiply<T>(Matrix2X2<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector2D<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-    }
-}
diff --git a/sources/Maths/Maths/Matrix2X4.cs b/sources/Maths/Maths/Matrix2X4.cs
index 838b0902cb..447aa4fac4 100644
--- a/sources/Maths/Maths/Matrix2X4.cs
+++ b/sources/Maths/Maths/Matrix2X4.cs
@@ -66,14 +66,5 @@ public Matrix2X4(Matrix4X2<T> value)
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector4D<T> operator *(Vector2D<T> value1, Matrix2X4<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2;
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index 2e8af8f158..c9f0301392 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -128,7 +128,6 @@ public override string ToString() =>
                 Row2.X, Row2.Y, Row2.Z, Row2.W);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix2X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -218,6 +217,20 @@ public Matrix4X2<T> Transpose() =>
             new(left.Row1 * right,
                 left.Row2 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> operator *(Vector2D<T> rowVector, Matrix2X4<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> operator *(Matrix2X4<T> matrix, Vector4D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z +  matrix.Column4 * columnVector.W;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -460,6 +473,9 @@ public static explicit operator checked Matrix2X4<ulong>(Matrix2X4<T> from) =>
                 Vector4D<ulong>.CreateChecked(from.Row2));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix2X4{T}"/>
+    /// </summary>
     public static partial class Matrix2X4
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -471,5 +487,108 @@ public static Matrix2X4<T> Lerp<T>(Matrix2X4<T> value1, Matrix2X4<T> value2, T a
             where T : IFloatingPointIeee754<T> =>
             new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector4D.Lerp(value1.Row2, value2.Row2, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix2X4<T> Add<T>(Matrix2X4<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix2X4<T> Negate<T>(Matrix2X4<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix2X4<T> Subtract<T>(Matrix2X4<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix2X4<T> Multiply<T>(T left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> Multiply<T>(Vector2D<T> rowVector, Matrix2X4<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector2D<T> Multiply<T>(Matrix2X4<T> matrix, Vector4D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X2.Ops.cs b/sources/Maths/Maths/Matrix3X2.Ops.cs
index 4f5194fe0a..34096ae04d 100644
--- a/sources/Maths/Maths/Matrix3X2.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X2.Ops.cs
@@ -18,15 +18,6 @@ public static partial class Matrix3X2
         private const float RotationEpsilon = 0.001f * ((float) Math.PI) / 180f;     // 0.1% of a degree
 #endif
 
-        /// <summary>Adds each matrix element in value1 with its corresponding element in value2.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The matrix containing the summed values.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Add<T>(Matrix3X2<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 + value2;
-
         /// <summary>Creates a rotation matrix using the given rotation in radians.</summary>
         /// <param name="radians">The amount of rotation, in radians.</param>
         /// <returns>A rotation matrix.</returns>
@@ -413,76 +404,5 @@ public static bool Invert<T>(Matrix3X2<T> matrix, out Matrix3X2<T> result)
 
             return true;
         }
-
-        /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The product matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector3D<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The product matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Multiply<T>(Matrix3X2<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The product matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies two matrices together and returns the resulting matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The product matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Scales all elements in a matrix by the given scalar factor.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling value to use.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Negates the given matrix by multiplying all values by -1.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Negate<T>(Matrix3X2<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts each matrix element in value2 from its corresponding element in value1.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The matrix containing the resulting values.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Subtract<T>(Matrix3X2<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X2.cs b/sources/Maths/Maths/Matrix3X2.cs
index fe2716e323..6f618c2e69 100644
--- a/sources/Maths/Maths/Matrix3X2.cs
+++ b/sources/Maths/Maths/Matrix3X2.cs
@@ -72,15 +72,6 @@ public Matrix3X2(Matrix4X2<T> value)
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
 
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector2D<T> operator *(Vector3D<T> value1, Matrix3X2<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
-        }
-
         /// <summary>Calculates the determinant for this matrix.
         /// The determinant is calculated by expanding the matrix with a third column whose values are (0,0,1).</summary>
         /// <returns>The determinant.</returns>
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 3afe6bdefa..5f8f13123e 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -119,7 +119,6 @@ public override string ToString() =>
                 Row3.X, Row3.Y);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -213,6 +212,20 @@ public Matrix2X3<T> Transpose() =>
                 left.Row2 * right,
                 left.Row3 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> operator *(Vector3D<T> rowVector, Matrix3X2<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> operator *(Matrix3X2<T> matrix, Vector2D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -472,6 +485,9 @@ public static explicit operator checked Matrix3X2<ulong>(Matrix3X2<T> from) =>
                 Vector2D<ulong>.CreateChecked(from.Row3));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix3X2{T}"/>
+    /// </summary>
     public static partial class Matrix3X2
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -484,5 +500,108 @@ public static Matrix3X2<T> Lerp<T>(Matrix3X2<T> value1, Matrix3X2<T> value2, T a
             new(Vector2D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector2D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector2D.Lerp(value1.Row3, value2.Row3, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3X2<T> Add<T>(Matrix3X2<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3X2<T> Negate<T>(Matrix3X2<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3X2<T> Subtract<T>(Matrix3X2<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X2<T> Multiply<T>(T left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> Multiply<T>(Vector3D<T> rowVector, Matrix3X2<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> Multiply<T>(Matrix3X2<T> matrix, Vector2D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index 3f1dcf198d..c90d00d352 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -35,17 +35,6 @@ private struct VectorBasis<T>
         }
         */
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Add<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
         /// <summary>Creates a spherical billboard that rotates around a specified object position.</summary>
         /// <param name="objectPosition">Position of the object the billboard will rotate around.</param>
         /// <param name="cameraPosition">Position of the camera.</param>
@@ -287,89 +276,6 @@ public static Matrix3X3<T> CreateScale<T>(T scale)
             return result;
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector3D<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Negate<T>(Matrix3X3<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-
         /*
         /// <summary>Attempts to extract the scale, translation, and rotation components from the given scale/rotation/translation matrix.
         /// If successful, the out parameters will contained the extracted values.</summary>
diff --git a/sources/Maths/Maths/Matrix3X3.cs b/sources/Maths/Maths/Matrix3X3.cs
index d98120c478..492bc49f43 100644
--- a/sources/Maths/Maths/Matrix3X3.cs
+++ b/sources/Maths/Maths/Matrix3X3.cs
@@ -77,15 +77,6 @@ public Matrix3X3(Matrix4X4<T> value)
             Row3 = new(value.M31, value.M32, value.M33);
         }
 
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector3D<T> operator *(Vector3D<T> value1, Matrix3X3<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index 33e2f9db96..adf07c2f0a 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -148,7 +148,6 @@ public override string ToString() =>
                 Row3.X, Row3.Y, Row3.Z);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -243,6 +242,20 @@ public Matrix3X3<T> Transpose() =>
                 left.Row2 * right,
                 left.Row3 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> operator *(Vector3D<T> rowVector, Matrix3X3<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> operator *(Matrix3X3<T> matrix, Vector3D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -510,6 +523,9 @@ public static explicit operator checked Matrix3X3<ulong>(Matrix3X3<T> from) =>
                 Vector3D<ulong>.CreateChecked(from.Row3));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix3X3{T}"/>
+    /// </summary>
     public static partial class Matrix3X3
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -522,5 +538,100 @@ public static Matrix3X3<T> Lerp<T>(Matrix3X3<T> value1, Matrix3X3<T> value2, T a
             new(Vector3D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector3D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector3D.Lerp(value1.Row3, value2.Row3, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3X3<T> Add<T>(Matrix3X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3X3<T> Negate<T>(Matrix3X3<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3X3<T> Subtract<T>(Matrix3X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X3<T> Multiply<T>(T left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> Multiply<T>(Vector3D<T> rowVector, Matrix3X3<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> Multiply<T>(Matrix3X3<T> matrix, Vector3D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X4.Ops.cs b/sources/Maths/Maths/Matrix3X4.Ops.cs
deleted file mode 100644
index ae25df3fb3..0000000000
--- a/sources/Maths/Maths/Matrix3X4.Ops.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Matrix3X4{T}"/>
-    /// </summary>
-    public static partial class Matrix3X4
-    {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Add<T>(Matrix3X4<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector3D<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Negate<T>(Matrix3X4<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X4<T> Subtract<T>(Matrix3X4<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-    }
-}
diff --git a/sources/Maths/Maths/Matrix3X4.cs b/sources/Maths/Maths/Matrix3X4.cs
index 82ed67a171..1143215c6a 100644
--- a/sources/Maths/Maths/Matrix3X4.cs
+++ b/sources/Maths/Maths/Matrix3X4.cs
@@ -81,14 +81,5 @@ public Matrix3X4(Matrix4X2<T> value)
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector4D<T> operator *(Vector3D<T> value1, Matrix3X4<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3;
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index 640fe89ad4..93e590bbcf 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -157,7 +157,6 @@ public override string ToString() =>
                 Row3.X, Row3.Y, Row3.Z, Row3.W);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix3X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -253,6 +252,20 @@ public Matrix4X3<T> Transpose() =>
                 left.Row2 * right,
                 left.Row3 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> operator *(Vector3D<T> rowVector, Matrix3X4<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> operator *(Matrix3X4<T> matrix, Vector4D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z +  matrix.Column4 * columnVector.W;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -529,6 +542,9 @@ public static explicit operator checked Matrix3X4<ulong>(Matrix3X4<T> from) =>
                 Vector4D<ulong>.CreateChecked(from.Row3));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix3X4{T}"/>
+    /// </summary>
     public static partial class Matrix3X4
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -541,5 +557,108 @@ public static Matrix3X4<T> Lerp<T>(Matrix3X4<T> value1, Matrix3X4<T> value2, T a
             new(Vector4D.Lerp(value1.Row1, value2.Row1, amount),
                 Vector4D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector4D.Lerp(value1.Row3, value2.Row3, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix3X4<T> Add<T>(Matrix3X4<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix3X4<T> Negate<T>(Matrix3X4<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix3X4<T> Subtract<T>(Matrix3X4<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix3X4<T> Multiply<T>(T left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> Multiply<T>(Vector3D<T> rowVector, Matrix3X4<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector3D<T> Multiply<T>(Matrix3X4<T> matrix, Vector4D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X2.Ops.cs b/sources/Maths/Maths/Matrix4X2.Ops.cs
index 697280fe63..d6a6d59f00 100644
--- a/sources/Maths/Maths/Matrix4X2.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X2.Ops.cs
@@ -12,97 +12,6 @@ namespace Silk.NET.Maths
     /// </summary>
     public static partial class Matrix4X2
     {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Add<T>(Matrix4X2<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> value1, Matrix2X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X2<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector2D<T> Multiply<T>(Vector4D<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Negate<T>(Matrix4X2<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Subtract<T>(Matrix4X2<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-
         /*[MethodImpl((MethodImplOptions)768)]
         private static Vector128<T> Permute<T>(Vector128<T> value, byte control)
             where T : INumberBase<T>
diff --git a/sources/Maths/Maths/Matrix4X2.cs b/sources/Maths/Maths/Matrix4X2.cs
index 6086ca84b4..4fab060824 100644
--- a/sources/Maths/Maths/Matrix4X2.cs
+++ b/sources/Maths/Maths/Matrix4X2.cs
@@ -79,14 +79,5 @@ public Matrix4X2(Matrix2X4<T> value)
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector2D<T> operator *(Vector4D<T> value1, Matrix4X2<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index 2cad4a3085..eb6b0133c9 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -138,7 +138,6 @@ public override string ToString() =>
                 Row4.X, Row4.Y);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X2<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -238,6 +237,20 @@ public Matrix2X4<T> Transpose() =>
                 left.Row3 * right,
                 left.Row4 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> operator *(Vector4D<T> rowVector, Matrix4X2<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3 + rowVector.W * matrix.Row4;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> operator *(Matrix4X2<T> matrix, Vector2D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -533,6 +546,9 @@ public static explicit operator checked Matrix4X2<ulong>(Matrix4X2<T> from) =>
                 Vector2D<ulong>.CreateChecked(from.Row4));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix4X2{T}"/>
+    /// </summary>
     public static partial class Matrix4X2
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -546,5 +562,108 @@ public static Matrix4X2<T> Lerp<T>(Matrix4X2<T> value1, Matrix4X2<T> value2, T a
                 Vector2D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector2D.Lerp(value1.Row3, value2.Row3, amount),
                 Vector2D.Lerp(value1.Row4, value2.Row4, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4X2<T> Add<T>(Matrix4X2<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4X2<T> Negate<T>(Matrix4X2<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4X2<T> Subtract<T>(Matrix4X2<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X2<T> Multiply<T>(T left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector2D<T> Multiply<T>(Vector4D<T> rowVector, Matrix4X2<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> Multiply<T>(Matrix4X2<T> matrix, Vector2D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X2<T> Multiply<T>(Matrix2X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X2<T> Multiply<T>(Matrix3X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X2<T> left, Matrix2X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X2<T> left, Matrix2X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X2<T> left, Matrix2X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X3.Ops.cs b/sources/Maths/Maths/Matrix4X3.Ops.cs
deleted file mode 100644
index 807192cc85..0000000000
--- a/sources/Maths/Maths/Matrix4X3.Ops.cs
+++ /dev/null
@@ -1,97 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-
-namespace Silk.NET.Maths
-{
-    /// <summary>
-    /// Methods for working with <see cref="Matrix4X3{T}"/>
-    /// </summary>
-    public static partial class Matrix4X3
-    {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Add<T>(Matrix4X3<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> value1, Matrix3X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector3D<T> Multiply<T>(Vector4D<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Negate<T>(Matrix4X3<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X3<T> Subtract<T>(Matrix4X3<T> value1, Matrix4X3<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-    }
-}
diff --git a/sources/Maths/Maths/Matrix4X3.cs b/sources/Maths/Maths/Matrix4X3.cs
index 607aa46115..bbda207d29 100644
--- a/sources/Maths/Maths/Matrix4X3.cs
+++ b/sources/Maths/Maths/Matrix4X3.cs
@@ -100,14 +100,5 @@ public Matrix4X3(Matrix4X4<T> value)
         /// <summary>Returns whether the matrix is the identity matrix.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector3D<T> operator *(Vector4D<T> value1, Matrix4X3<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 + value1.W * value2.Row4;
-        }
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index bb4c1216ff..5dbf30c452 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -162,7 +162,6 @@ public override string ToString() =>
                 Row4.X, Row4.Y, Row4.Z);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X3<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -263,6 +262,20 @@ public Matrix3X4<T> Transpose() =>
                 left.Row3 * right,
                 left.Row4 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> operator *(Vector4D<T> rowVector, Matrix4X3<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3 + rowVector.W * matrix.Row4;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> operator *(Matrix4X3<T> matrix, Vector3D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -566,6 +579,9 @@ public static explicit operator checked Matrix4X3<ulong>(Matrix4X3<T> from) =>
                 Vector3D<ulong>.CreateChecked(from.Row4));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix4X3{T}"/>
+    /// </summary>
     public static partial class Matrix4X3
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -579,5 +595,108 @@ public static Matrix4X3<T> Lerp<T>(Matrix4X3<T> value1, Matrix4X3<T> value2, T a
                 Vector3D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector3D.Lerp(value1.Row3, value2.Row3, amount),
                 Vector3D.Lerp(value1.Row4, value2.Row4, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4X3<T> Add<T>(Matrix4X3<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4X3<T> Negate<T>(Matrix4X3<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4X3<T> Subtract<T>(Matrix4X3<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X3<T> Multiply<T>(T left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector3D<T> Multiply<T>(Vector4D<T> rowVector, Matrix4X3<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> Multiply<T>(Matrix4X3<T> matrix, Vector3D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X3<T> Multiply<T>(Matrix2X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X3<T> Multiply<T>(Matrix3X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X3<T> left, Matrix3X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X3<T> left, Matrix3X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X3<T> left, Matrix3X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index 83e8e3dc15..f8c605f21c 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -40,17 +40,6 @@ private struct VectorBasis<T>
         }
         */
 
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Add<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
         /// <summary>Creates a spherical billboard that rotates around a specified object position.</summary>
         /// <param name="objectPosition">Position of the object the billboard will rotate around.</param>
         /// <param name="cameraPosition">Position of the camera.</param>
@@ -1192,68 +1181,6 @@ static bool SoftwareFallback(Matrix4X4<T> matrix, out Matrix4X4<T> result)
             }
         }
 
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by another matrix.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> value1, Matrix4X2<T> value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Negate<T>(Matrix4X4<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix4X4<T> Subtract<T>(Matrix4X4<T> value1, Matrix4X4<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
-
         /*[MethodImpl((MethodImplOptions)768)]
         private static Vector128<T> Permute(Vector128<T> value, byte control)
         {
diff --git a/sources/Maths/Maths/Matrix4X4.cs b/sources/Maths/Maths/Matrix4X4.cs
index b9e06be306..2cd9f69e41 100644
--- a/sources/Maths/Maths/Matrix4X4.cs
+++ b/sources/Maths/Maths/Matrix4X4.cs
@@ -74,16 +74,6 @@ public Matrix4X4(Matrix4X2<T> value)
             Row4 = new(value.M41, value.M42, T.Zero, T.One);
         }
 
-        /// <summary>Multiplies a vector by a matrix.</summary>
-        /// <param name="value1">The vector.</param>
-        /// <param name="value2">The matrix.</param>
-        /// <returns>The result of the multiplication.</returns>
-        public static unsafe Vector4D<T> operator *(Vector4D<T> value1, Matrix4X4<T> value2)
-        {
-            return value1.X * value2.Row1 + value1.Y * value2.Row2 + value1.Z * value2.Row3 +
-                   value1.W * value2.Row4;
-        }
-
         /// <summary>Calculates the determinant of the matrix.</summary>
         /// <returns>The determinant of the matrix.</returns>
         public readonly T GetDeterminant()
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index 5346ae1daf..b2ffa73373 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -197,7 +197,6 @@ public override string ToString() =>
                 Row4.X, Row4.Y, Row4.Z, Row4.W);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix4X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -299,6 +298,20 @@ public Matrix4X4<T> Transpose() =>
                 left.Row3 * right,
                 left.Row4 * right);
 
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> operator *(Vector4D<T> rowVector, Matrix4X4<T> matrix) =>
+            rowVector.X * matrix.Row1 + rowVector.Y * matrix.Row2 + rowVector.Z * matrix.Row3 + rowVector.W * matrix.Row4;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> operator *(Matrix4X4<T> matrix, Vector4D<T> columnVector) =>
+             matrix.Column1 * columnVector.X +  matrix.Column2 * columnVector.Y +  matrix.Column3 * columnVector.Z +  matrix.Column4 * columnVector.W;
+
         /// <summary>Multiplies a matrix by another matrix.</summary>
         /// <param name="left">The first source matrix.</param>
         /// <param name="right">The second source matrix.</param>
@@ -611,6 +624,9 @@ public static explicit operator checked Matrix4X4<ulong>(Matrix4X4<T> from) =>
                 Vector4D<ulong>.CreateChecked(from.Row4));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix4X4{T}"/>
+    /// </summary>
     public static partial class Matrix4X4
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -624,5 +640,108 @@ public static Matrix4X4<T> Lerp<T>(Matrix4X4<T> value1, Matrix4X4<T> value2, T a
                 Vector4D.Lerp(value1.Row2, value2.Row2, amount),
                 Vector4D.Lerp(value1.Row3, value2.Row3, amount),
                 Vector4D.Lerp(value1.Row4, value2.Row4, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix4X4<T> Add<T>(Matrix4X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix4X4<T> Negate<T>(Matrix4X4<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix4X4<T> Subtract<T>(Matrix4X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix4X4<T> Multiply<T>(T left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="rowVector">The first source matrix, expressed as a row vector.</param>
+        /// <param name="matrix">The second source matrix.</param>
+        /// <returns>The result of the multiplication as a column vector.</returns>
+        public static Vector4D<T> Multiply<T>(Vector4D<T> rowVector, Matrix4X4<T> matrix)
+            where T : INumberBase<T> =>
+            rowVector * matrix;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="matrix">The first source matrix.</param>
+        /// <param name="columnVector">The second source matrix, expressed as a column vector.</param>
+        /// <returns>The result of the multiplication as a row vector.</returns>
+        public static Vector4D<T> Multiply<T>(Matrix4X4<T> matrix, Vector4D<T> columnVector)
+            where T : INumberBase<T> =>
+            matrix * columnVector;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix2X4<T> Multiply<T>(Matrix2X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix3X4<T> Multiply<T>(Matrix3X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X2<T> Multiply<T>(Matrix4X4<T> left, Matrix4X2<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X3<T> Multiply<T>(Matrix4X4<T> left, Matrix4X3<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix4X4<T> Multiply<T>(Matrix4X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Matrix5X4.Ops.cs b/sources/Maths/Maths/Matrix5X4.Ops.cs
index 032181692f..65c6170be8 100644
--- a/sources/Maths/Maths/Matrix5X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix5X4.Ops.cs
@@ -12,17 +12,6 @@ namespace Silk.NET.Maths
     /// </summary>
     public static partial class Matrix5X4
     {
-        /// <summary>Adds two matrices together.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The resulting matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix5X4<T> Add<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
-            where T : INumberBase<T>
-        {
-            return value1 + value2;
-        }
-
         /// <summary>Multiplies a vector by a matrix.</summary>
         /// <param name="value1">The vector.</param>
         /// <param name="value2">The matrix.</param>
@@ -31,31 +20,5 @@ public static Matrix5X4<T> Add<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
         public static Vector4D<T> Multiply<T>(Vector4D<T> value1, Matrix5X4<T> value2)
             where T : INumberBase<T>
             => value1 * value2;
-
-        /// <summary>Multiplies a matrix by a scalar value.</summary>
-        /// <param name="value1">The source matrix.</param>
-        /// <param name="value2">The scaling factor.</param>
-        /// <returns>The scaled matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> value1, T value2)
-            where T : INumberBase<T>
-            => value1 * value2;
-
-        /// <summary>Returns a new matrix with the negated elements of the given matrix.</summary>
-        /// <param name="value">The source matrix.</param>
-        /// <returns>The negated matrix.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix5X4<T> Negate<T>(Matrix5X4<T> value)
-            where T : INumberBase<T>
-            => -value;
-
-        /// <summary>Subtracts the second matrix from the first.</summary>
-        /// <param name="value1">The first source matrix.</param>
-        /// <param name="value2">The second source matrix.</param>
-        /// <returns>The result of the subtraction.</returns>
-        [MethodImpl((MethodImplOptions) 768)]
-        public static Matrix5X4<T> Subtract<T>(Matrix5X4<T> value1, Matrix5X4<T> value2)
-            where T : INumberBase<T>
-            => value1 - value2;
     }
 }
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index a294471477..af2e8a312e 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -199,7 +199,6 @@ public override string ToString() =>
                 Row5.X, Row5.Y, Row5.Z, Row5.W);
 
         /// <inheridoc/>
-        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
         public override bool Equals(object? obj) => obj is Matrix5X4<T> other && Equals(other);
 
         /// <inheridoc/>
@@ -600,6 +599,9 @@ public static explicit operator checked Matrix5X4<ulong>(Matrix5X4<T> from) =>
                 Vector4D<ulong>.CreateChecked(from.Row5));
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Matrix5X4{T}"/>
+    /// </summary>
     public static partial class Matrix5X4
     {
         /// <summary>Linearly interpolates between the corresponding values of two matrices.</summary>
@@ -614,5 +616,52 @@ public static Matrix5X4<T> Lerp<T>(Matrix5X4<T> value1, Matrix5X4<T> value2, T a
                 Vector4D.Lerp(value1.Row3, value2.Row3, amount),
                 Vector4D.Lerp(value1.Row4, value2.Row4, amount),
                 Vector4D.Lerp(value1.Row5, value2.Row5, amount));
+
+        /// <summary>Adds two matrices together.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the addition.</returns>
+        public static Matrix5X4<T> Add<T>(Matrix5X4<T> left, Matrix5X4<T> right)
+            where T : INumberBase<T> =>
+            left + right;
+
+        /// <summary>Returns a negated copy of the specified matrix.</summary>
+        /// <param name="value">The source matrix.</param>
+        /// <returns>The negated matrix.</returns>
+        public static Matrix5X4<T> Negate<T>(Matrix5X4<T> value)
+            where T : INumberBase<T>
+            => -value;
+
+        /// <summary>Subtracts the second matrix from the first.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the subtraction.</returns>
+        public static Matrix5X4<T> Subtract<T>(Matrix5X4<T> left, Matrix5X4<T> right)
+            where T : INumberBase<T>
+            => left - right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The source matrix.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source matrix.</param>
+        /// <returns>The scaled matrix.</returns>
+        public static Matrix5X4<T> Multiply<T>(T left, Matrix5X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a matrix by another matrix.</summary>
+        /// <param name="left">The first source matrix.</param>
+        /// <param name="right">The second source matrix.</param>
+        /// <returns>The result of the multiplication.</returns>
+        public static Matrix5X4<T> Multiply<T>(Matrix5X4<T> left, Matrix4X4<T> right)
+            where T : INumberBase<T> =>
+            left * right;
     }
 }
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 09e6b203bc..3d7286547d 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -648,6 +648,22 @@ public static (Vector2D<T> Quotient, Vector2D<T> Remainder) DivRem<T>(Vector2D<T
             return (new Vector2D<T>(qX, qY), new Vector2D<T>(rX, rY));
         }
 
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The source vector.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector2D<T> Multiply<T>(Vector2D<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector2D<T> Multiply<T>(T left, Vector2D<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector2D<int> Sign<TSelf>(this Vector2D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index cb34c6f13f..b6572cd47f 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -689,6 +689,22 @@ public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem<T>(Vector3D<T
             return (new Vector3D<T>(qX, qY, qZ), new Vector3D<T>(rX, rY, rZ));
         }
 
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The source vector.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector3D<T> Multiply<T>(Vector3D<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector3D<T> Multiply<T>(T left, Vector3D<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector3D<int> Sign<TSelf>(this Vector3D<TSelf> value)
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index bfdfbecb07..ed84851eb8 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -730,6 +730,22 @@ public static (Vector4D<T> Quotient, Vector4D<T> Remainder) DivRem<T>(Vector4D<T
             return (new Vector4D<T>(qX, qY, qZ, qW), new Vector4D<T>(rX, rY, rZ, rW));
         }
 
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The source vector.</param>
+        /// <param name="right">The scaling factor.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector4D<T> Multiply<T>(Vector4D<T> left, T right)
+            where T : INumberBase<T> =>
+            left * right;
+
+        /// <summary>Multiplies a vector by a scalar value.</summary>
+        /// <param name="left">The scaling factor.</param>
+        /// <param name="right">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
+        public static Vector4D<T> Multiply<T>(T left, Vector4D<T> right)
+            where T : INumberBase<T> =>
+            left * right;
+
         /// <summary>Applies <see cref="INumber{TSelf}.Sign(TSelf)"/> to the provided arguments.</summary>
         /// <param name="value">A vector whose members will be provided for <parameref name="value"/>.</param>
         public static Vector4D<int> Sign<TSelf>(this Vector4D<TSelf> value)

From 9497be81c0f6d4d91a0655a29cc4b4d3a128ddb8 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 19:56:09 -0700
Subject: [PATCH 49/52] Recovered Old Quaternion implementation.

---
 sources/Maths/Maths/Matrix2X3.Ops.cs          |  12 +-
 sources/Maths/Maths/Matrix3X3.Ops.cs          |  12 +-
 sources/Maths/Maths/Matrix4X4.Ops.cs          |  12 +-
 sources/Maths/Maths/Plane.Ops.cs              |   4 +-
 .../Quaternion.cs => Quaternion.Old.cs}       | 261 ++++--------------
 sources/Maths/Maths/Quaternion.cs             |  36 ++-
 6 files changed, 99 insertions(+), 238 deletions(-)
 rename sources/Maths/Maths/{Legacy/Quaternion.cs => Quaternion.Old.cs} (69%)

diff --git a/sources/Maths/Maths/Matrix2X3.Ops.cs b/sources/Maths/Maths/Matrix2X3.Ops.cs
index d9cd1234fc..fdd180d1ce 100644
--- a/sources/Maths/Maths/Matrix2X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix2X3.Ops.cs
@@ -94,8 +94,8 @@ public static Matrix2X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : INumberBase<T>
+        public static Matrix2X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+            where T : ITrigonometricFunctions<T>
         {
             Matrix2X3<T> result = Matrix2X3<T>.Identity;
 
@@ -128,9 +128,9 @@ public static Matrix2X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : INumberBase<T>
+            where T : ITrigonometricFunctions<T>
         {
-            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            var q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -138,8 +138,8 @@ public static Matrix2X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Legacy.Quaternion<T> rotation)
-            where T : INumberBase<T>
+        public static Matrix2X3<T> Transform<T>(Matrix2X3<T> value, Quaternion<T> rotation)
+            where T : ITrigonometricFunctions<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Matrix3X3.Ops.cs b/sources/Maths/Maths/Matrix3X3.Ops.cs
index c90d00d352..2cdcb433e6 100644
--- a/sources/Maths/Maths/Matrix3X3.Ops.cs
+++ b/sources/Maths/Maths/Matrix3X3.Ops.cs
@@ -119,8 +119,8 @@ public static Matrix3X3<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : INumberBase<T>
+        public static Matrix3X3<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+            where T : ITrigonometricFunctions<T>
         {
             Matrix3X3<T> result = Matrix3X3<T>.Identity;
 
@@ -157,9 +157,9 @@ public static Matrix3X3<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix3X3<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : INumberBase<T>
+            where T : ITrigonometricFunctions<T>
         {
-            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            var q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -475,8 +475,8 @@ public static bool Decompose<T>(Matrix3X3<T> matrix, out Vector3D<T> scale, out
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Legacy.Quaternion<T> rotation)
-            where T : INumberBase<T>
+        public static Matrix3X3<T> Transform<T>(Matrix3X3<T> value, Quaternion<T> rotation)
+            where T : ITrigonometricFunctions<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Matrix4X4.Ops.cs b/sources/Maths/Maths/Matrix4X4.Ops.cs
index f8c605f21c..fffd21652b 100644
--- a/sources/Maths/Maths/Matrix4X4.Ops.cs
+++ b/sources/Maths/Maths/Matrix4X4.Ops.cs
@@ -189,8 +189,8 @@ public static Matrix4X4<T> CreateFromAxisAngle<T>(Vector3D<T> axis, T angle)
         /// <summary>Creates a rotation matrix from the given Quaternion rotation value.</summary>
         /// <param name="quaternion">The source Quaternion.</param>
         /// <returns>The rotation matrix.</returns>
-        public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quaternion<T> quaternion)
-            where T : INumberBase<T>
+        public static Matrix4X4<T> CreateFromQuaternion<T>(Quaternion<T> quaternion)
+            where T : ITrigonometricFunctions<T>
         {
             Matrix4X4<T> result = Matrix4X4<T>.Identity;
 
@@ -227,9 +227,9 @@ public static Matrix4X4<T> CreateFromQuaternion<T>(Silk.NET.Maths.Legacy.Quatern
         /// <param name="roll">Angle of rotation, in radians, around the Z-axis.</param>
         /// <returns>The rotation matrix.</returns>
         public static Matrix4X4<T> CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll)
-            where T : INumberBase<T>
+            where T : ITrigonometricFunctions<T>
         {
-            Legacy.Quaternion<T> q = Legacy.Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
+            var q = Quaternion<T>.CreateFromYawPitchRoll(yaw, pitch, roll);
             return CreateFromQuaternion(q);
         }
 
@@ -1404,8 +1404,8 @@ public static bool Decompose<T>(Matrix4X4<T> matrix, out Vector3D<T> scale, out
         /// <param name="value">The source matrix to transform.</param>
         /// <param name="rotation">The rotation to apply.</param>
         /// <returns>The transformed matrix.</returns>
-        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Legacy.Quaternion<T> rotation)
-            where T : INumberBase<T>
+        public static Matrix4X4<T> Transform<T>(Matrix4X4<T> value, Quaternion<T> rotation)
+            where T : ITrigonometricFunctions<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Plane.Ops.cs b/sources/Maths/Maths/Plane.Ops.cs
index fff64125ca..279f4200bf 100644
--- a/sources/Maths/Maths/Plane.Ops.cs
+++ b/sources/Maths/Maths/Plane.Ops.cs
@@ -182,8 +182,8 @@ public static Plane<T> Transform<T>(Plane<T> plane, Matrix4X4<T> matrix)
         /// <param name="rotation">The Quaternion rotation to apply to the Plane.</param>
         /// <returns>A new Plane that results from applying the rotation.</returns>
         [MethodImpl((MethodImplOptions) 768)]
-        public static Plane<T> Transform<T>(Plane<T> plane, Legacy.Quaternion<T> rotation)
-            where T : INumberBase<T>
+        public static Plane<T> Transform<T>(Plane<T> plane, Quaternion<T> rotation)
+            where T : ITrigonometricFunctions<T>
         {
             // Compute rotation matrix.
             T x2 = Scalar.Add(rotation.X, rotation.X);
diff --git a/sources/Maths/Maths/Legacy/Quaternion.cs b/sources/Maths/Maths/Quaternion.Old.cs
similarity index 69%
rename from sources/Maths/Maths/Legacy/Quaternion.cs
rename to sources/Maths/Maths/Quaternion.Old.cs
index 2694588fca..9a4c29648b 100644
--- a/sources/Maths/Maths/Legacy/Quaternion.cs
+++ b/sources/Maths/Maths/Quaternion.Old.cs
@@ -8,7 +8,7 @@
 using System.Runtime.Serialization;
 using Silk.NET.Maths;
 
-namespace Silk.NET.Maths.Legacy
+namespace Silk.NET.Maths
 {
     /// <summary>
     /// Represents a vector that is used to encode three-dimensional physical rotations.
@@ -16,41 +16,10 @@ namespace Silk.NET.Maths.Legacy
     /// <typeparam name="T">The type used to store values.</typeparam>
     [Serializable]
     [DataContract]
-    public struct Quaternion<T>
-        : IEquatable<Quaternion<T>>
-        where T : INumberBase<T>
+    public partial struct Quaternion<T>
     {
         private const float SlerpEpsilon = 1e-6f;
 
-        /// <summary>Specifies the X-value of the vector component of the Quaternion.</summary>
-        [DataMember]
-        public T X;
-
-        /// <summary>Specifies the Y-value of the vector component of the Quaternion.</summary>
-        [DataMember]
-        public T Y;
-
-        /// <summary>Specifies the Z-value of the vector component of the Quaternion.</summary>
-        [DataMember]
-        public T Z;
-
-        /// <summary>Specifies the rotation component of the Quaternion.</summary>
-        [DataMember]
-        public T W;
-
-        /// <summary>Constructs a Quaternion from the given components.</summary>
-        /// <param name="x">The X component of the Quaternion.</param>
-        /// <param name="y">The Y component of the Quaternion.</param>
-        /// <param name="z">The Z component of the Quaternion.</param>
-        /// <param name="w">The W component of the Quaternion.</param>
-        public Quaternion(T x, T y, T z, T w)
-        {
-            X = x;
-            Y = y;
-            Z = z;
-            W = w;
-        }
-
         /// <summary>Constructs a Quaternion from the given vector and rotation parts.</summary>
         /// <param name="vectorPart">The vector part of the Quaternion.</param>
         /// <param name="scalarPart">The rotation part of the Quaternion.</param>
@@ -62,9 +31,6 @@ public Quaternion(Vector3D<T> vectorPart, T scalarPart)
             W = scalarPart;
         }
 
-        /// <summary>Returns a Quaternion representing no rotation.</summary>
-        public static Quaternion<T> Identity => new(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
-
         /// <summary>Returns whether the Quaternion is the identity Quaternion.</summary>
         [IgnoreDataMember]
         public readonly bool IsIdentity => this == Identity;
@@ -104,22 +70,22 @@ public Quaternion(Vector3D<T> vectorPart, T scalarPart)
                 Scalar.Add(
                     Scalar.Add(Scalar.Multiply(value2.X, value2.X), Scalar.Multiply(value2.Y, value2.Y)),
                     Scalar.Multiply(value2.Z, value2.Z)), Scalar.Multiply(value2.W, value2.W));
-            T invNorm = Scalar.Reciprocal(ls);
+            var invNorm = Scalar.Reciprocal(ls);
 
-            T q2x = Scalar.Negate(Scalar.Multiply(value2.X, invNorm));
-            T q2y = Scalar.Negate(Scalar.Multiply(value2.Y, invNorm));
-            T q2z = Scalar.Negate(Scalar.Multiply(value2.Z, invNorm));
-            T q2w = Scalar.Multiply(value2.W, invNorm);
+            var q2x = Scalar.Negate(Scalar.Multiply(value2.X, invNorm));
+            var q2y = Scalar.Negate(Scalar.Multiply(value2.Y, invNorm));
+            var q2z = Scalar.Negate(Scalar.Multiply(value2.Z, invNorm));
+            var q2w = Scalar.Multiply(value2.W, invNorm);
 
             //-------------------------------------
             // Multiply part.
 
             // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+            var cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            var cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            var cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
 
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+            var dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
                 Scalar.Multiply(q1z, q2z));
 
             ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
@@ -130,23 +96,6 @@ public Quaternion(Vector3D<T> vectorPart, T scalarPart)
             return ans;
         }
 
-        /// <summary>Returns a boolean indicating whether the two given Quaternions are equal.</summary>
-        /// <param name="value1">The first Quaternion to compare.</param>
-        /// <param name="value2">The second Quaternion to compare.</param>
-        /// <returns>True if the Quaternions are equal; False otherwise.</returns>
-        public static bool operator ==(Quaternion<T> value1, Quaternion<T> value2)
-            => Scalar.Equal(value1.X, value2.X)
-            && Scalar.Equal(value1.Y, value2.Y)
-            && Scalar.Equal(value1.Z, value2.Z)
-            && Scalar.Equal(value1.W, value2.W);
-
-        /// <summary>Returns a boolean indicating whether the two given Quaternions are not equal.</summary>
-        /// <param name="value1">The first Quaternion to compare.</param>
-        /// <param name="value2">The second Quaternion to compare.</param>
-        /// <returns>True if the Quaternions are not equal; False if they are equal.</returns>
-        public static bool operator !=(Quaternion<T> value1, Quaternion<T> value2)
-            => !(value1 == value2);
-
         /// <summary>Multiplies two Quaternions together.</summary>
         /// <param name="value1">The Quaternion on the left side of the multiplication.</param>
         /// <param name="value2">The Quaternion on the right side of the multiplication.</param>
@@ -166,11 +115,11 @@ public Quaternion(Vector3D<T> vectorPart, T scalarPart)
             T q2w = value2.W;
 
             // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+            var cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            var cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            var cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
 
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+            var dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
                 Scalar.Multiply(q1z, q2z));
 
             ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
@@ -257,11 +206,11 @@ public static Quaternion<T> Concatenate(Quaternion<T> value1, Quaternion<T> valu
             T q2w = value1.W;
 
             // cross(av, bv)
-            T cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
-            T cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
-            T cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
+            var cx = Scalar.Subtract(Scalar.Multiply(q1y, q2z), Scalar.Multiply(q1z, q2y));
+            var cy = Scalar.Subtract(Scalar.Multiply(q1z, q2x), Scalar.Multiply(q1x, q2z));
+            var cz = Scalar.Subtract(Scalar.Multiply(q1x, q2y), Scalar.Multiply(q1y, q2x));
 
-            T dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
+            var dot = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2x), Scalar.Multiply(q1y, q2y)),
                 Scalar.Multiply(q1z, q2z));
 
             ans.X = Scalar.Add(Scalar.Add(Scalar.Multiply(q1x, q2w), Scalar.Multiply(q2x, q1w)), cx);
@@ -296,9 +245,9 @@ public static Quaternion<T> CreateFromAxisAngle(Vector3D<T> axis, T angle)
         {
             Quaternion<T> ans;
 
-            T halfAngle = Scalar.Divide(angle, Scalar<T>.Two);
-            T s = Scalar.Sin(halfAngle);
-            T c = Scalar.Cos(halfAngle);
+            var halfAngle = Scalar.Divide(angle, Scalar<T>.Two);
+            var s = Scalar.Sin(halfAngle);
+            var c = Scalar.Cos(halfAngle);
 
             ans.X = Scalar.Multiply(axis.X, s);
             ans.Y = Scalar.Multiply(axis.Y, s);
@@ -313,13 +262,13 @@ public static Quaternion<T> CreateFromAxisAngle(Vector3D<T> axis, T angle)
         /// <returns>The created Quaternion.</returns>
         public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
         {
-            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
+            var trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
 
             Quaternion<T> q = default;
 
             if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
             {
-                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
+                var s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
                 q.W = Scalar.Divide(s, Scalar<T>.Two);
                 s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                 q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
@@ -330,8 +279,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
             {
                 if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Divide(s, Scalar<T>.Two);
                     q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
                     q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
@@ -339,8 +288,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
                 }
                 else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
                     q.Y = Scalar.Divide(s, Scalar<T>.Two);
                     q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
@@ -348,8 +297,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
                 }
                 else
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
                     q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
                     q.Z = Scalar.Divide(s, Scalar<T>.Two);
@@ -365,13 +314,13 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix4X4<T> matrix)
         /// <returns>The created Quaternion.</returns>
         public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
         {
-            T trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
+            var trace = Scalar.Add(Scalar.Add(matrix.M11, matrix.M22), matrix.M33);
 
             Quaternion<T> q = default;
 
             if (Scalar.GreaterThan(trace, Scalar<T>.Zero))
             {
-                T s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
+                var s = Scalar.Sqrt(Scalar.Add(trace, Scalar<T>.One));
                 q.W = Scalar.Divide(s, Scalar<T>.Two);
                 s = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                 q.X = Scalar.Multiply(Scalar.Subtract(matrix.M23, matrix.M32), s);
@@ -382,8 +331,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
             {
                 if (Scalar.GreaterThanOrEqual(matrix.M11, matrix.M22) && Scalar.GreaterThanOrEqual(matrix.M11, matrix.M33))
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M11), matrix.M22), matrix.M33));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Divide(s, Scalar<T>.Two);
                     q.Y = Scalar.Multiply(Scalar.Add(matrix.M12, matrix.M21), invS);
                     q.Z = Scalar.Multiply(Scalar.Add(matrix.M13, matrix.M31), invS);
@@ -391,8 +340,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
                 }
                 else if (Scalar.GreaterThan(matrix.M22, matrix.M33))
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M22), matrix.M11), matrix.M33));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Multiply(Scalar.Add(matrix.M21, matrix.M12), invS);
                     q.Y = Scalar.Divide(s, Scalar<T>.Two);
                     q.Z = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
@@ -400,8 +349,8 @@ public static Quaternion<T> CreateFromRotationMatrix(Matrix3X3<T> matrix)
                 }
                 else
                 {
-                    T s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
-                    T invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
+                    var s = Scalar.Sqrt(Scalar.Subtract(Scalar.Subtract(Scalar.Add(Scalar<T>.One, matrix.M33), matrix.M11), matrix.M22));
+                    var invS = Scalar.Reciprocal(Scalar.Multiply(Scalar<T>.Two, s));
                     q.X = Scalar.Multiply(Scalar.Add(matrix.M31, matrix.M13), invS);
                     q.Y = Scalar.Multiply(Scalar.Add(matrix.M32, matrix.M23), invS);
                     q.Z = Scalar.Divide(s, Scalar<T>.Two);
@@ -423,15 +372,15 @@ public static Quaternion<T> CreateFromYawPitchRoll(T yaw, T pitch, T roll)
             //  pitch upward, then yaw to face into the new heading
             T sr, cr, sp, cp, sy, cy;
 
-            T halfRoll = Scalar.Divide(roll, Scalar<T>.Two);
+            var halfRoll = Scalar.Divide(roll, Scalar<T>.Two);
             sr = Scalar.Sin(halfRoll);
             cr = Scalar.Cos(halfRoll);
 
-            T halfPitch = Scalar.Divide(pitch, Scalar<T>.Two);
+            var halfPitch = Scalar.Divide(pitch, Scalar<T>.Two);
             sp = Scalar.Sin(halfPitch);
             cp = Scalar.Cos(halfPitch);
 
-            T halfYaw = Scalar.Divide(yaw, Scalar<T>.Two);
+            var halfYaw = Scalar.Divide(yaw, Scalar<T>.Two);
             sy = Scalar.Sin(halfYaw);
             cy = Scalar.Cos(halfYaw);
 
@@ -477,7 +426,7 @@ public static Quaternion<T> Inverse(Quaternion<T> value)
             Quaternion<T> ans;
 
             T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
-            T invNorm = Scalar.Reciprocal(ls);
+            var invNorm = Scalar.Reciprocal(ls);
 
             ans.X = Scalar.Negate(Scalar.Multiply(value.X, invNorm));
             ans.Y = Scalar.Negate(Scalar.Multiply(value.Y, invNorm));
@@ -494,8 +443,8 @@ public static Quaternion<T> Inverse(Quaternion<T> value)
         /// <returns>The interpolated Quaternion.</returns>
         public static Quaternion<T> Lerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
         {
-            T t = amount;
-            T t1 = Scalar.Subtract(Scalar<T>.One, t);
+            var t = amount;
+            var t1 = Scalar.Subtract(Scalar<T>.One, t);
 
             Quaternion<T> r = default;
 
@@ -523,7 +472,7 @@ public static Quaternion<T> Lerp(Quaternion<T> quaternion1, Quaternion<T> quater
 
             // Normalize it.
             T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(r.X, r.X), Scalar.Multiply(r.Y, r.Y)), Scalar.Multiply(r.Z, r.Z)), Scalar.Multiply(r.W, r.W));
-            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
+            var invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
 
             r.X = Scalar.Multiply(r.X, invNorm);
             r.Y = Scalar.Multiply(r.Y, invNorm);
@@ -564,7 +513,7 @@ public static Quaternion<T> Normalize(Quaternion<T> value)
             Quaternion<T> ans;
 
             T ls = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(value.X, value.X), Scalar.Multiply(value.Y, value.Y)), Scalar.Multiply(value.Z, value.Z)), Scalar.Multiply(value.W, value.W));
-            T invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
+            var invNorm = Scalar.Reciprocal(Scalar.Sqrt(ls));
 
             ans.X = Scalar.Multiply(value.X, invNorm);
             ans.Y = Scalar.Multiply(value.Y, invNorm);
@@ -581,11 +530,11 @@ public static Quaternion<T> Normalize(Quaternion<T> value)
         /// <returns>The interpolated Quaternion.</returns>
         public static Quaternion<T> Slerp(Quaternion<T> quaternion1, Quaternion<T> quaternion2, T amount)
         {
-            T t = amount;
+            var t = amount;
 
             T cosOmega = Scalar.Add(Scalar.Add(Scalar.Add(Scalar.Multiply(quaternion1.X, quaternion2.X), Scalar.Multiply(quaternion1.Y, quaternion2.Y)), Scalar.Multiply(quaternion1.Z, quaternion2.Z)), Scalar.Multiply(quaternion1.W, quaternion2.W));
 
-            bool flip = false;
+            var flip = false;
 
             if (!Scalar.GreaterThanOrEqual(cosOmega, Scalar<T>.Zero))
             {
@@ -603,11 +552,11 @@ public static Quaternion<T> Slerp(Quaternion<T> quaternion1, Quaternion<T> quate
             }
             else
             {
-                T omega = Scalar.Acos(cosOmega);
-                T invSinOmega = Scalar.Reciprocal(Scalar.Sin(omega));
+                var omega = Scalar.Acos(cosOmega);
+                var invSinOmega = Scalar.Reciprocal(Scalar.Sin(omega));
 
                 s1 = Scalar.Multiply(Scalar.Sin(Scalar.Multiply(Scalar.Subtract(Scalar<T>.One, t), omega)), invSinOmega);
-                s2 = (flip)
+                s2 = flip
                     ? Scalar.Negate(Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega))
                     : Scalar.Multiply(Scalar.Sin(Scalar.Multiply(t, omega)), invSinOmega);
             }
@@ -630,25 +579,6 @@ public static Quaternion<T> Slerp(Quaternion<T> quaternion1, Quaternion<T> quate
         public static Quaternion<T> Subtract(Quaternion<T> value1, Quaternion<T> value2)
             => value1 - value2;
 
-        /// <summary>Returns a boolean indicating whether the given Object is equal to this Quaternion instance.</summary>
-        /// <param name="obj">The Object to compare against.</param>
-        /// <returns>True if the Object is equal to this Quaternion; False otherwise.</returns>
-        public override readonly bool Equals(object? obj)
-            => (obj is Quaternion<T> other) && Equals(other);
-
-        /// <summary>Returns a boolean indicating whether the given Quaternion is equal to this Quaternion instance.</summary>
-        /// <param name="other">The Quaternion to compare this instance to.</param>
-        /// <returns>True if the other Quaternion is equal to this instance; False otherwise.</returns>
-        public readonly bool Equals(Quaternion<T> other)
-            => this == other;
-
-        /// <summary>Returns the hash code for this instance.</summary>
-        /// <returns>The hash code.</returns>
-        public override readonly int GetHashCode()
-        {
-            return unchecked(X.GetHashCode() + Y.GetHashCode() + Z.GetHashCode() + W.GetHashCode());
-        }
-
         /// <summary>Calculates the length of the Quaternion.</summary>
         /// <returns>The computed length of the Quaternion.</returns>
         public readonly T Length()
@@ -685,14 +615,14 @@ public static explicit operator Quaternion<float>(Quaternion<T> from)
                 Scalar.As<T, float>(from.W));
 
         /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into <see cref="System.Numerics.Quaternion"/>
+        /// Converts a <see cref="Quaternion{T}"/> into <see cref="Quaternion"/>
         /// </summary>
         /// <param name="from">The source quaternion</param>
         /// <returns>The <see cref="System.Numerics"/> quaternion</returns>
-        public static explicit operator System.Numerics.Quaternion(Quaternion<T> from)
+        public static explicit operator Quaternion(Quaternion<T> from)
             => new(Scalar.As<T, float>(from.X), Scalar.As<T, float>(from.Y), Scalar.As<T, float>(from.Z),
                 Scalar.As<T, float>(from.W));
-        
+
         /// <summary>
         /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="double"/>
         /// </summary>
@@ -702,93 +632,12 @@ public static explicit operator Quaternion<double>(Quaternion<T> from)
             => new(Scalar.As<T, double>(from.X), Scalar.As<T, double>(from.Y), Scalar.As<T, double>(from.Z),
                 Scalar.As<T, double>(from.W));
 
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="decimal"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="decimal"/> matrix</returns>
-        public static explicit operator Quaternion<decimal>(Quaternion<T> from)
-            => new(Scalar.As<T, decimal>(from.X), Scalar.As<T, decimal>(from.Y), Scalar.As<T, decimal>(from.Z),
-                Scalar.As<T, decimal>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="sbyte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="sbyte"/> matrix</returns>
-        public static explicit operator Quaternion<sbyte>(Quaternion<T> from)
-            => new(Scalar.As<T, sbyte>(from.X), Scalar.As<T, sbyte>(from.Y), Scalar.As<T, sbyte>(from.Z),
-                Scalar.As<T, sbyte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="byte"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="byte"/> matrix</returns>
-        public static explicit operator Quaternion<byte>(Quaternion<T> from)
-            => new(Scalar.As<T, byte>(from.X), Scalar.As<T, byte>(from.Y), Scalar.As<T, byte>(from.Z),
-                Scalar.As<T, byte>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ushort"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ushort"/> matrix</returns>
-        public static explicit operator Quaternion<ushort>(Quaternion<T> from)
-            => new(Scalar.As<T, ushort>(from.X), Scalar.As<T, ushort>(from.Y), Scalar.As<T, ushort>(from.Z),
-                Scalar.As<T, ushort>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="short"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="short"/> matrix</returns>
-        public static explicit operator Quaternion<short>(Quaternion<T> from)
-            => new(Scalar.As<T, short>(from.X), Scalar.As<T, short>(from.Y), Scalar.As<T, short>(from.Z),
-                Scalar.As<T, short>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="uint"/> matrix</returns>
-        public static explicit operator Quaternion<uint>(Quaternion<T> from)
-            => new(Scalar.As<T, uint>(from.X), Scalar.As<T, uint>(from.Y), Scalar.As<T, uint>(from.Z),
-                Scalar.As<T, uint>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="int"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="int"/> matrix</returns>
-        public static explicit operator Quaternion<int>(Quaternion<T> from)
-            => new(Scalar.As<T, int>(from.X), Scalar.As<T, int>(from.Y), Scalar.As<T, int>(from.Z),
-                Scalar.As<T, int>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="ulong"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="ulong"/> matrix</returns>
-        public static explicit operator Quaternion<ulong>(Quaternion<T> from)
-            => new(Scalar.As<T, ulong>(from.X), Scalar.As<T, ulong>(from.Y), Scalar.As<T, ulong>(from.Z),
-                Scalar.As<T, ulong>(from.W));
-
-        /// <summary>
-        /// Converts a <see cref="Quaternion{T}"/> into one with a <typeparamref name="T"/> of <see cref="long"/>
-        /// </summary>
-        /// <param name="from">The source matrix</param>
-        /// <returns>The <see cref="long"/> matrix</returns>
-        public static explicit operator Quaternion<long>(Quaternion<T> from)
-            => new(Scalar.As<T, long>(from.X), Scalar.As<T, long>(from.Y), Scalar.As<T, long>(from.Z),
-                Scalar.As<T, long>(from.W));
-        
         /// <summary>
         /// Returns this quaternion casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted quaternion</returns>
-        public Quaternion<TOther> As<TOther>() where TOther : INumberBase<TOther>
+        public Quaternion<TOther> As<TOther>() where TOther : ITrigonometricFunctions<TOther>
         {
             return new(Scalar.As<T, TOther>(X), Scalar.As<T, TOther>(Y), Scalar.As<T, TOther>(Z), Scalar.As<T, TOther>(W));
         }
diff --git a/sources/Maths/Maths/Quaternion.cs b/sources/Maths/Maths/Quaternion.cs
index cbc9253039..16f3b69527 100644
--- a/sources/Maths/Maths/Quaternion.cs
+++ b/sources/Maths/Maths/Quaternion.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Runtime.Serialization;
 using System.Text;
 using System.Threading.Tasks;
 
@@ -13,27 +14,31 @@ namespace Silk.NET.Maths
     /// <summary>
     /// Represents a four-dimensional vector used to encode 3D rotations.
     /// </summary>
-    public struct Quaternion<T> :
+    public partial struct Quaternion<T> :
         IEquatable<Quaternion<T>>
-        where T : IFloatingPointIeee754<T>
+        where T : ITrigonometricFunctions<T>
     {
         /// <summary>Specifies the X-value of the vector component of the Quaternion.</summary>
+        [DataMember]
         public T X;
 
         /// <summary>Specifies the Y-value of the vector component of the Quaternion.</summary>
+        [DataMember]
         public T Y;
 
         /// <summary>Specifies the Z-value of the vector component of the Quaternion.</summary>
+        [DataMember]
         public T Z;
 
-        /// <summary>Specifies the W-value of the scalar component of the Quaternion.</summary>
+        /// <summary>Specifies the rotation (W) component of the Quaternion.</summary>
+        [DataMember]
         public T W;
 
         /// <summary>Constructs a Quaternion from the given components.</summary>
-        /// <param name="x">The X component of the Quaternion.</param>
-        /// <param name="y">The Y component of the Quaternion.</param>
-        /// <param name="z">The Z component of the Quaternion.</param>
-        /// <param name="w">The W component of the Quaternion.</param>
+        /// <param name="x">The X-component of the Quaternion.</param>
+        /// <param name="y">The Y-component of the Quaternion.</param>
+        /// <param name="z">The Z-component of the Quaternion.</param>
+        /// <param name="w">The rotation (W) component of the Quaternion.</param>
         public Quaternion(T x, T y, T z, T w)
         {
             X = x;
@@ -58,7 +63,7 @@ public Quaternion(T x, T y, T z, T w)
         // TODO: Vector4F/Vector3F constructors
 
         /// <summary>Returns a <see cref="Quaternion{T}"/> representing no rotation.</summary>
-        public static Quaternion<T> Identity => new Quaternion<T>(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
+        public static Quaternion<T> Identity { get; } = new Quaternion<T>(Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.Zero, Scalar<T>.One);
 
         /// <summary>Returns a boolean indicating whether the given Object is equal to this <see cref="Quaternion{T}"/> instance.</summary>
         public override bool Equals(object? obj) =>
@@ -69,15 +74,22 @@ public bool Equals(Quaternion<T> other) =>
             this == other;
 
         /// <summary>Returns the hash code for this instance.</summary>
+        /// <returns>The hash code.</returns>
         public override int GetHashCode() =>
             HashCode.Combine(X, Y, Z, W);
 
+        /// <summary>Returns a boolean indicating whether the two given Quaternions are not equal.</summary>
+        /// <param name="left">The first Quaternion to compare.</param>
+        /// <param name="right">The second Quaternion to compare.</param>
+        /// <returns>True if the Quaternions are not equal; False if they are equal.</returns>
+        public static bool operator !=(Quaternion<T> left, Quaternion<T> right) =>
+            !(left == right);
 
-        // Equality Operators
+        /// <summary>Returns a boolean indicating whether the two given Quaternions are equal.</summary>
+        /// <param name="left">The first Quaternion to compare.</param>
+        /// <param name="right">The second Quaternion to compare.</param>
+        /// <returns>True if the Quaternions are equal; False otherwise.</returns>
         public static bool operator ==(Quaternion<T> left, Quaternion<T> right) =>
             left.X == right.X && left.Y == right.Y && left.Z == right.Z && left.W == right.W;
-
-        public static bool operator !=(Quaternion<T> left, Quaternion<T> right) =>
-            !(left == right);
     }
 }

From 9aa76de914047ff21649e4836a53321e967d8535 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 20:22:50 -0700
Subject: [PATCH 50/52] Fix Obsolete warnings.

---
 sources/Maths/Maths/Box2D.cs         | 36 +++++++++++++++++++++++++++-
 sources/Maths/Maths/Box3D.cs         |  9 +++----
 sources/Maths/Maths/Circle.cs        |  3 ++-
 sources/Maths/Maths/Cube.cs          | 11 +++++----
 sources/Maths/Maths/Matrix2X2.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix2X3.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix2X4.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix3X2.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix3X3.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix3X4.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix4X2.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix4X3.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix4X4.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Matrix5X4.gen.cs | 25 +++++++++++++++----
 sources/Maths/Maths/Plane.cs         |  3 ++-
 sources/Maths/Maths/Ray2D.cs         |  3 ++-
 sources/Maths/Maths/Ray3D.cs         |  3 ++-
 sources/Maths/Maths/Rectangle.cs     | 11 +++++----
 sources/Maths/Maths/Sphere.cs        |  1 +
 sources/Maths/Maths/Vector2D.gen.cs  | 18 +++++++++++++-
 sources/Maths/Maths/Vector3D.gen.cs  | 18 +++++++++++++-
 sources/Maths/Maths/Vector4D.gen.cs  | 18 +++++++++++++-
 22 files changed, 312 insertions(+), 72 deletions(-)

diff --git a/sources/Maths/Maths/Box2D.cs b/sources/Maths/Maths/Box2D.cs
index f038fd5fd5..c468e2fa48 100644
--- a/sources/Maths/Maths/Box2D.cs
+++ b/sources/Maths/Maths/Box2D.cs
@@ -151,7 +151,7 @@ public Box2D<T> GetScaled(Vector2D<T> scale, Vector2D<T> anchor)
         public Box2D<T> GetScaled<TScale>(Vector2D<TScale> scale, Vector2D<T> anchor)
             where TScale : INumber<TScale>
         {
-            return this.As<TScale>().GetScaled(scale, anchor.As<TScale>()).As<T>();
+            return this.AsTruncating<TScale>().GetScaled(scale, anchor.AsTruncating<TScale>()).AsTruncating<T>();
         }
 
         /// <summary>
@@ -210,10 +210,44 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Box2D<TOther> As<TOther>()
             where TOther : INumber<TOther>
         {
             return new(Min.As<TOther>(), Max.As<TOther>());
         }
+
+        /// <summary>
+        /// Returns this box casted to <typeparamref name="TOther"></typeparamref>
+        /// </summary>
+        /// <typeparam name="TOther">The type to cast to</typeparam>
+        /// <returns>The casted box</returns>
+        public Box2D<TOther> AsChecked<TOther>()
+            where TOther : INumber<TOther>
+        {
+            return new(Min.AsChecked<TOther>(), Max.AsChecked<TOther>());
+        }
+
+        /// <summary>
+        /// Returns this box casted to <typeparamref name="TOther"></typeparamref>
+        /// </summary>
+        /// <typeparam name="TOther">The type to cast to</typeparam>
+        /// <returns>The casted box</returns>
+        public Box2D<TOther> AsSaturating<TOther>()
+            where TOther : INumber<TOther>
+        {
+            return new(Min.AsSaturating<TOther>(), Max.AsSaturating<TOther>());
+        }
+
+        /// <summary>
+        /// Returns this box casted to <typeparamref name="TOther"></typeparamref>
+        /// </summary>
+        /// <typeparam name="TOther">The type to cast to</typeparam>
+        /// <returns>The casted box</returns>
+        public Box2D<TOther> AsTruncating<TOther>()
+            where TOther : INumber<TOther>
+        {
+            return new(Min.AsTruncating<TOther>(), Max.AsTruncating<TOther>());
+        }
     }
 }
diff --git a/sources/Maths/Maths/Box3D.cs b/sources/Maths/Maths/Box3D.cs
index 040c2b0256..4e50cfb16a 100644
--- a/sources/Maths/Maths/Box3D.cs
+++ b/sources/Maths/Maths/Box3D.cs
@@ -160,10 +160,10 @@ public Box3D<T> GetScaled(Vector3D<T> scale, Vector3D<T> anchor)
         public Box3D<T> GetScaled<TScale>(Vector3D<TScale> scale, Vector3D<T> anchor)
             where TScale : INumberBase<TScale>
         {
-            var convertedAnchor = anchor.As<TScale>();
-            var min = (scale * (Min.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            var max = (scale * (Max.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            return new Box3D<T>(min.As<T>(), max.As<T>());
+            var convertedAnchor = anchor.AsTruncating<TScale>();
+            var min = (scale * (Min.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            var max = (scale * (Max.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            return new Box3D<T>(min.AsTruncating<T>(), max.AsTruncating<T>());
         }
 
         /// <summary>
@@ -222,6 +222,7 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted box</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Box3D<TOther> As<TOther>()
             where TOther : INumber<TOther>
         {
diff --git a/sources/Maths/Maths/Circle.cs b/sources/Maths/Maths/Circle.cs
index 4be7fcc35e..53e37c049e 100644
--- a/sources/Maths/Maths/Circle.cs
+++ b/sources/Maths/Maths/Circle.cs
@@ -168,12 +168,13 @@ public override int GetHashCode()
         {
             return !value1.Equals(value2);
         }
-        
+
         /// <summary>
         /// Returns this circle casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted circle</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Circle<TOther> As<TOther>() where TOther : IRootFunctions<TOther>
         {
             return new(Center.As<TOther>(), Scalar.As<T, TOther>(Radius));
diff --git a/sources/Maths/Maths/Cube.cs b/sources/Maths/Maths/Cube.cs
index 90bc620d49..bdc61f267e 100644
--- a/sources/Maths/Maths/Cube.cs
+++ b/sources/Maths/Maths/Cube.cs
@@ -172,10 +172,10 @@ public Cube<T> GetScaled(Vector3D<T> scale, Vector3D<T> anchor)
         public Cube<T> GetScaled<TScale>(Vector3D<TScale> scale, Vector3D<T> anchor)
             where TScale : INumberBase<TScale>
         {
-            var convertedAnchor = anchor.As<TScale>();
-            var min = (scale * (Origin.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            var max = (scale * (Max.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            return new(min.As<T>(), (max - min).As<T>());
+            var convertedAnchor = anchor.AsTruncating<TScale>();
+            var min = (scale * (Origin.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            var max = (scale * (Max.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            return new(min.AsTruncating<T>(), (max - min).AsTruncating<T>());
         }
 
         /// <summary>
@@ -230,12 +230,13 @@ public override int GetHashCode()
         {
             return !value1.Equals(value2);
         }
-        
+
         /// <summary>
         /// Returns this circle casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted cube</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Cube<TOther> As<TOther>()
             where TOther : INumber<TOther>
         {
diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index 154f2572ba..c78d2f83c9 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -117,27 +117,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X2<T> CreateChecked<TOther>(Matrix2X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X2<T> CreateSaturating<TOther>(Matrix2X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X2<T> CreateTruncating<TOther>(Matrix2X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix2X2<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X2<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X2<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X2<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X2<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X2<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X2<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X2<T> Transpose() =>
             new(new(M11, M21),
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index c5d7f73970..f0a222eaae 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -122,27 +122,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X3<T> CreateChecked<TOther>(Matrix2X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X3<T> CreateSaturating<TOther>(Matrix2X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X3<T> CreateTruncating<TOther>(Matrix2X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix2X3<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X3<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X3<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X3<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X3<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X3<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X3<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X2<T> Transpose() =>
             new(new(M11, M21),
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index c9f0301392..ea7aed2896 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -136,27 +136,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X4<T> CreateChecked<TOther>(Matrix2X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X4<T> CreateSaturating<TOther>(Matrix2X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix2X4<T> CreateTruncating<TOther>(Matrix2X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix2X4<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X4<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X4<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X4<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X4<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix2X4<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix2X4<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X2<T> Transpose() =>
             new(new(M11, M21),
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 5f8f13123e..8f27467b3a 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -127,27 +127,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X2<T> CreateChecked<TOther>(Matrix3X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2), Vector2D<T>.CreateChecked(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X2<T> CreateSaturating<TOther>(Matrix3X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2), Vector2D<T>.CreateSaturating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X2<T> CreateTruncating<TOther>(Matrix3X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2), Vector2D<T>.CreateTruncating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix3X2<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X2<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X2<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X2<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X2<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X2<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X2<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X3<T> Transpose() =>
             new(new(M11, M21, M31),
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index adf07c2f0a..5718ab5f6c 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -156,27 +156,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X3<T> CreateChecked<TOther>(Matrix3X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2), Vector3D<T>.CreateChecked(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X3<T> CreateSaturating<TOther>(Matrix3X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2), Vector3D<T>.CreateSaturating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X3<T> CreateTruncating<TOther>(Matrix3X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2), Vector3D<T>.CreateTruncating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix3X3<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X3<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X3<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X3<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X3<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X3<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X3<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X3<T> Transpose() =>
             new(new(M11, M21, M31),
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index 93e590bbcf..202f179523 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -165,27 +165,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X4<T> CreateChecked<TOther>(Matrix3X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X4<T> CreateSaturating<TOther>(Matrix3X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix3X4<T> CreateTruncating<TOther>(Matrix3X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix3X4<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X4<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X4<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X4<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X4<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix3X4<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix3X4<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X3<T> Transpose() =>
             new(new(M11, M21, M31),
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index eb6b0133c9..7fa9e127b0 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -146,27 +146,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X2<T> CreateChecked<TOther>(Matrix4X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateChecked(other.Row1), Vector2D<T>.CreateChecked(other.Row2), Vector2D<T>.CreateChecked(other.Row3), Vector2D<T>.CreateChecked(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X2<T> CreateSaturating<TOther>(Matrix4X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateSaturating(other.Row1), Vector2D<T>.CreateSaturating(other.Row2), Vector2D<T>.CreateSaturating(other.Row3), Vector2D<T>.CreateSaturating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X2<T> CreateTruncating<TOther>(Matrix4X2<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector2D<T>.CreateTruncating(other.Row1), Vector2D<T>.CreateTruncating(other.Row2), Vector2D<T>.CreateTruncating(other.Row3), Vector2D<T>.CreateTruncating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix4X2<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X2<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X2<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X2<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X2<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X2<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X2<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix2X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index 5dbf30c452..47e77e6519 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -170,27 +170,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X3<T> CreateChecked<TOther>(Matrix4X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateChecked(other.Row1), Vector3D<T>.CreateChecked(other.Row2), Vector3D<T>.CreateChecked(other.Row3), Vector3D<T>.CreateChecked(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X3<T> CreateSaturating<TOther>(Matrix4X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateSaturating(other.Row1), Vector3D<T>.CreateSaturating(other.Row2), Vector3D<T>.CreateSaturating(other.Row3), Vector3D<T>.CreateSaturating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X3<T> CreateTruncating<TOther>(Matrix4X3<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector3D<T>.CreateTruncating(other.Row1), Vector3D<T>.CreateTruncating(other.Row2), Vector3D<T>.CreateTruncating(other.Row3), Vector3D<T>.CreateTruncating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix4X3<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X3<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X3<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X3<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X3<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X3<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X3<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix3X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index b2ffa73373..49bae4e98a 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -205,27 +205,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X4<T> CreateChecked<TOther>(Matrix4X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3), Vector4D<T>.CreateChecked(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X4<T> CreateSaturating<TOther>(Matrix4X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3), Vector4D<T>.CreateSaturating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix4X4<T> CreateTruncating<TOther>(Matrix4X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3), Vector4D<T>.CreateTruncating(other.Row4));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix4X4<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X4<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X4<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X4<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X4<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix4X4<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix4X4<TOther>.CreateTruncating(this);
+
         /// <summary>Computes the transpose of the matrix.</summary>
         public Matrix4X4<T> Transpose() =>
             new(new(M11, M21, M31, M41),
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index af2e8a312e..7d95ce484a 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -207,27 +207,42 @@ public override string ToString() =>
         /// <inheridoc/>
         public override int GetHashCode() => HashCode.Combine(Row1, Row2, Row3, Row4, Row5);
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix5X4<T> CreateChecked<TOther>(Matrix5X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateChecked(other.Row1), Vector4D<T>.CreateChecked(other.Row2), Vector4D<T>.CreateChecked(other.Row3), Vector4D<T>.CreateChecked(other.Row4), Vector4D<T>.CreateChecked(other.Row5));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix5X4<T> CreateSaturating<TOther>(Matrix5X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateSaturating(other.Row1), Vector4D<T>.CreateSaturating(other.Row2), Vector4D<T>.CreateSaturating(other.Row3), Vector4D<T>.CreateSaturating(other.Row4), Vector4D<T>.CreateSaturating(other.Row5));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
+        /// <summary>Converts the components of this matrix to another type.</summary>
         public static Matrix5X4<T> CreateTruncating<TOther>(Matrix5X4<TOther> other)
             where TOther : INumberBase<TOther> =>
             new(Vector4D<T>.CreateTruncating(other.Row1), Vector4D<T>.CreateTruncating(other.Row2), Vector4D<T>.CreateTruncating(other.Row3), Vector4D<T>.CreateTruncating(other.Row4), Vector4D<T>.CreateTruncating(other.Row5));
 
-        /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating or cast instead.", error: false)]
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Matrix5X4<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             new(Row1.As<TOther>(), Row2.As<TOther>(), Row3.As<TOther>(), Row4.As<TOther>(), Row5.As<TOther>());
 
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix5X4<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix5X4<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix5X4<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix5X4<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this matrix to another type.</summary>
+        public Matrix5X4<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Matrix5X4<TOther>.CreateTruncating(this);
+
         /// <summary>Returns a boolean indicating whether the given two matrices are equal.</summary>
         /// <param name="left">The first matrix to compare.</param>
         /// <param name="right">The second matrix to compare.</param>
diff --git a/sources/Maths/Maths/Plane.cs b/sources/Maths/Maths/Plane.cs
index f14e3f989f..39a7164f86 100644
--- a/sources/Maths/Maths/Plane.cs
+++ b/sources/Maths/Maths/Plane.cs
@@ -175,7 +175,7 @@ public static explicit operator Plane<ushort>(Plane<T> from)
         /// <param name="from">The source matrix</param>
         /// <returns>The <see cref="short"/> matrix</returns>
         public static explicit operator Plane<short>(Plane<T> from)
-            => new(from.Normal.As<short>(), short.CreateSaturating(from.Distance));
+            => new(from.Normal.AsSaturating<short>(), short.CreateSaturating(from.Distance));
 
         /// <summary>
         /// Converts a <see cref="Plane{T}"/> into one with a <typeparamref name="T"/> of <see cref="uint"/>
@@ -214,6 +214,7 @@ public static explicit operator Plane<long>(Plane<T> from)
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted plane</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Plane<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Normal.As<TOther>(), Scalar.As<T, TOther>(Distance));
diff --git a/sources/Maths/Maths/Ray2D.cs b/sources/Maths/Maths/Ray2D.cs
index 9980748f31..00b09dbcfe 100644
--- a/sources/Maths/Maths/Ray2D.cs
+++ b/sources/Maths/Maths/Ray2D.cs
@@ -124,12 +124,13 @@ public override int GetHashCode()
         {
             return !value1.Equals(value2);
         }
-        
+
         /// <summary>
         /// Returns this ray casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted ray</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Ray2D<TOther> As<TOther>()
             where TOther : INumberBase<TOther>
         {
diff --git a/sources/Maths/Maths/Ray3D.cs b/sources/Maths/Maths/Ray3D.cs
index b73feceb17..44f14aab0f 100644
--- a/sources/Maths/Maths/Ray3D.cs
+++ b/sources/Maths/Maths/Ray3D.cs
@@ -128,12 +128,13 @@ public override int GetHashCode()
         {
             return !value1.Equals(value2);
         }
-        
+
         /// <summary>
         /// Returns this ray casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted ray</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Ray3D<TOther> As<TOther>() where TOther : INumberBase<TOther>
         {
             return new(Origin.As<TOther>(), Direction.As<TOther>());
diff --git a/sources/Maths/Maths/Rectangle.cs b/sources/Maths/Maths/Rectangle.cs
index db90d7032b..86198c30b8 100644
--- a/sources/Maths/Maths/Rectangle.cs
+++ b/sources/Maths/Maths/Rectangle.cs
@@ -164,10 +164,10 @@ public Rectangle<T> GetScaled(Vector2D<T> scale, Vector2D<T> anchor)
         public Rectangle<T> GetScaled<TScale>(Vector2D<TScale> scale, Vector2D<T> anchor)
             where TScale : INumberBase<TScale>
         {
-            var convertedAnchor = anchor.As<TScale>();
-            var min = (scale * (Origin.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            var max = (scale * (Max.As<TScale>() - convertedAnchor)) + convertedAnchor;
-            return new(min.As<T>(), (max - min).As<T>());
+            var convertedAnchor = anchor.AsTruncating<TScale>();
+            var min = (scale * (Origin.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            var max = (scale * (Max.AsTruncating<TScale>() - convertedAnchor)) + convertedAnchor;
+            return new(min.AsTruncating<T>(), (max - min).AsTruncating<T>());
         }
 
         /// <summary>
@@ -222,12 +222,13 @@ public override int GetHashCode()
         {
             return !value1.Equals(value2);
         }
-        
+
         /// <summary>
         /// Returns this rectangle casted to <typeparamref name="TOther"></typeparamref>
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted rectangle</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Rectangle<TOther> As<TOther>()
             where TOther : INumber<TOther>
         {
diff --git a/sources/Maths/Maths/Sphere.cs b/sources/Maths/Maths/Sphere.cs
index 759a13290a..7c44cf801c 100644
--- a/sources/Maths/Maths/Sphere.cs
+++ b/sources/Maths/Maths/Sphere.cs
@@ -170,6 +170,7 @@ public override int GetHashCode()
         /// </summary>
         /// <typeparam name="TOther">The type to cast to</typeparam>
         /// <returns>The casted sphere</returns>
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Sphere<TOther> As<TOther>()
             where TOther : IRootFunctions<TOther>
         {
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 3d7286547d..45d3b22c9e 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -316,11 +316,26 @@ public static Vector2D<T> CreateTruncating<TOther>(Vector2D<TOther> source)
             new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y));
 
         /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Vector2D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             Vector2D<TOther>.CreateTruncating(this);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector2D<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector2D<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector2D<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector2D<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector2D<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector2D<TOther>.CreateTruncating(this);
+
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T}"/> to a <see cref="Vector2D{T}"/>.</summary>
         public static implicit operator Vector2D<T>((T X, T Y) v) =>
             new(v.X, v.Y);
@@ -572,6 +587,7 @@ public static partial class Vector2D
         }
 
         /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="vector">The vector to deconstruct.</param>
         /// <param name="x">The X component.</param>
         /// <param name="y">The Y component.</param>
         public static void Deconstruct<T>(this Vector2D<T> vector, out T x, out T y)
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index b6572cd47f..2cf015c394 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -353,11 +353,26 @@ public static Vector3D<T> CreateTruncating<TOther>(Vector3D<TOther> source)
             new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y), T.CreateTruncating(source.Z));
 
         /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Vector3D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             Vector3D<TOther>.CreateTruncating(this);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector3D<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector3D<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector3D<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector3D<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector3D<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector3D<TOther>.CreateTruncating(this);
+
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T}"/> to a <see cref="Vector3D{T}"/>.</summary>
         public static implicit operator Vector3D<T>((T X, T Y, T Z) v) =>
             new(v.X, v.Y, v.Z);
@@ -609,6 +624,7 @@ public static partial class Vector3D
         }
 
         /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="vector">The vector to deconstruct.</param>
         /// <param name="x">The X component.</param>
         /// <param name="y">The Y component.</param>
         /// <param name="z">The Z component.</param>
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index ed84851eb8..ecd849ca15 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -390,11 +390,26 @@ public static Vector4D<T> CreateTruncating<TOther>(Vector4D<TOther> source)
             new(T.CreateTruncating(source.X), T.CreateTruncating(source.Y), T.CreateTruncating(source.Z), T.CreateTruncating(source.W));
 
         /// <summary>Converts the components of this vector to another type.</summary>
-        [Obsolete("Use CreateChecked, CreateSaturating, CreateTruncating, or a cast instead.", error: false)]
+        [Obsolete("Use AsChecked, AsSaturating, or AsTruncating instead.", error: false)]
         public Vector4D<TOther> As<TOther>()
             where TOther : INumberBase<TOther> =>
             Vector4D<TOther>.CreateTruncating(this);
 
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector4D<TOther> AsChecked<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector4D<TOther>.CreateChecked(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector4D<TOther> AsSaturating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector4D<TOther>.CreateSaturating(this);
+
+        /// <summary>Converts the components of this vector to another type.</summary>
+        public Vector4D<TOther> AsTruncating<TOther>()
+            where TOther : INumberBase<TOther> =>
+            Vector4D<TOther>.CreateTruncating(this);
+
         /// <summary>Implicitly casts a <see cref="ValueTuple{T, T, T, T}"/> to a <see cref="Vector4D{T}"/>.</summary>
         public static implicit operator Vector4D<T>((T X, T Y, T Z, T W) v) =>
             new(v.X, v.Y, v.Z, v.W);
@@ -646,6 +661,7 @@ public static partial class Vector4D
         }
 
         /// <summary>Desconstructs a vector into its components.</summary>
+        /// <param name="vector">The vector to deconstruct.</param>
         /// <param name="x">The X component.</param>
         /// <param name="y">The Y component.</param>
         /// <param name="z">The Z component.</param>

From 2d6c95bee1de0bb6d09eb97e9ee8dc2a3ec2bef4 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 20:59:46 -0700
Subject: [PATCH 51/52] XML Doc Comments.

---
 sources/Maths/Maths/Matrix2X2.gen.cs |  2 +-
 sources/Maths/Maths/Matrix2X3.gen.cs |  2 +-
 sources/Maths/Maths/Matrix2X4.gen.cs |  2 +-
 sources/Maths/Maths/Matrix3X2.gen.cs |  2 +-
 sources/Maths/Maths/Matrix3X3.gen.cs |  2 +-
 sources/Maths/Maths/Matrix3X4.gen.cs |  2 +-
 sources/Maths/Maths/Matrix4X2.gen.cs |  2 +-
 sources/Maths/Maths/Matrix4X3.gen.cs |  2 +-
 sources/Maths/Maths/Matrix4X4.gen.cs |  2 +-
 sources/Maths/Maths/Matrix5X4.gen.cs |  2 +-
 sources/Maths/Maths/Vector2D.gen.cs  | 54 ++++++++++++++++++++++++++++
 sources/Maths/Maths/Vector3D.gen.cs  | 54 ++++++++++++++++++++++++++++
 sources/Maths/Maths/Vector4D.gen.cs  | 54 ++++++++++++++++++++++++++++
 13 files changed, 172 insertions(+), 10 deletions(-)

diff --git a/sources/Maths/Maths/Matrix2X2.gen.cs b/sources/Maths/Maths/Matrix2X2.gen.cs
index c78d2f83c9..36d8a000cb 100644
--- a/sources/Maths/Maths/Matrix2X2.gen.cs
+++ b/sources/Maths/Maths/Matrix2X2.gen.cs
@@ -451,7 +451,7 @@ public static explicit operator checked Matrix2X2<ulong>(Matrix2X2<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix2X2{T}"/>
+    /// Methods for working with <see cref="Matrix2X2{T}"/>.
     /// </summary>
     public static partial class Matrix2X2
     {
diff --git a/sources/Maths/Maths/Matrix2X3.gen.cs b/sources/Maths/Maths/Matrix2X3.gen.cs
index f0a222eaae..bff4862b07 100644
--- a/sources/Maths/Maths/Matrix2X3.gen.cs
+++ b/sources/Maths/Maths/Matrix2X3.gen.cs
@@ -465,7 +465,7 @@ public static explicit operator checked Matrix2X3<ulong>(Matrix2X3<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix2X3{T}"/>
+    /// Methods for working with <see cref="Matrix2X3{T}"/>.
     /// </summary>
     public static partial class Matrix2X3
     {
diff --git a/sources/Maths/Maths/Matrix2X4.gen.cs b/sources/Maths/Maths/Matrix2X4.gen.cs
index ea7aed2896..708458f69b 100644
--- a/sources/Maths/Maths/Matrix2X4.gen.cs
+++ b/sources/Maths/Maths/Matrix2X4.gen.cs
@@ -489,7 +489,7 @@ public static explicit operator checked Matrix2X4<ulong>(Matrix2X4<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix2X4{T}"/>
+    /// Methods for working with <see cref="Matrix2X4{T}"/>.
     /// </summary>
     public static partial class Matrix2X4
     {
diff --git a/sources/Maths/Maths/Matrix3X2.gen.cs b/sources/Maths/Maths/Matrix3X2.gen.cs
index 8f27467b3a..792f84ebaa 100644
--- a/sources/Maths/Maths/Matrix3X2.gen.cs
+++ b/sources/Maths/Maths/Matrix3X2.gen.cs
@@ -501,7 +501,7 @@ public static explicit operator checked Matrix3X2<ulong>(Matrix3X2<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix3X2{T}"/>
+    /// Methods for working with <see cref="Matrix3X2{T}"/>.
     /// </summary>
     public static partial class Matrix3X2
     {
diff --git a/sources/Maths/Maths/Matrix3X3.gen.cs b/sources/Maths/Maths/Matrix3X3.gen.cs
index 5718ab5f6c..8bc8ec7c86 100644
--- a/sources/Maths/Maths/Matrix3X3.gen.cs
+++ b/sources/Maths/Maths/Matrix3X3.gen.cs
@@ -539,7 +539,7 @@ public static explicit operator checked Matrix3X3<ulong>(Matrix3X3<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix3X3{T}"/>
+    /// Methods for working with <see cref="Matrix3X3{T}"/>.
     /// </summary>
     public static partial class Matrix3X3
     {
diff --git a/sources/Maths/Maths/Matrix3X4.gen.cs b/sources/Maths/Maths/Matrix3X4.gen.cs
index 202f179523..2df43ee04c 100644
--- a/sources/Maths/Maths/Matrix3X4.gen.cs
+++ b/sources/Maths/Maths/Matrix3X4.gen.cs
@@ -558,7 +558,7 @@ public static explicit operator checked Matrix3X4<ulong>(Matrix3X4<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix3X4{T}"/>
+    /// Methods for working with <see cref="Matrix3X4{T}"/>.
     /// </summary>
     public static partial class Matrix3X4
     {
diff --git a/sources/Maths/Maths/Matrix4X2.gen.cs b/sources/Maths/Maths/Matrix4X2.gen.cs
index 7fa9e127b0..3b147c1b97 100644
--- a/sources/Maths/Maths/Matrix4X2.gen.cs
+++ b/sources/Maths/Maths/Matrix4X2.gen.cs
@@ -562,7 +562,7 @@ public static explicit operator checked Matrix4X2<ulong>(Matrix4X2<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix4X2{T}"/>
+    /// Methods for working with <see cref="Matrix4X2{T}"/>.
     /// </summary>
     public static partial class Matrix4X2
     {
diff --git a/sources/Maths/Maths/Matrix4X3.gen.cs b/sources/Maths/Maths/Matrix4X3.gen.cs
index 47e77e6519..85ef245f27 100644
--- a/sources/Maths/Maths/Matrix4X3.gen.cs
+++ b/sources/Maths/Maths/Matrix4X3.gen.cs
@@ -595,7 +595,7 @@ public static explicit operator checked Matrix4X3<ulong>(Matrix4X3<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix4X3{T}"/>
+    /// Methods for working with <see cref="Matrix4X3{T}"/>.
     /// </summary>
     public static partial class Matrix4X3
     {
diff --git a/sources/Maths/Maths/Matrix4X4.gen.cs b/sources/Maths/Maths/Matrix4X4.gen.cs
index 49bae4e98a..0fcdce95cf 100644
--- a/sources/Maths/Maths/Matrix4X4.gen.cs
+++ b/sources/Maths/Maths/Matrix4X4.gen.cs
@@ -640,7 +640,7 @@ public static explicit operator checked Matrix4X4<ulong>(Matrix4X4<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix4X4{T}"/>
+    /// Methods for working with <see cref="Matrix4X4{T}"/>.
     /// </summary>
     public static partial class Matrix4X4
     {
diff --git a/sources/Maths/Maths/Matrix5X4.gen.cs b/sources/Maths/Maths/Matrix5X4.gen.cs
index 7d95ce484a..6da344fa18 100644
--- a/sources/Maths/Maths/Matrix5X4.gen.cs
+++ b/sources/Maths/Maths/Matrix5X4.gen.cs
@@ -615,7 +615,7 @@ public static explicit operator checked Matrix5X4<ulong>(Matrix5X4<T> from) =>
     }
 
     /// <summary>
-    /// Methods for working with <see cref="Matrix5X4{T}"/>
+    /// Methods for working with <see cref="Matrix5X4{T}"/>.
     /// </summary>
     public static partial class Matrix5X4
     {
diff --git a/sources/Maths/Maths/Vector2D.gen.cs b/sources/Maths/Maths/Vector2D.gen.cs
index 45d3b22c9e..79b4f1297d 100644
--- a/sources/Maths/Maths/Vector2D.gen.cs
+++ b/sources/Maths/Maths/Vector2D.gen.cs
@@ -344,36 +344,78 @@ public static implicit operator Vector2D<T>((T X, T Y) v) =>
         public static implicit operator (T X, T Y)(Vector2D<T> v) =>
             (v.X, v.Y);
 
+        /// <summary>Returns the given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The source vector.</returns>
         public static Vector2D<T> operator +(Vector2D<T> vector) =>
             vector;
 
+        /// <summary>Negates a given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The negated vector.</returns>
         public static Vector2D<T> operator -(Vector2D<T> vector) =>
             new(-vector.X, -vector.Y);
 
+        /// <summary>Adds two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The summed vector.</returns>
         public static Vector2D<T> operator +(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X + right.X, left.Y + right.Y);
 
+        /// <summary>Subtracts the second vector from the first.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The difference vector.</returns>
         public static Vector2D<T> operator -(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X - right.X, left.Y - right.Y);
 
+        /// <summary>Multiplies two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The product vector.</returns>
         public static Vector2D<T> operator *(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X * right.X, left.Y * right.Y);
 
+        /// <summary>Divides the first vector by the second.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The vector resulting from the division.</returns>
         public static Vector2D<T> operator /(Vector2D<T> left, Vector2D<T> right) =>
             new(left.X / right.X, left.Y / right.Y);
 
+        /// <summary>Adds a scalar to the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector2D<T> operator +(Vector2D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar);
 
+        /// <summary>Subtracts a scalar from the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector2D<T> operator -(Vector2D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector2D<T> operator *(Vector2D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="scalar">The scalar value.</param>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector2D<T> operator *(T scalar, Vector2D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y);
 
+        /// <summary>Divides the vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The result of the division.</returns>
         public static Vector2D<T> operator /(Vector2D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar);
 
@@ -570,8 +612,12 @@ public static explicit operator checked Vector2D<ulong>(Vector2D<T> from) =>
             Vector2D<ulong>.CreateChecked(from);
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Vector2D{T}"/>.
+    /// </summary>
     public static partial class Vector2D
     {
+        /// <summary>Extensions for vectors with elements implementing <see cref="IRootFunctions{TSelf}"/>.</summary>
         extension<T>(Vector2D<T> vector)
             where T : IRootFunctions<T>
         {
@@ -579,6 +625,7 @@ public static partial class Vector2D
             public T Length => T.Sqrt(vector.LengthSquared);
         }
 
+        /// <summary>Extensions for vectors with elements implementing <see cref="INumberBase{TSelf}"/>.</summary>
         extension<T>(Vector2D<T> vector)
             where T : INumberBase<T>
         {
@@ -648,14 +695,21 @@ public static Vector2D<T> LerpClamped<T>(Vector2D<T> a, Vector2D<T> b, Vector2D<
             new(T.Lerp(a.X, b.X, T.Clamp(amount.X, T.Zero, T.One)),
                 T.Lerp(a.Y, b.Y, T.Clamp(amount.Y, T.Zero, T.One)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector2D<T> Sin, Vector2D<T> Cos) SinCos<T>(this Vector2D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.Sin(x.X), T.Sin(x.Y)), new(T.Cos(x.X), T.Cos(x.Y)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector2D<T> SinPi, Vector2D<T> CosPi) SinCosPi<T>(this Vector2D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.SinPi(x.X), T.SinPi(x.Y)), new(T.CosPi(x.X), T.CosPi(x.Y)));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.DivRem(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         public static (Vector2D<T> Quotient, Vector2D<T> Remainder) DivRem<T>(Vector2D<T> left, Vector2D<T> right)
             where T : IBinaryInteger<T>
         {
diff --git a/sources/Maths/Maths/Vector3D.gen.cs b/sources/Maths/Maths/Vector3D.gen.cs
index 2cf015c394..769dd516b2 100644
--- a/sources/Maths/Maths/Vector3D.gen.cs
+++ b/sources/Maths/Maths/Vector3D.gen.cs
@@ -381,36 +381,78 @@ public static implicit operator Vector3D<T>((T X, T Y, T Z) v) =>
         public static implicit operator (T X, T Y, T Z)(Vector3D<T> v) =>
             (v.X, v.Y, v.Z);
 
+        /// <summary>Returns the given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The source vector.</returns>
         public static Vector3D<T> operator +(Vector3D<T> vector) =>
             vector;
 
+        /// <summary>Negates a given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The negated vector.</returns>
         public static Vector3D<T> operator -(Vector3D<T> vector) =>
             new(-vector.X, -vector.Y, -vector.Z);
 
+        /// <summary>Adds two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The summed vector.</returns>
         public static Vector3D<T> operator +(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X + right.X, left.Y + right.Y, left.Z + right.Z);
 
+        /// <summary>Subtracts the second vector from the first.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The difference vector.</returns>
         public static Vector3D<T> operator -(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X - right.X, left.Y - right.Y, left.Z - right.Z);
 
+        /// <summary>Multiplies two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The product vector.</returns>
         public static Vector3D<T> operator *(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X * right.X, left.Y * right.Y, left.Z * right.Z);
 
+        /// <summary>Divides the first vector by the second.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The vector resulting from the division.</returns>
         public static Vector3D<T> operator /(Vector3D<T> left, Vector3D<T> right) =>
             new(left.X / right.X, left.Y / right.Y, left.Z / right.Z);
 
+        /// <summary>Adds a scalar to the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector3D<T> operator +(Vector3D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar);
 
+        /// <summary>Subtracts a scalar from the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector3D<T> operator -(Vector3D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector3D<T> operator *(Vector3D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="scalar">The scalar value.</param>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector3D<T> operator *(T scalar, Vector3D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z);
 
+        /// <summary>Divides the vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The result of the division.</returns>
         public static Vector3D<T> operator /(Vector3D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar);
 
@@ -607,8 +649,12 @@ public static explicit operator checked Vector3D<ulong>(Vector3D<T> from) =>
             Vector3D<ulong>.CreateChecked(from);
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Vector3D{T}"/>.
+    /// </summary>
     public static partial class Vector3D
     {
+        /// <summary>Extensions for vectors with elements implementing <see cref="IRootFunctions{TSelf}"/>.</summary>
         extension<T>(Vector3D<T> vector)
             where T : IRootFunctions<T>
         {
@@ -616,6 +662,7 @@ public static partial class Vector3D
             public T Length => T.Sqrt(vector.LengthSquared);
         }
 
+        /// <summary>Extensions for vectors with elements implementing <see cref="INumberBase{TSelf}"/>.</summary>
         extension<T>(Vector3D<T> vector)
             where T : INumberBase<T>
         {
@@ -688,14 +735,21 @@ public static Vector3D<T> LerpClamped<T>(Vector3D<T> a, Vector3D<T> b, Vector3D<
                 T.Lerp(a.Y, b.Y, T.Clamp(amount.Y, T.Zero, T.One)),
                 T.Lerp(a.Z, b.Z, T.Clamp(amount.Z, T.Zero, T.One)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector3D<T> Sin, Vector3D<T> Cos) SinCos<T>(this Vector3D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.Sin(x.X), T.Sin(x.Y), T.Sin(x.Z)), new(T.Cos(x.X), T.Cos(x.Y), T.Cos(x.Z)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector3D<T> SinPi, Vector3D<T> CosPi) SinCosPi<T>(this Vector3D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.SinPi(x.X), T.SinPi(x.Y), T.SinPi(x.Z)), new(T.CosPi(x.X), T.CosPi(x.Y), T.CosPi(x.Z)));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.DivRem(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         public static (Vector3D<T> Quotient, Vector3D<T> Remainder) DivRem<T>(Vector3D<T> left, Vector3D<T> right)
             where T : IBinaryInteger<T>
         {
diff --git a/sources/Maths/Maths/Vector4D.gen.cs b/sources/Maths/Maths/Vector4D.gen.cs
index ecd849ca15..6f7e2d978c 100644
--- a/sources/Maths/Maths/Vector4D.gen.cs
+++ b/sources/Maths/Maths/Vector4D.gen.cs
@@ -418,36 +418,78 @@ public static implicit operator Vector4D<T>((T X, T Y, T Z, T W) v) =>
         public static implicit operator (T X, T Y, T Z, T W)(Vector4D<T> v) =>
             (v.X, v.Y, v.Z, v.W);
 
+        /// <summary>Returns the given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The source vector.</returns>
         public static Vector4D<T> operator +(Vector4D<T> vector) =>
             vector;
 
+        /// <summary>Negates a given vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The negated vector.</returns>
         public static Vector4D<T> operator -(Vector4D<T> vector) =>
             new(-vector.X, -vector.Y, -vector.Z, -vector.W);
 
+        /// <summary>Adds two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The summed vector.</returns>
         public static Vector4D<T> operator +(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X + right.X, left.Y + right.Y, left.Z + right.Z, left.W + right.W);
 
+        /// <summary>Subtracts the second vector from the first.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The difference vector.</returns>
         public static Vector4D<T> operator -(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X - right.X, left.Y - right.Y, left.Z - right.Z, left.W - right.W);
 
+        /// <summary>Multiplies two vectors together.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The product vector.</returns>
         public static Vector4D<T> operator *(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X * right.X, left.Y * right.Y, left.Z * right.Z, left.W * right.W);
 
+        /// <summary>Divides the first vector by the second.</summary>
+        /// <param name="left">The first source vector.</param>
+        /// <param name="right">The second source vector.</param>
+        /// <returns>The vector resulting from the division.</returns>
         public static Vector4D<T> operator /(Vector4D<T> left, Vector4D<T> right) =>
             new(left.X / right.X, left.Y / right.Y, left.Z / right.Z, left.W / right.W);
 
+        /// <summary>Adds a scalar to the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector4D<T> operator +(Vector4D<T> vector, T scalar) =>
             new(vector.X + scalar, vector.Y + scalar, vector.Z + scalar, vector.W + scalar);
 
+        /// <summary>Subtracts a scalar from the components of a vector.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The offset vector.</returns>
         public static Vector4D<T> operator -(Vector4D<T> vector, T scalar) =>
             new(vector.X - scalar, vector.Y - scalar, vector.Z - scalar, vector.W - scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector4D<T> operator *(Vector4D<T> vector, T scalar) =>
             new(vector.X * scalar, vector.Y * scalar, vector.Z * scalar, vector.W * scalar);
 
+        /// <summary>Multiplies a vector by the given scalar.</summary>
+        /// <param name="scalar">The scalar value.</param>
+        /// <param name="vector">The source vector.</param>
+        /// <returns>The scaled vector.</returns>
         public static Vector4D<T> operator *(T scalar, Vector4D<T> vector) =>
             new(scalar * vector.X, scalar * vector.Y, scalar * vector.Z, scalar * vector.W);
 
+        /// <summary>Divides the vector by the given scalar.</summary>
+        /// <param name="vector">The source vector.</param>
+        /// <param name="scalar">The scalar value.</param>
+        /// <returns>The result of the division.</returns>
         public static Vector4D<T> operator /(Vector4D<T> vector, T scalar) =>
             new(vector.X / scalar, vector.Y / scalar, vector.Z / scalar, vector.W / scalar);
 
@@ -644,8 +686,12 @@ public static explicit operator checked Vector4D<ulong>(Vector4D<T> from) =>
             Vector4D<ulong>.CreateChecked(from);
     }
 
+    /// <summary>
+    /// Methods for working with <see cref="Vector4D{T}"/>.
+    /// </summary>
     public static partial class Vector4D
     {
+        /// <summary>Extensions for vectors with elements implementing <see cref="IRootFunctions{TSelf}"/>.</summary>
         extension<T>(Vector4D<T> vector)
             where T : IRootFunctions<T>
         {
@@ -653,6 +699,7 @@ public static partial class Vector4D
             public T Length => T.Sqrt(vector.LengthSquared);
         }
 
+        /// <summary>Extensions for vectors with elements implementing <see cref="INumberBase{TSelf}"/>.</summary>
         extension<T>(Vector4D<T> vector)
             where T : INumberBase<T>
         {
@@ -728,14 +775,21 @@ public static Vector4D<T> LerpClamped<T>(Vector4D<T> a, Vector4D<T> b, Vector4D<
                 T.Lerp(a.Z, b.Z, T.Clamp(amount.Z, T.Zero, T.One)),
                 T.Lerp(a.W, b.W, T.Clamp(amount.W, T.Zero, T.One)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCos(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector4D<T> Sin, Vector4D<T> Cos) SinCos<T>(this Vector4D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.Sin(x.X), T.Sin(x.Y), T.Sin(x.Z), T.Sin(x.W)), new(T.Cos(x.X), T.Cos(x.Y), T.Cos(x.Z), T.Cos(x.W)));
 
+        /// <summary>Applies <see cref="ITrigonometricFunctions{TSelf}.SinCosPi(TSelf)"/> to the provided arguments.</summary>
+        /// <param name="x">A vector whose members will be provided for <parameref name="x"/>.</param>
         public static (Vector4D<T> SinPi, Vector4D<T> CosPi) SinCosPi<T>(this Vector4D<T> x)
             where T : ITrigonometricFunctions<T> =>
             (new(T.SinPi(x.X), T.SinPi(x.Y), T.SinPi(x.Z), T.SinPi(x.W)), new(T.CosPi(x.X), T.CosPi(x.Y), T.CosPi(x.Z), T.CosPi(x.W)));
 
+        /// <summary>Applies <see cref="IBinaryInteger{TSelf}.DivRem(TSelf, TSelf)"/> to the provided arguments.</summary>
+        /// <param name="left">A vector whose members will be provided for <parameref name="left"/>.</param>
+        /// <param name="right">A vector whose members will be provided for <parameref name="right"/>.</param>
         public static (Vector4D<T> Quotient, Vector4D<T> Remainder) DivRem<T>(Vector4D<T> left, Vector4D<T> right)
             where T : IBinaryInteger<T>
         {

From 1c2b6f87becb358dd0c44f1e2c79437c490ec684 Mon Sep 17 00:00:00 2001
From: John Gietzen <john@gietzen.us>
Date: Wed, 2 Jul 2025 21:15:23 -0700
Subject: [PATCH 52/52] Reset APIs.

---
 .../PublicAPI/net8.0/PublicAPI.Shipped.txt    | 1418 -------------
 .../PublicAPI/net8.0/PublicAPI.Unshipped.txt  | 1872 +++++++++++++++++
 2 files changed, 1872 insertions(+), 1418 deletions(-)

diff --git a/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Shipped.txt b/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Shipped.txt
index 3552eec334..7dc5c58110 100644
--- a/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Shipped.txt
+++ b/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Shipped.txt
@@ -1,1419 +1 @@
 #nullable enable
-override Silk.NET.Maths.Box2D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Box2D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Box3D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Box3D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Circle<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Circle<T>.GetHashCode() -> int
-override Silk.NET.Maths.Cube<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Cube<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix2X2<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix2X2<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix2X2<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix2X3<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix2X3<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix2X3<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix2X4<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix2X4<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix2X4<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix3X2<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix3X2<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix3X2<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix3X3<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix3X3<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix3X3<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix3X4<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix3X4<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix3X4<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix4X2<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix4X2<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix4X2<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix4X3<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix4X3<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix4X3<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix4X4<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix4X4<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix4X4<T>.ToString() -> string!
-override Silk.NET.Maths.Matrix5X4<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Matrix5X4<T>.GetHashCode() -> int
-override Silk.NET.Maths.Matrix5X4<T>.ToString() -> string!
-override Silk.NET.Maths.Plane<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Plane<T>.GetHashCode() -> int
-override Silk.NET.Maths.Plane<T>.ToString() -> string!
-override Silk.NET.Maths.Quaternion<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Quaternion<T>.GetHashCode() -> int
-override Silk.NET.Maths.Quaternion<T>.ToString() -> string!
-override Silk.NET.Maths.Ray2D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Ray2D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Ray3D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Ray3D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Rectangle<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Rectangle<T>.GetHashCode() -> int
-override Silk.NET.Maths.Sphere<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Sphere<T>.GetHashCode() -> int
-override Silk.NET.Maths.Vector2D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Vector2D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Vector2D<T>.ToString() -> string!
-override Silk.NET.Maths.Vector3D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Vector3D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Vector3D<T>.ToString() -> string!
-override Silk.NET.Maths.Vector4D<T>.Equals(object? obj) -> bool
-override Silk.NET.Maths.Vector4D<T>.GetHashCode() -> int
-override Silk.NET.Maths.Vector4D<T>.ToString() -> string!
-Silk.NET.Maths.Box2D<T>
-Silk.NET.Maths.Box2D<T>.As<TOther>() -> Silk.NET.Maths.Box2D<TOther>
-Silk.NET.Maths.Box2D<T>.Box2D() -> void
-Silk.NET.Maths.Box2D<T>.Box2D(Silk.NET.Maths.Vector2D<T> min, Silk.NET.Maths.Vector2D<T> max) -> void
-Silk.NET.Maths.Box2D<T>.Box2D(Silk.NET.Maths.Vector2D<T> min, T maxX, T maxY) -> void
-Silk.NET.Maths.Box2D<T>.Box2D(T minX, T minY, Silk.NET.Maths.Vector2D<T> max) -> void
-Silk.NET.Maths.Box2D<T>.Box2D(T minX, T minY, T maxX, T maxY) -> void
-Silk.NET.Maths.Box2D<T>.Center.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Box2D<T>.Contains(Silk.NET.Maths.Box2D<T> other) -> bool
-Silk.NET.Maths.Box2D<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
-Silk.NET.Maths.Box2D<T>.Equals(Silk.NET.Maths.Box2D<T> other) -> bool
-Silk.NET.Maths.Box2D<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
-Silk.NET.Maths.Box2D<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Box2D<T>
-Silk.NET.Maths.Box2D<T>.GetScaled(Silk.NET.Maths.Vector2D<T> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Box2D<T>
-Silk.NET.Maths.Box2D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Box2D<T>
-Silk.NET.Maths.Box2D<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Box2D<T>
-Silk.NET.Maths.Box2D<T>.Max -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Box2D<T>.Min -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Box2D<T>.Size.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Box3D<T>
-Silk.NET.Maths.Box3D<T>.As<TOther>() -> Silk.NET.Maths.Box3D<TOther>
-Silk.NET.Maths.Box3D<T>.Box3D() -> void
-Silk.NET.Maths.Box3D<T>.Box3D(Silk.NET.Maths.Vector3D<T> min, Silk.NET.Maths.Vector3D<T> max) -> void
-Silk.NET.Maths.Box3D<T>.Box3D(Silk.NET.Maths.Vector3D<T> min, T maxX, T maxY, T maxZ) -> void
-Silk.NET.Maths.Box3D<T>.Box3D(T minX, T minY, T minZ, Silk.NET.Maths.Vector3D<T> max) -> void
-Silk.NET.Maths.Box3D<T>.Box3D(T minX, T minY, T minZ, T maxX, T maxY, T maxZ) -> void
-Silk.NET.Maths.Box3D<T>.Center.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Box3D<T>.Contains(Silk.NET.Maths.Box3D<T> other) -> bool
-Silk.NET.Maths.Box3D<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
-Silk.NET.Maths.Box3D<T>.Equals(Silk.NET.Maths.Box3D<T> other) -> bool
-Silk.NET.Maths.Box3D<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
-Silk.NET.Maths.Box3D<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Box3D<T>
-Silk.NET.Maths.Box3D<T>.GetScaled(Silk.NET.Maths.Vector3D<T> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Box3D<T>
-Silk.NET.Maths.Box3D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Box3D<T>
-Silk.NET.Maths.Box3D<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Box3D<T>
-Silk.NET.Maths.Box3D<T>.Max -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Box3D<T>.Min -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Box3D<T>.Size.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Circle<T>
-Silk.NET.Maths.Circle<T>.As<TOther>() -> Silk.NET.Maths.Circle<TOther>
-Silk.NET.Maths.Circle<T>.Center -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Circle<T>.Circle() -> void
-Silk.NET.Maths.Circle<T>.Circle(Silk.NET.Maths.Vector2D<T> center, T radius) -> void
-Silk.NET.Maths.Circle<T>.Circle(T centerX, T centerY, T radius) -> void
-Silk.NET.Maths.Circle<T>.Circumference.get -> T
-Silk.NET.Maths.Circle<T>.Contains(Silk.NET.Maths.Circle<T> other) -> bool
-Silk.NET.Maths.Circle<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
-Silk.NET.Maths.Circle<T>.Diameter.get -> T
-Silk.NET.Maths.Circle<T>.Equals(Silk.NET.Maths.Circle<T> other) -> bool
-Silk.NET.Maths.Circle<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
-Silk.NET.Maths.Circle<T>.GetDistanceToNearestEdgeSquared(Silk.NET.Maths.Vector2D<T> point) -> T
-Silk.NET.Maths.Circle<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Circle<T>
-Silk.NET.Maths.Circle<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Circle<T>
-Silk.NET.Maths.Circle<T>.Radius -> T
-Silk.NET.Maths.Circle<T>.SquaredRadius.get -> T
-Silk.NET.Maths.Cube<T>
-Silk.NET.Maths.Cube<T>.As<TOther>() -> Silk.NET.Maths.Cube<TOther>
-Silk.NET.Maths.Cube<T>.Center.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Cube<T>.Contains(Silk.NET.Maths.Cube<T> other) -> bool
-Silk.NET.Maths.Cube<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
-Silk.NET.Maths.Cube<T>.Cube() -> void
-Silk.NET.Maths.Cube<T>.Cube(Silk.NET.Maths.Vector3D<T> origin, Silk.NET.Maths.Vector3D<T> size) -> void
-Silk.NET.Maths.Cube<T>.Cube(Silk.NET.Maths.Vector3D<T> origin, T sizeX, T sizeY, T sizeZ) -> void
-Silk.NET.Maths.Cube<T>.Cube(T originX, T originY, T originZ, Silk.NET.Maths.Vector3D<T> size) -> void
-Silk.NET.Maths.Cube<T>.Cube(T originX, T originY, T originZ, T sizeX, T sizeY, T sizeZ) -> void
-Silk.NET.Maths.Cube<T>.Equals(Silk.NET.Maths.Cube<T> other) -> bool
-Silk.NET.Maths.Cube<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
-Silk.NET.Maths.Cube<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Cube<T>
-Silk.NET.Maths.Cube<T>.GetScaled(Silk.NET.Maths.Vector3D<T> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
-Silk.NET.Maths.Cube<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
-Silk.NET.Maths.Cube<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Cube<T>
-Silk.NET.Maths.Cube<T>.HalfSize.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Cube<T>.Max.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Cube<T>.Origin -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Cube<T>.Size -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix2X2
-Silk.NET.Maths.Matrix2X2<T>
-Silk.NET.Maths.Matrix2X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X2<TOther>
-Silk.NET.Maths.Matrix2X2<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X2<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X2<T>.Equals(Silk.NET.Maths.Matrix2X2<T> other) -> bool
-Silk.NET.Maths.Matrix2X2<T>.GetDeterminant() -> T
-Silk.NET.Maths.Matrix2X2<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix2X2<T>.M11.get -> T
-Silk.NET.Maths.Matrix2X2<T>.M11.set -> void
-Silk.NET.Maths.Matrix2X2<T>.M12.get -> T
-Silk.NET.Maths.Matrix2X2<T>.M12.set -> void
-Silk.NET.Maths.Matrix2X2<T>.M21.get -> T
-Silk.NET.Maths.Matrix2X2<T>.M21.set -> void
-Silk.NET.Maths.Matrix2X2<T>.M22.get -> T
-Silk.NET.Maths.Matrix2X2<T>.M22.set -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2() -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2) -> void
-Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(T m11, T m12, T m21, T m22) -> void
-Silk.NET.Maths.Matrix2X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X2<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix2X2<T>.this[int x].get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X3
-Silk.NET.Maths.Matrix2X3<T>
-Silk.NET.Maths.Matrix2X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X3<TOther>
-Silk.NET.Maths.Matrix2X3<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X3<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X3<T>.Column3.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X3<T>.Equals(Silk.NET.Maths.Matrix2X3<T> other) -> bool
-Silk.NET.Maths.Matrix2X3<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix2X3<T>.M11.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M11.set -> void
-Silk.NET.Maths.Matrix2X3<T>.M12.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M12.set -> void
-Silk.NET.Maths.Matrix2X3<T>.M13.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M13.set -> void
-Silk.NET.Maths.Matrix2X3<T>.M21.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M21.set -> void
-Silk.NET.Maths.Matrix2X3<T>.M22.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M22.set -> void
-Silk.NET.Maths.Matrix2X3<T>.M23.get -> T
-Silk.NET.Maths.Matrix2X3<T>.M23.set -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3() -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2) -> void
-Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(T m11, T m12, T m13, T m21, T m22, T m23) -> void
-Silk.NET.Maths.Matrix2X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix2X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix2X3<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix2X3<T>.this[int x].get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix2X4
-Silk.NET.Maths.Matrix2X4<T>
-Silk.NET.Maths.Matrix2X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X4<TOther>
-Silk.NET.Maths.Matrix2X4<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X4<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X4<T>.Column3.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X4<T>.Column4.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix2X4<T>.Equals(Silk.NET.Maths.Matrix2X4<T> other) -> bool
-Silk.NET.Maths.Matrix2X4<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix2X4<T>.M11.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M11.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M12.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M12.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M13.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M13.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M14.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M14.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M21.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M21.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M22.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M22.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M23.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M23.set -> void
-Silk.NET.Maths.Matrix2X4<T>.M24.get -> T
-Silk.NET.Maths.Matrix2X4<T>.M24.set -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4() -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2) -> void
-Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24) -> void
-Silk.NET.Maths.Matrix2X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix2X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix2X4<T>.this[int x, int j].get -> T
-Silk.NET.Maths.Matrix2X4<T>.this[int x].get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix3X2
-Silk.NET.Maths.Matrix3X2<T>
-Silk.NET.Maths.Matrix3X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X2<TOther>
-Silk.NET.Maths.Matrix3X2<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X2<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X2<T>.Equals(Silk.NET.Maths.Matrix3X2<T> other) -> bool
-Silk.NET.Maths.Matrix3X2<T>.GetDeterminant() -> T
-Silk.NET.Maths.Matrix3X2<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix3X2<T>.M11.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M11.set -> void
-Silk.NET.Maths.Matrix3X2<T>.M12.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M12.set -> void
-Silk.NET.Maths.Matrix3X2<T>.M21.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M21.set -> void
-Silk.NET.Maths.Matrix3X2<T>.M22.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M22.set -> void
-Silk.NET.Maths.Matrix3X2<T>.M31.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M31.set -> void
-Silk.NET.Maths.Matrix3X2<T>.M32.get -> T
-Silk.NET.Maths.Matrix3X2<T>.M32.set -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2() -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2, Silk.NET.Maths.Vector2D<T> row3) -> void
-Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(T m11, T m12, T m21, T m22, T m31, T m32) -> void
-Silk.NET.Maths.Matrix3X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix3X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix3X2<T>.Row3 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix3X2<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix3X2<T>.this[int x].get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix3X3
-Silk.NET.Maths.Matrix3X3<T>
-Silk.NET.Maths.Matrix3X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X3<TOther>
-Silk.NET.Maths.Matrix3X3<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.Column3.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.Equals(Silk.NET.Maths.Matrix3X3<T> other) -> bool
-Silk.NET.Maths.Matrix3X3<T>.GetDeterminant() -> T
-Silk.NET.Maths.Matrix3X3<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix3X3<T>.M11.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M11.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M12.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M12.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M13.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M13.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M21.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M21.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M22.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M22.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M23.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M23.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M31.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M31.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M32.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M32.set -> void
-Silk.NET.Maths.Matrix3X3<T>.M33.get -> T
-Silk.NET.Maths.Matrix3X3<T>.M33.set -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3() -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X4<T> value) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2, Silk.NET.Maths.Vector3D<T> row3) -> void
-Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33) -> void
-Silk.NET.Maths.Matrix3X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.Row3 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X3<T>.this[int x, int i].get -> T
-Silk.NET.Maths.Matrix3X3<T>.this[int x].get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X4
-Silk.NET.Maths.Matrix3X4<T>
-Silk.NET.Maths.Matrix3X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X4<TOther>
-Silk.NET.Maths.Matrix3X4<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X4<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X4<T>.Column3.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X4<T>.Column4.get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix3X4<T>.Equals(Silk.NET.Maths.Matrix3X4<T> other) -> bool
-Silk.NET.Maths.Matrix3X4<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix3X4<T>.M11.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M11.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M12.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M12.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M13.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M13.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M14.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M14.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M21.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M21.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M22.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M22.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M23.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M23.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M24.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M24.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M31.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M31.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M32.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M32.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M33.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M33.set -> void
-Silk.NET.Maths.Matrix3X4<T>.M34.get -> T
-Silk.NET.Maths.Matrix3X4<T>.M34.set -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4() -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3) -> void
-Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34) -> void
-Silk.NET.Maths.Matrix3X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix3X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix3X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix3X4<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix3X4<T>.this[int x].get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X2
-Silk.NET.Maths.Matrix4X2<T>
-Silk.NET.Maths.Matrix4X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X2<TOther>
-Silk.NET.Maths.Matrix4X2<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X2<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X2<T>.Equals(Silk.NET.Maths.Matrix4X2<T> other) -> bool
-Silk.NET.Maths.Matrix4X2<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix4X2<T>.M11.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M11.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M12.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M12.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M21.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M21.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M22.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M22.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M31.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M31.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M32.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M32.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M41.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M41.set -> void
-Silk.NET.Maths.Matrix4X2<T>.M42.get -> T
-Silk.NET.Maths.Matrix4X2<T>.M42.set -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2() -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2, Silk.NET.Maths.Vector2D<T> row3, Silk.NET.Maths.Vector2D<T> row4) -> void
-Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(T m11, T m12, T m21, T m22, T m31, T m32, T m41, T m42) -> void
-Silk.NET.Maths.Matrix4X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix4X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix4X2<T>.Row3 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix4X2<T>.Row4 -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix4X2<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix4X2<T>.this[int x].get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Matrix4X3
-Silk.NET.Maths.Matrix4X3<T>
-Silk.NET.Maths.Matrix4X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X3<TOther>
-Silk.NET.Maths.Matrix4X3<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X3<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X3<T>.Column3.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X3<T>.Equals(Silk.NET.Maths.Matrix4X3<T> other) -> bool
-Silk.NET.Maths.Matrix4X3<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix4X3<T>.M11.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M11.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M12.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M12.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M13.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M13.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M21.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M21.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M22.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M22.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M23.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M23.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M31.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M31.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M32.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M32.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M33.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M33.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M41.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M41.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M42.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M42.set -> void
-Silk.NET.Maths.Matrix4X3<T>.M43.get -> T
-Silk.NET.Maths.Matrix4X3<T>.M43.set -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3() -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X4<T> value) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2, Silk.NET.Maths.Vector3D<T> row3, Silk.NET.Maths.Vector3D<T> row4) -> void
-Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33, T m41, T m42, T m43) -> void
-Silk.NET.Maths.Matrix4X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix4X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix4X3<T>.Row3 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix4X3<T>.Row4 -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix4X3<T>.this[int x, int i].get -> T
-Silk.NET.Maths.Matrix4X3<T>.this[int x].get -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Matrix4X4
-Silk.NET.Maths.Matrix4X4<T>
-Silk.NET.Maths.Matrix4X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X4<TOther>
-Silk.NET.Maths.Matrix4X4<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Column3.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Column4.get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Equals(Silk.NET.Maths.Matrix4X4<T> other) -> bool
-Silk.NET.Maths.Matrix4X4<T>.GetDeterminant() -> T
-Silk.NET.Maths.Matrix4X4<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix4X4<T>.M11.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M11.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M12.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M12.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M13.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M13.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M14.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M14.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M21.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M21.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M22.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M22.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M23.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M23.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M24.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M24.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M31.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M31.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M32.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M32.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M33.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M33.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M34.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M34.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M41.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M41.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M42.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M42.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M43.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M43.set -> void
-Silk.NET.Maths.Matrix4X4<T>.M44.get -> T
-Silk.NET.Maths.Matrix4X4<T>.M44.set -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4() -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3, Silk.NET.Maths.Vector4D<T> row4) -> void
-Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34, T m41, T m42, T m43, T m44) -> void
-Silk.NET.Maths.Matrix4X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.Row4 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix4X4<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix4X4<T>.this[int x].get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4
-Silk.NET.Maths.Matrix5X4<T>
-Silk.NET.Maths.Matrix5X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix5X4<TOther>
-Silk.NET.Maths.Matrix5X4<T>.Equals(Silk.NET.Maths.Matrix5X4<T> other) -> bool
-Silk.NET.Maths.Matrix5X4<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Matrix5X4<T>.M11.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M11.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M12.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M12.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M13.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M13.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M14.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M14.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M21.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M21.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M22.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M22.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M23.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M23.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M24.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M24.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M31.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M31.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M32.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M32.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M33.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M33.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M34.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M34.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M41.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M41.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M42.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M42.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M43.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M43.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M44.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M44.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M51.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M51.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M52.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M52.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M53.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M53.set -> void
-Silk.NET.Maths.Matrix5X4<T>.M54.get -> T
-Silk.NET.Maths.Matrix5X4<T>.M54.set -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4() -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X4<T> value) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3, Silk.NET.Maths.Vector4D<T> row4, Silk.NET.Maths.Vector4D<T> row5) -> void
-Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34, T m41, T m42, T m43, T m44, T m51, T m52, T m53, T m54) -> void
-Silk.NET.Maths.Matrix5X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4<T>.Row4 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4<T>.Row5 -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Matrix5X4<T>.this[int x, int y].get -> T
-Silk.NET.Maths.Matrix5X4<T>.this[int x].get -> Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Plane
-Silk.NET.Maths.Plane<T>
-Silk.NET.Maths.Plane<T>.As<TOther>() -> Silk.NET.Maths.Plane<TOther>
-Silk.NET.Maths.Plane<T>.Distance -> T
-Silk.NET.Maths.Plane<T>.Equals(Silk.NET.Maths.Plane<T> other) -> bool
-Silk.NET.Maths.Plane<T>.Normal -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Plane<T>.Plane() -> void
-Silk.NET.Maths.Plane<T>.Plane(Silk.NET.Maths.Vector3D<T> normal, T distance) -> void
-Silk.NET.Maths.Plane<T>.Plane(Silk.NET.Maths.Vector4D<T> value) -> void
-Silk.NET.Maths.Plane<T>.Plane(T x, T y, T z, T distance) -> void
-Silk.NET.Maths.Quaternion<T>
-Silk.NET.Maths.Quaternion<T>.As<TOther>() -> Silk.NET.Maths.Quaternion<TOther>
-Silk.NET.Maths.Quaternion<T>.Equals(Silk.NET.Maths.Quaternion<T> other) -> bool
-Silk.NET.Maths.Quaternion<T>.IsIdentity.get -> bool
-Silk.NET.Maths.Quaternion<T>.Length() -> T
-Silk.NET.Maths.Quaternion<T>.LengthSquared() -> T
-Silk.NET.Maths.Quaternion<T>.Quaternion() -> void
-Silk.NET.Maths.Quaternion<T>.Quaternion(Silk.NET.Maths.Vector3D<T> vectorPart, T scalarPart) -> void
-Silk.NET.Maths.Quaternion<T>.Quaternion(T x, T y, T z, T w) -> void
-Silk.NET.Maths.Quaternion<T>.W -> T
-Silk.NET.Maths.Quaternion<T>.X -> T
-Silk.NET.Maths.Quaternion<T>.Y -> T
-Silk.NET.Maths.Quaternion<T>.Z -> T
-Silk.NET.Maths.Ray2D<T>
-Silk.NET.Maths.Ray2D<T>.As<TOther>() -> Silk.NET.Maths.Ray2D<TOther>
-Silk.NET.Maths.Ray2D<T>.Direction -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Ray2D<T>.Equals(Silk.NET.Maths.Ray2D<T> other) -> bool
-Silk.NET.Maths.Ray2D<T>.GetPoint(T distance) -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Ray2D<T>.Origin -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Ray2D<T>.Ray2D() -> void
-Silk.NET.Maths.Ray2D<T>.Ray2D(Silk.NET.Maths.Vector2D<T> origin, Silk.NET.Maths.Vector2D<T> direction) -> void
-Silk.NET.Maths.Ray2D<T>.Ray2D(Silk.NET.Maths.Vector2D<T> origin, T directionX, T directionY) -> void
-Silk.NET.Maths.Ray2D<T>.Ray2D(T originX, T originY, Silk.NET.Maths.Vector2D<T> direction) -> void
-Silk.NET.Maths.Ray2D<T>.Ray2D(T originX, T originY, T directionX, T directionY) -> void
-Silk.NET.Maths.Ray3D<T>
-Silk.NET.Maths.Ray3D<T>.As<TOther>() -> Silk.NET.Maths.Ray3D<TOther>
-Silk.NET.Maths.Ray3D<T>.Direction -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Ray3D<T>.Equals(Silk.NET.Maths.Ray3D<T> other) -> bool
-Silk.NET.Maths.Ray3D<T>.GetPoint(T distance) -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Ray3D<T>.Origin -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Ray3D<T>.Ray3D() -> void
-Silk.NET.Maths.Ray3D<T>.Ray3D(Silk.NET.Maths.Vector3D<T> origin, Silk.NET.Maths.Vector3D<T> direction) -> void
-Silk.NET.Maths.Ray3D<T>.Ray3D(Silk.NET.Maths.Vector3D<T> origin, T directionX, T directionY, T directionZ) -> void
-Silk.NET.Maths.Ray3D<T>.Ray3D(T originX, T originY, T originZ, Silk.NET.Maths.Vector3D<T> direction) -> void
-Silk.NET.Maths.Ray3D<T>.Ray3D(T originX, T originY, T originZ, T directionX, T directionY, T directionZ) -> void
-Silk.NET.Maths.Rectangle
-Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Rectangle<T>.As<TOther>() -> Silk.NET.Maths.Rectangle<TOther>
-Silk.NET.Maths.Rectangle<T>.Center.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Rectangle<T>.Contains(Silk.NET.Maths.Rectangle<T> other) -> bool
-Silk.NET.Maths.Rectangle<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
-Silk.NET.Maths.Rectangle<T>.Equals(Silk.NET.Maths.Rectangle<T> other) -> bool
-Silk.NET.Maths.Rectangle<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
-Silk.NET.Maths.Rectangle<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Rectangle<T>.GetScaled(Silk.NET.Maths.Vector2D<T> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Rectangle<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Rectangle<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Rectangle<T>
-Silk.NET.Maths.Rectangle<T>.HalfSize.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Rectangle<T>.Max.get -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Rectangle<T>.Origin -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Rectangle<T>.Rectangle() -> void
-Silk.NET.Maths.Rectangle<T>.Rectangle(Silk.NET.Maths.Vector2D<T> origin, Silk.NET.Maths.Vector2D<T> size) -> void
-Silk.NET.Maths.Rectangle<T>.Rectangle(Silk.NET.Maths.Vector2D<T> origin, T sizeX, T sizeY) -> void
-Silk.NET.Maths.Rectangle<T>.Rectangle(T originX, T originY, Silk.NET.Maths.Vector2D<T> size) -> void
-Silk.NET.Maths.Rectangle<T>.Rectangle(T originX, T originY, T sizeX, T sizeY) -> void
-Silk.NET.Maths.Rectangle<T>.Size -> Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Scalar
-Silk.NET.Maths.Scalar<T>
-Silk.NET.Maths.Sphere<T>
-Silk.NET.Maths.Sphere<T>.As<TOther>() -> Silk.NET.Maths.Sphere<TOther>
-Silk.NET.Maths.Sphere<T>.Center -> Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Sphere<T>.Contains(Silk.NET.Maths.Sphere<T> other) -> bool
-Silk.NET.Maths.Sphere<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
-Silk.NET.Maths.Sphere<T>.Diameter.get -> T
-Silk.NET.Maths.Sphere<T>.Equals(Silk.NET.Maths.Sphere<T> other) -> bool
-Silk.NET.Maths.Sphere<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
-Silk.NET.Maths.Sphere<T>.GetDistanceToNearestEdgeSquared(Silk.NET.Maths.Vector3D<T> point) -> T
-Silk.NET.Maths.Sphere<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Sphere<T>
-Silk.NET.Maths.Sphere<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Sphere<T>
-Silk.NET.Maths.Sphere<T>.Radius -> T
-Silk.NET.Maths.Sphere<T>.Sphere() -> void
-Silk.NET.Maths.Sphere<T>.Sphere(Silk.NET.Maths.Vector3D<T> center, T radius) -> void
-Silk.NET.Maths.Sphere<T>.Sphere(T centerX, T centerY, T centerZ, T radius) -> void
-Silk.NET.Maths.Sphere<T>.SquaredRadius.get -> T
-Silk.NET.Maths.SystemNumericsExtensions
-Silk.NET.Maths.Vector2D
-Silk.NET.Maths.Vector2D<T>
-Silk.NET.Maths.Vector2D<T>.As<TOther>() -> Silk.NET.Maths.Vector2D<TOther>
-Silk.NET.Maths.Vector2D<T>.CopyTo(T[]? array) -> void
-Silk.NET.Maths.Vector2D<T>.CopyTo(T[]? array, int index) -> void
-Silk.NET.Maths.Vector2D<T>.Equals(Silk.NET.Maths.Vector2D<T> other) -> bool
-Silk.NET.Maths.Vector2D<T>.Length.get -> T
-Silk.NET.Maths.Vector2D<T>.LengthSquared.get -> T
-Silk.NET.Maths.Vector2D<T>.this[int i].get -> T
-Silk.NET.Maths.Vector2D<T>.ToString(string? format) -> string!
-Silk.NET.Maths.Vector2D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
-Silk.NET.Maths.Vector2D<T>.Vector2D() -> void
-Silk.NET.Maths.Vector2D<T>.Vector2D(T value) -> void
-Silk.NET.Maths.Vector2D<T>.Vector2D(T x, T y) -> void
-Silk.NET.Maths.Vector2D<T>.X -> T
-Silk.NET.Maths.Vector2D<T>.Y -> T
-Silk.NET.Maths.Vector3D
-Silk.NET.Maths.Vector3D<T>
-Silk.NET.Maths.Vector3D<T>.As<TOther>() -> Silk.NET.Maths.Vector3D<TOther>
-Silk.NET.Maths.Vector3D<T>.CopyTo(T[]? array) -> void
-Silk.NET.Maths.Vector3D<T>.CopyTo(T[]? array, int index) -> void
-Silk.NET.Maths.Vector3D<T>.Equals(Silk.NET.Maths.Vector3D<T> other) -> bool
-Silk.NET.Maths.Vector3D<T>.Length.get -> T
-Silk.NET.Maths.Vector3D<T>.LengthSquared.get -> T
-Silk.NET.Maths.Vector3D<T>.this[int i].get -> T
-Silk.NET.Maths.Vector3D<T>.ToString(string? format) -> string!
-Silk.NET.Maths.Vector3D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
-Silk.NET.Maths.Vector3D<T>.Vector3D() -> void
-Silk.NET.Maths.Vector3D<T>.Vector3D(Silk.NET.Maths.Vector2D<T> value, T z) -> void
-Silk.NET.Maths.Vector3D<T>.Vector3D(T value) -> void
-Silk.NET.Maths.Vector3D<T>.Vector3D(T x, T y, T z) -> void
-Silk.NET.Maths.Vector3D<T>.X -> T
-Silk.NET.Maths.Vector3D<T>.Y -> T
-Silk.NET.Maths.Vector3D<T>.Z -> T
-Silk.NET.Maths.Vector4D
-Silk.NET.Maths.Vector4D<T>
-Silk.NET.Maths.Vector4D<T>.As<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
-Silk.NET.Maths.Vector4D<T>.CopyTo(T[]? array) -> void
-Silk.NET.Maths.Vector4D<T>.CopyTo(T[]? array, int index) -> void
-Silk.NET.Maths.Vector4D<T>.Equals(Silk.NET.Maths.Vector4D<T> other) -> bool
-Silk.NET.Maths.Vector4D<T>.Length.get -> T
-Silk.NET.Maths.Vector4D<T>.LengthSquared.get -> T
-Silk.NET.Maths.Vector4D<T>.this[int i].get -> T
-Silk.NET.Maths.Vector4D<T>.ToString(string? format) -> string!
-Silk.NET.Maths.Vector4D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
-Silk.NET.Maths.Vector4D<T>.Vector4D() -> void
-Silk.NET.Maths.Vector4D<T>.Vector4D(Silk.NET.Maths.Vector2D<T> value, T z, T w) -> void
-Silk.NET.Maths.Vector4D<T>.Vector4D(Silk.NET.Maths.Vector3D<T> value, T w) -> void
-Silk.NET.Maths.Vector4D<T>.Vector4D(T value) -> void
-Silk.NET.Maths.Vector4D<T>.Vector4D(T x, T y, T z, T w) -> void
-Silk.NET.Maths.Vector4D<T>.W -> T
-Silk.NET.Maths.Vector4D<T>.X -> T
-Silk.NET.Maths.Vector4D<T>.Y -> T
-Silk.NET.Maths.Vector4D<T>.Z -> T
-static readonly Silk.NET.Maths.Scalar<T>.DegreesPerRadian -> T
-static readonly Silk.NET.Maths.Scalar<T>.E -> T
-static readonly Silk.NET.Maths.Scalar<T>.Epsilon -> T
-static readonly Silk.NET.Maths.Scalar<T>.MaxValue -> T
-static readonly Silk.NET.Maths.Scalar<T>.MinusOne -> T
-static readonly Silk.NET.Maths.Scalar<T>.MinusTwo -> T
-static readonly Silk.NET.Maths.Scalar<T>.MinValue -> T
-static readonly Silk.NET.Maths.Scalar<T>.NaN -> T
-static readonly Silk.NET.Maths.Scalar<T>.NegativeInfinity -> T
-static readonly Silk.NET.Maths.Scalar<T>.One -> T
-static readonly Silk.NET.Maths.Scalar<T>.Pi -> T
-static readonly Silk.NET.Maths.Scalar<T>.PiOver2 -> T
-static readonly Silk.NET.Maths.Scalar<T>.PositiveInfinity -> T
-static readonly Silk.NET.Maths.Scalar<T>.RadiansPerDegree -> T
-static readonly Silk.NET.Maths.Scalar<T>.Tau -> T
-static readonly Silk.NET.Maths.Scalar<T>.Two -> T
-static readonly Silk.NET.Maths.Scalar<T>.Zero -> T
-static Silk.NET.Maths.Box2D<T>.operator !=(Silk.NET.Maths.Box2D<T> value1, Silk.NET.Maths.Box2D<T> value2) -> bool
-static Silk.NET.Maths.Box2D<T>.operator ==(Silk.NET.Maths.Box2D<T> value1, Silk.NET.Maths.Box2D<T> value2) -> bool
-static Silk.NET.Maths.Box3D<T>.operator !=(Silk.NET.Maths.Box3D<T> value1, Silk.NET.Maths.Box3D<T> value2) -> bool
-static Silk.NET.Maths.Box3D<T>.operator ==(Silk.NET.Maths.Box3D<T> value1, Silk.NET.Maths.Box3D<T> value2) -> bool
-static Silk.NET.Maths.Circle<T>.operator !=(Silk.NET.Maths.Circle<T> value1, Silk.NET.Maths.Circle<T> value2) -> bool
-static Silk.NET.Maths.Circle<T>.operator ==(Silk.NET.Maths.Circle<T> value1, Silk.NET.Maths.Circle<T> value2) -> bool
-static Silk.NET.Maths.Cube<T>.operator !=(Silk.NET.Maths.Cube<T> value1, Silk.NET.Maths.Cube<T> value2) -> bool
-static Silk.NET.Maths.Cube<T>.operator ==(Silk.NET.Maths.Cube<T> value1, Silk.NET.Maths.Cube<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X2.Add<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2.Lerp<T>(Silk.NET.Maths.Matrix2X2<T> matrix1, Silk.NET.Maths.Matrix2X2<T> matrix2, T amount) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> value1, T value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix2X2.Negate<T>(Silk.NET.Maths.Matrix2X2<T> value) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2.Subtract<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<byte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<byte>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<decimal>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<decimal>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<double>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<double>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<float>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<float>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<int>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<int>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<long>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<long>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<sbyte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<sbyte>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<short>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<short>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<System.Half>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<System.Half>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<uint>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<uint>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<ulong>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ulong>
-static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<ushort>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ushort>
-static Silk.NET.Maths.Matrix2X2<T>.Identity.get -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator !=(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Matrix2X2<T> value1, T value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator +(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator -(Silk.NET.Maths.Matrix2X2<T> value) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator -(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X2<T>.operator ==(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X3.Add<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Lerp<T>(Silk.NET.Maths.Matrix2X3<T> matrix1, Silk.NET.Maths.Matrix2X3<T> matrix2, T amount) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, T value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix2X3.Negate<T>(Silk.NET.Maths.Matrix2X3<T> value) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Subtract<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3.Transform<T>(Silk.NET.Maths.Matrix2X3<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<byte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<byte>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<decimal>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<decimal>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<double>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<double>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<float>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<float>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<int>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<int>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<long>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<long>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<sbyte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<sbyte>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<short>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<short>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<System.Half>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<System.Half>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<uint>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<uint>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<ulong>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ulong>
-static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<ushort>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ushort>
-static Silk.NET.Maths.Matrix2X3<T>.Identity.get -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator !=(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> value1, T value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator +(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator -(Silk.NET.Maths.Matrix2X3<T> value) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator -(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X3<T>.operator ==(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X4.Add<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4.Lerp<T>(Silk.NET.Maths.Matrix2X4<T> matrix1, Silk.NET.Maths.Matrix2X4<T> matrix2, T amount) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<byte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<byte>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<decimal>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<decimal>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<double>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<double>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<float>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<float>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<int>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<int>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<long>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<long>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<sbyte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<sbyte>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<short>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<short>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<System.Half>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<System.Half>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<uint>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<uint>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<ulong>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ulong>
-static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<ushort>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ushort>
-static Silk.NET.Maths.Matrix2X4<T>.Identity.get -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator !=(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> value1, T value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator +(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator -(Silk.NET.Maths.Matrix2X4<T> value) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator -(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix2X4<T>.operator ==(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X2.Add<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateRotation<T>(T radians) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateRotation<T>(T radians, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(Silk.NET.Maths.Vector2D<T> scales) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(Silk.NET.Maths.Vector2D<T> scales, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T scale, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T xScale, T yScale) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T xScale, T yScale, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateSkew<T>(T radiansX, T radiansY) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateSkew<T>(T radiansX, T radiansY, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateTranslation<T>(Silk.NET.Maths.Vector2D<T> position) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.CreateTranslation<T>(T xPosition, T yPosition) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.Invert<T>(Silk.NET.Maths.Matrix3X2<T> matrix, out Silk.NET.Maths.Matrix3X2<T> result) -> bool
-static Silk.NET.Maths.Matrix3X2.Lerp<T>(Silk.NET.Maths.Matrix3X2<T> matrix1, Silk.NET.Maths.Matrix3X2<T> matrix2, T amount) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> value1, T value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix3X2.Negate<T>(Silk.NET.Maths.Matrix3X2<T> value) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2.Subtract<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<byte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<byte>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<decimal>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<decimal>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<double>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<double>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<float>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<float>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<int>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<int>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<long>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<long>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<sbyte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<sbyte>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<short>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<short>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<System.Half>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<System.Half>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<uint>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<uint>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<ulong>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ulong>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<ushort>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ushort>
-static Silk.NET.Maths.Matrix3X2<T>.explicit operator System.Numerics.Matrix3x2(Silk.NET.Maths.Matrix3X2<T> from) -> System.Numerics.Matrix3x2
-static Silk.NET.Maths.Matrix3X2<T>.Identity.get -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator !=(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> value1, T value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator +(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator -(Silk.NET.Maths.Matrix3X2<T> value) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator -(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X2<T>.operator ==(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X3.Add<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateRotationX<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateRotationY<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateRotationZ<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.CreateScale<T>(T xScale, T yScale, T zScale) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Decompose<T>(Silk.NET.Maths.Matrix3X3<T> matrix, out Silk.NET.Maths.Vector3D<T> scale, out Silk.NET.Maths.Quaternion<T> rotation) -> bool
-static Silk.NET.Maths.Matrix3X3.Lerp<T>(Silk.NET.Maths.Matrix3X3<T> matrix1, Silk.NET.Maths.Matrix3X3<T> matrix2, T amount) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix2X3<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> value1, T value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix3X3.Negate<T>(Silk.NET.Maths.Matrix3X3<T> value) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Subtract<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Transform<T>(Silk.NET.Maths.Matrix3X3<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3.Transpose<T>(Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<byte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<byte>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<decimal>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<decimal>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<double>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<double>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<float>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<float>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<int>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<int>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<long>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<long>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<sbyte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<sbyte>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<short>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<short>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<System.Half>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<System.Half>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<uint>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<uint>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<ulong>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ulong>
-static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<ushort>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ushort>
-static Silk.NET.Maths.Matrix3X3<T>.Identity.get -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator !=(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> value1, T value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator +(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator -(Silk.NET.Maths.Matrix3X3<T> value) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator -(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X3<T>.operator ==(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X4.Add<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Lerp<T>(Silk.NET.Maths.Matrix3X4<T> matrix1, Silk.NET.Maths.Matrix3X4<T> matrix2, T amount) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> value1, T value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix3X4.Negate<T>(Silk.NET.Maths.Matrix3X4<T> value) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4.Subtract<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<byte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<byte>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<decimal>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<decimal>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<double>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<double>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<float>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<float>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<int>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<int>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<long>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<long>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<sbyte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<sbyte>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<short>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<short>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<System.Half>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<System.Half>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<uint>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<uint>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<ulong>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ulong>
-static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<ushort>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ushort>
-static Silk.NET.Maths.Matrix3X4<T>.Identity.get -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator !=(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> value1, T value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator +(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator -(Silk.NET.Maths.Matrix3X4<T> value) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator -(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix3X4<T>.operator ==(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X2.Add<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2.Lerp<T>(Silk.NET.Maths.Matrix4X2<T> matrix1, Silk.NET.Maths.Matrix4X2<T> matrix2, T amount) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix4X2.Negate<T>(Silk.NET.Maths.Matrix4X2<T> value) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2.Subtract<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<byte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<byte>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<decimal>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<decimal>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<double>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<double>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<float>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<float>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<int>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<int>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<long>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<long>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<sbyte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<sbyte>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<short>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<short>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<System.Half>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<System.Half>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<uint>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<uint>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<ulong>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ulong>
-static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<ushort>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ushort>
-static Silk.NET.Maths.Matrix4X2<T>.Identity.get -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator !=(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix2X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix3X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> value1, T value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator +(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator -(Silk.NET.Maths.Matrix4X2<T> value) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator -(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X2<T>.operator ==(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X3.Add<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Lerp<T>(Silk.NET.Maths.Matrix4X3<T> matrix1, Silk.NET.Maths.Matrix4X3<T> matrix2, T amount) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix3X3<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> value1, T value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix4X3.Negate<T>(Silk.NET.Maths.Matrix4X3<T> value) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3.Subtract<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<byte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<byte>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<decimal>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<decimal>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<double>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<double>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<float>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<float>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<int>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<int>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<long>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<long>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<sbyte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<sbyte>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<short>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<short>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<System.Half>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<System.Half>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<uint>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<uint>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<ulong>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ulong>
-static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<ushort>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ushort>
-static Silk.NET.Maths.Matrix4X3<T>.Identity.get -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator !=(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> value1, T value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator +(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator -(Silk.NET.Maths.Matrix4X3<T> value) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator -(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X3<T>.operator ==(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X4.Add<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateConstrainedBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> rotateAxis, Silk.NET.Maths.Vector3D<T> cameraForwardVector, Silk.NET.Maths.Vector3D<T> objectForwardVector) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateLookAt<T>(Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraTarget, Silk.NET.Maths.Vector3D<T> cameraUpVector) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateOrthographic<T>(T width, T height, T zNearPlane, T zFarPlane) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateOrthographicOffCenter<T>(T left, T right, T bottom, T top, T zNearPlane, T zFarPlane) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreatePerspective<T>(T width, T height, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreatePerspectiveFieldOfView<T>(T fieldOfView, T aspectRatio, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreatePerspectiveOffCenter<T>(T left, T right, T bottom, T top, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateReflection<T>(Silk.NET.Maths.Plane<T> value) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationX<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationX<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationY<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationY<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationZ<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateRotationZ<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T scale, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T xScale, T yScale, T zScale) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T xScale, T yScale, T zScale, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateShadow<T>(Silk.NET.Maths.Vector3D<T> lightDirection, Silk.NET.Maths.Plane<T> plane) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateTranslation<T>(Silk.NET.Maths.Vector3D<T> position) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateTranslation<T>(T xPosition, T yPosition, T zPosition) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.CreateWorld<T>(Silk.NET.Maths.Vector3D<T> position, Silk.NET.Maths.Vector3D<T> forward, Silk.NET.Maths.Vector3D<T> up) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Decompose<T>(Silk.NET.Maths.Matrix4X4<T> matrix, out Silk.NET.Maths.Vector3D<T> scale, out Silk.NET.Maths.Quaternion<T> rotation, out Silk.NET.Maths.Vector3D<T> translation) -> bool
-static Silk.NET.Maths.Matrix4X4.Invert<T>(Silk.NET.Maths.Matrix4X4<T> matrix, out Silk.NET.Maths.Matrix4X4<T> result) -> bool
-static Silk.NET.Maths.Matrix4X4.Lerp<T>(Silk.NET.Maths.Matrix4X4<T> matrix1, Silk.NET.Maths.Matrix4X4<T> matrix2, T amount) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix2X4<T>
-static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Matrix4X2<T>
-static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> value1, T value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix4X4.Negate<T>(Silk.NET.Maths.Matrix4X4<T> value) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Subtract<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Transform<T>(Silk.NET.Maths.Matrix4X4<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4.Transpose<T>(Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<byte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<byte>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<decimal>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<decimal>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<double>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<double>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<float>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<float>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<int>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<int>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<long>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<long>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<sbyte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<sbyte>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<short>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<short>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<System.Half>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<System.Half>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<uint>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<uint>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<ulong>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ulong>
-static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<ushort>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ushort>
-static Silk.NET.Maths.Matrix4X4<T>.Identity.get -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator !=(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix3X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Matrix4X3<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> value1, T value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator +(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator -(Silk.NET.Maths.Matrix4X4<T> value) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator -(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Matrix4X4<T>
-static Silk.NET.Maths.Matrix4X4<T>.operator ==(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix5X4.Add<T>(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4.Lerp<T>(Silk.NET.Maths.Matrix5X4<T> matrix1, Silk.NET.Maths.Matrix5X4<T> matrix2, T amount) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4.Multiply<T>(Silk.NET.Maths.Matrix5X4<T> value1, T value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix5X4.Negate<T>(Silk.NET.Maths.Matrix5X4<T> value) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4.Subtract<T>(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<byte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<byte>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<decimal>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<decimal>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<double>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<double>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<float>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<float>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<int>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<int>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<long>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<long>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<sbyte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<sbyte>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<short>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<short>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<System.Half>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<System.Half>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<uint>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<uint>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<ulong>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ulong>
-static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<ushort>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ushort>
-static Silk.NET.Maths.Matrix5X4<T>.Identity.get -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator !=(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> bool
-static Silk.NET.Maths.Matrix5X4<T>.operator *(Silk.NET.Maths.Matrix5X4<T> value1, T value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator *(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator +(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator -(Silk.NET.Maths.Matrix5X4<T> value) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator -(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Matrix5X4<T>
-static Silk.NET.Maths.Matrix5X4<T>.operator ==(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> bool
-static Silk.NET.Maths.Plane.CreateFromVertices<T>(Silk.NET.Maths.Vector3D<T> point1, Silk.NET.Maths.Vector3D<T> point2, Silk.NET.Maths.Vector3D<T> point3) -> Silk.NET.Maths.Plane<T>
-static Silk.NET.Maths.Plane.Dot<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector4D<T> value) -> T
-static Silk.NET.Maths.Plane.DotCoordinate<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector3D<T> value) -> T
-static Silk.NET.Maths.Plane.DotNormal<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector3D<T> value) -> T
-static Silk.NET.Maths.Plane.Normalize<T>(Silk.NET.Maths.Plane<T> value) -> Silk.NET.Maths.Plane<T>
-static Silk.NET.Maths.Plane.Transform<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Plane<T>
-static Silk.NET.Maths.Plane.Transform<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Plane<T>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<byte>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<byte>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<decimal>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<decimal>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<double>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<double>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<float>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<float>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<int>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<int>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<long>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<long>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<sbyte>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<sbyte>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<short>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<short>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<System.Half>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<System.Half>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<uint>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<uint>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<ulong>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<ulong>
-static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<ushort>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<ushort>
-static Silk.NET.Maths.Plane<T>.explicit operator System.Numerics.Plane(Silk.NET.Maths.Plane<T> from) -> System.Numerics.Plane
-static Silk.NET.Maths.Plane<T>.operator !=(Silk.NET.Maths.Plane<T> value1, Silk.NET.Maths.Plane<T> value2) -> bool
-static Silk.NET.Maths.Plane<T>.operator ==(Silk.NET.Maths.Plane<T> value1, Silk.NET.Maths.Plane<T> value2) -> bool
-static Silk.NET.Maths.Quaternion<T>.Add(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Concatenate(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Conjugate(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.CreateFromAxisAngle(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.CreateFromRotationMatrix(Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.CreateFromRotationMatrix(Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.CreateFromYawPitchRoll(T yaw, T pitch, T roll) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Divide(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Dot(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2) -> T
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<byte>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<byte>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<decimal>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<decimal>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<double>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<double>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<float>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<float>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<int>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<int>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<long>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<long>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<sbyte>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<sbyte>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<short>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<short>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<System.Half>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<System.Half>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<uint>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<uint>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<ulong>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<ulong>
-static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<ushort>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<ushort>
-static Silk.NET.Maths.Quaternion<T>.explicit operator System.Numerics.Quaternion(Silk.NET.Maths.Quaternion<T> from) -> System.Numerics.Quaternion
-static Silk.NET.Maths.Quaternion<T>.Identity.get -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Inverse(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Lerp(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2, T amount) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Multiply(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Multiply(Silk.NET.Maths.Quaternion<T> value1, T value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Negate(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Normalize(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator !=(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> bool
-static Silk.NET.Maths.Quaternion<T>.operator *(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator *(Silk.NET.Maths.Quaternion<T> value1, T value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator +(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator -(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator -(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator /(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.operator ==(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> bool
-static Silk.NET.Maths.Quaternion<T>.Slerp(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2, T amount) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Quaternion<T>.Subtract(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
-static Silk.NET.Maths.Ray2D<T>.operator !=(Silk.NET.Maths.Ray2D<T> value1, Silk.NET.Maths.Ray2D<T> value2) -> bool
-static Silk.NET.Maths.Ray2D<T>.operator ==(Silk.NET.Maths.Ray2D<T> value1, Silk.NET.Maths.Ray2D<T> value2) -> bool
-static Silk.NET.Maths.Ray3D<T>.operator !=(Silk.NET.Maths.Ray3D<T> value1, Silk.NET.Maths.Ray3D<T> value2) -> bool
-static Silk.NET.Maths.Ray3D<T>.operator ==(Silk.NET.Maths.Ray3D<T> value1, Silk.NET.Maths.Ray3D<T> value2) -> bool
-static Silk.NET.Maths.Rectangle.FromLTRB<T>(T left, T top, T right, T bottom) -> Silk.NET.Maths.Rectangle<T>
-static Silk.NET.Maths.Rectangle<T>.operator !=(Silk.NET.Maths.Rectangle<T> value1, Silk.NET.Maths.Rectangle<T> value2) -> bool
-static Silk.NET.Maths.Rectangle<T>.operator ==(Silk.NET.Maths.Rectangle<T> value1, Silk.NET.Maths.Rectangle<T> value2) -> bool
-static Silk.NET.Maths.Scalar.Abs<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Acos<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Acosh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Add<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.And<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.As<TFrom, TTo>(TFrom val) -> TTo
-static Silk.NET.Maths.Scalar.Asin<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Asinh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Atan2<T>(T y, T x) -> T
-static Silk.NET.Maths.Scalar.Atan<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Atanh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Cbrt<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Ceiling<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Cos<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Cosh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.DegreesToRadians<T>(T degrees) -> T
-static Silk.NET.Maths.Scalar.Divide<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.Equal<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.Exp<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Floor<T>(T x) -> T
-static Silk.NET.Maths.Scalar.GreaterThan<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.GreaterThanOrEqual<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.IEEERemainder<T>(T x, T y) -> T
-static Silk.NET.Maths.Scalar.IsFinite<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsHardwareAccelerated.get -> bool
-static Silk.NET.Maths.Scalar.IsInfinity<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsNaN<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsNegative<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsNegativeInfinity<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsNormal<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsPositiveInfinity<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.IsSubnormal<T>(T f) -> bool
-static Silk.NET.Maths.Scalar.LessThan<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.LessThanOrEqual<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.Log10<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Log<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Log<T>(T x, T y) -> T
-static Silk.NET.Maths.Scalar.Max<T>(T x, T y) -> T
-static Silk.NET.Maths.Scalar.Min<T>(T x, T y) -> T
-static Silk.NET.Maths.Scalar.Multiply<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.Negate<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Not<T>(T value) -> T
-static Silk.NET.Maths.Scalar.NotEqual<T>(T left, T right) -> bool
-static Silk.NET.Maths.Scalar.Or<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.Pow<T>(T x, T y) -> T
-static Silk.NET.Maths.Scalar.RadiansToDegrees<T>(T radians) -> T
-static Silk.NET.Maths.Scalar.Reciprocal<T>(T x) -> T
-static Silk.NET.Maths.Scalar.RotateLeft<T>(T value, int offset) -> T
-static Silk.NET.Maths.Scalar.RotateRight<T>(T value, int offset) -> T
-static Silk.NET.Maths.Scalar.Round<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Round<T>(T x, int digits) -> T
-static Silk.NET.Maths.Scalar.Round<T>(T x, int digits, System.MidpointRounding mode) -> T
-static Silk.NET.Maths.Scalar.Round<T>(T x, System.MidpointRounding mode) -> T
-static Silk.NET.Maths.Scalar.ShiftLeft<T>(T value, int offset) -> T
-static Silk.NET.Maths.Scalar.ShiftRight<T>(T value, int offset) -> T
-static Silk.NET.Maths.Scalar.Sign<T>(T x) -> int
-static Silk.NET.Maths.Scalar.Sin<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Sinh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Sqrt<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Subtract<T>(T left, T right) -> T
-static Silk.NET.Maths.Scalar.Tan<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Tanh<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Truncate<T>(T x) -> T
-static Silk.NET.Maths.Scalar.Xor<T>(T left, T right) -> T
-static Silk.NET.Maths.Sphere<T>.operator !=(Silk.NET.Maths.Sphere<T> value1, Silk.NET.Maths.Sphere<T> value2) -> bool
-static Silk.NET.Maths.Sphere<T>.operator ==(Silk.NET.Maths.Sphere<T> value1, Silk.NET.Maths.Sphere<T> value2) -> bool
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Matrix3x2 value) -> Silk.NET.Maths.Matrix3X2<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Matrix4x4 value) -> Silk.NET.Maths.Matrix4X4<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Plane value) -> Silk.NET.Maths.Plane<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Quaternion value) -> Silk.NET.Maths.Quaternion<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector2 value) -> Silk.NET.Maths.Vector2D<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector3 value) -> Silk.NET.Maths.Vector3D<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector4 value) -> Silk.NET.Maths.Vector4D<float>
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Matrix3X2<float> value) -> System.Numerics.Matrix3x2
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Matrix4X4<float> value) -> System.Numerics.Matrix4x4
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Plane<float> value) -> System.Numerics.Plane
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Quaternion<float> value) -> System.Numerics.Quaternion
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector2D<float> value) -> System.Numerics.Vector2
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector3D<float> value) -> System.Numerics.Vector3
-static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector4D<float> value) -> System.Numerics.Vector4
-static Silk.NET.Maths.Vector2D.Abs<T>(Silk.NET.Maths.Vector2D<T> value) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Add<T>(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Clamp<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> min, Silk.NET.Maths.Vector2D<T> max) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Distance<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> T
-static Silk.NET.Maths.Vector2D.DistanceSquared<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> T
-static Silk.NET.Maths.Vector2D.Divide<T>(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Divide<T>(Silk.NET.Maths.Vector2D<T> left, T divisor) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Dot<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> T
-static Silk.NET.Maths.Vector2D.Lerp<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2, T amount) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Max<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Min<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> left, T right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Matrix2X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector2D.Multiply<T>(T left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Negate<T>(Silk.NET.Maths.Vector2D<T> value) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Normalize<T>(Silk.NET.Maths.Vector2D<T> value) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Reflect<T>(Silk.NET.Maths.Vector2D<T> vector, Silk.NET.Maths.Vector2D<T> normal) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.SquareRoot<T>(Silk.NET.Maths.Vector2D<T> value) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Subtract<T>(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Transform<T>(Silk.NET.Maths.Vector2D<T> position, Silk.NET.Maths.Matrix3X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Transform<T>(Silk.NET.Maths.Vector2D<T> position, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.Transform<T>(Silk.NET.Maths.Vector2D<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.TransformNormal<T>(Silk.NET.Maths.Vector2D<T> normal, Silk.NET.Maths.Matrix3X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D.TransformNormal<T>(Silk.NET.Maths.Vector2D<T> normal, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<byte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<byte>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<decimal>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<decimal>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<double>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<double>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<float>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<float>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<int>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<int>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<long>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<long>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<sbyte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<sbyte>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<short>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<short>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<System.Half>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<System.Half>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<uint>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<uint>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<ulong>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ulong>
-static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<ushort>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ushort>
-static Silk.NET.Maths.Vector2D<T>.explicit operator System.Numerics.Vector2(Silk.NET.Maths.Vector2D<T> from) -> System.Numerics.Vector2
-static Silk.NET.Maths.Vector2D<T>.One.get -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator !=(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> bool
-static Silk.NET.Maths.Vector2D<T>.operator *(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator *(Silk.NET.Maths.Vector2D<T> left, T right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator *(T left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator +(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator -(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator -(Silk.NET.Maths.Vector2D<T> value) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator /(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator /(Silk.NET.Maths.Vector2D<T> value1, T value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.operator ==(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> bool
-static Silk.NET.Maths.Vector2D<T>.UnitX.get -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.UnitY.get -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector2D<T>.Zero.get -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector3D.Abs<T>(Silk.NET.Maths.Vector3D<T> value) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Add<T>(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Clamp<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> min, Silk.NET.Maths.Vector3D<T> max) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Cross<T>(Silk.NET.Maths.Vector3D<T> vector1, Silk.NET.Maths.Vector3D<T> vector2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Distance<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> T
-static Silk.NET.Maths.Vector3D.DistanceSquared<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> T
-static Silk.NET.Maths.Vector3D.Divide<T>(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Divide<T>(Silk.NET.Maths.Vector3D<T> left, T divisor) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Dot<T>(Silk.NET.Maths.Vector3D<T> vector1, Silk.NET.Maths.Vector3D<T> vector2) -> T
-static Silk.NET.Maths.Vector3D.Lerp<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2, T amount) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Max<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Min<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> left, T right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Matrix3X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector3D.Multiply<T>(T left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Negate<T>(Silk.NET.Maths.Vector3D<T> value) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Normalize<T>(Silk.NET.Maths.Vector3D<T> value) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Reflect<T>(Silk.NET.Maths.Vector3D<T> vector, Silk.NET.Maths.Vector3D<T> normal) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.SquareRoot<T>(Silk.NET.Maths.Vector3D<T> value) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Subtract<T>(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Transform<T>(Silk.NET.Maths.Vector3D<T> position, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.Transform<T>(Silk.NET.Maths.Vector3D<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D.TransformNormal<T>(Silk.NET.Maths.Vector3D<T> normal, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<byte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<byte>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<decimal>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<decimal>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<double>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<double>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<float>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<float>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<int>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<int>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<long>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<long>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<sbyte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<sbyte>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<short>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<short>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<System.Half>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<System.Half>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<uint>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<uint>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<ulong>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ulong>
-static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<ushort>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ushort>
-static Silk.NET.Maths.Vector3D<T>.explicit operator System.Numerics.Vector3(Silk.NET.Maths.Vector3D<T> from) -> System.Numerics.Vector3
-static Silk.NET.Maths.Vector3D<T>.One.get -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator !=(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> bool
-static Silk.NET.Maths.Vector3D<T>.operator *(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator *(Silk.NET.Maths.Vector3D<T> left, T right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator *(T left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator +(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator -(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator -(Silk.NET.Maths.Vector3D<T> value) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator /(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator /(Silk.NET.Maths.Vector3D<T> value1, T value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.operator ==(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> bool
-static Silk.NET.Maths.Vector3D<T>.UnitX.get -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.UnitY.get -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.UnitZ.get -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector3D<T>.Zero.get -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector4D.Abs<T>(Silk.NET.Maths.Vector4D<T> value) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Add<T>(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Clamp<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> min, Silk.NET.Maths.Vector4D<T> max) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Distance<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> T
-static Silk.NET.Maths.Vector4D.DistanceSquared<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> T
-static Silk.NET.Maths.Vector4D.Divide<T>(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Divide<T>(Silk.NET.Maths.Vector4D<T> left, T divisor) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Dot<T>(Silk.NET.Maths.Vector4D<T> vector1, Silk.NET.Maths.Vector4D<T> vector2) -> T
-static Silk.NET.Maths.Vector4D.Lerp<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2, T amount) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Max<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Min<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> left, T right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X2<T> value2) -> Silk.NET.Maths.Vector2D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X3<T> value2) -> Silk.NET.Maths.Vector3D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix4X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Multiply<T>(T left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Negate<T>(Silk.NET.Maths.Vector4D<T> value) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Normalize<T>(Silk.NET.Maths.Vector4D<T> vector) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.SquareRoot<T>(Silk.NET.Maths.Vector4D<T> value) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Subtract<T>(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector2D<T> position, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector2D<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector3D<T> position, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector3D<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector4D<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D.Transform<T>(Silk.NET.Maths.Vector4D<T> vector, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<byte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<byte>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<decimal>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<decimal>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<double>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<double>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<float>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<float>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<int>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<int>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<long>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<long>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<sbyte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<sbyte>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<short>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<short>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<System.Half>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<System.Half>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<uint>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<uint>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<ulong>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ulong>
-static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<ushort>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ushort>
-static Silk.NET.Maths.Vector4D<T>.explicit operator System.Numerics.Vector4(Silk.NET.Maths.Vector4D<T> from) -> System.Numerics.Vector4
-static Silk.NET.Maths.Vector4D<T>.One.get -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator !=(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> bool
-static Silk.NET.Maths.Vector4D<T>.operator *(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator *(Silk.NET.Maths.Vector4D<T> left, T right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator *(T left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator +(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator -(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator -(Silk.NET.Maths.Vector4D<T> value) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator /(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator /(Silk.NET.Maths.Vector4D<T> value1, T value2) -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.operator ==(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> bool
-static Silk.NET.Maths.Vector4D<T>.UnitW.get -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.UnitX.get -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.UnitY.get -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.UnitZ.get -> Silk.NET.Maths.Vector4D<T>
-static Silk.NET.Maths.Vector4D<T>.Zero.get -> Silk.NET.Maths.Vector4D<T>
diff --git a/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Unshipped.txt b/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Unshipped.txt
index 7dc5c58110..47ef53fa1c 100644
--- a/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Unshipped.txt
+++ b/sources/Maths/Maths/PublicAPI/net8.0/PublicAPI.Unshipped.txt
@@ -1 +1,1873 @@
 #nullable enable
+override Silk.NET.Maths.Box2D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Box2D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Box3D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Box3D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Circle<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Circle<T>.GetHashCode() -> int
+override Silk.NET.Maths.Cube<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Cube<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix2X2<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix2X2<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix2X2<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix2X3<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix2X3<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix2X3<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix2X4<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix2X4<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix2X4<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix3X2<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix3X2<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix3X2<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix3X3<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix3X3<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix3X3<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix3X4<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix3X4<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix3X4<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix4X2<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix4X2<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix4X2<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix4X3<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix4X3<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix4X3<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix4X4<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix4X4<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix4X4<T>.ToString() -> string!
+override Silk.NET.Maths.Matrix5X4<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Matrix5X4<T>.GetHashCode() -> int
+override Silk.NET.Maths.Matrix5X4<T>.ToString() -> string!
+override Silk.NET.Maths.Plane<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Plane<T>.GetHashCode() -> int
+override Silk.NET.Maths.Plane<T>.ToString() -> string!
+override Silk.NET.Maths.Quaternion<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Quaternion<T>.GetHashCode() -> int
+override Silk.NET.Maths.Quaternion<T>.ToString() -> string!
+override Silk.NET.Maths.Ray2D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Ray2D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Ray3D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Ray3D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Rectangle<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Rectangle<T>.GetHashCode() -> int
+override Silk.NET.Maths.Sphere<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Sphere<T>.GetHashCode() -> int
+override Silk.NET.Maths.Vector2D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Vector2D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Vector2D<T>.ToString() -> string!
+override Silk.NET.Maths.Vector3D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Vector3D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Vector3D<T>.ToString() -> string!
+override Silk.NET.Maths.Vector4D<T>.Equals(object? obj) -> bool
+override Silk.NET.Maths.Vector4D<T>.GetHashCode() -> int
+override Silk.NET.Maths.Vector4D<T>.ToString() -> string!
+Silk.NET.Maths.Box2D<T>
+Silk.NET.Maths.Box2D<T>.As<TOther>() -> Silk.NET.Maths.Box2D<TOther>
+Silk.NET.Maths.Box2D<T>.AsChecked<TOther>() -> Silk.NET.Maths.Box2D<TOther>
+Silk.NET.Maths.Box2D<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Box2D<TOther>
+Silk.NET.Maths.Box2D<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Box2D<TOther>
+Silk.NET.Maths.Box2D<T>.Box2D() -> void
+Silk.NET.Maths.Box2D<T>.Box2D(Silk.NET.Maths.Vector2D<T> min, Silk.NET.Maths.Vector2D<T> max) -> void
+Silk.NET.Maths.Box2D<T>.Box2D(Silk.NET.Maths.Vector2D<T> min, T maxX, T maxY) -> void
+Silk.NET.Maths.Box2D<T>.Box2D(T minX, T minY, Silk.NET.Maths.Vector2D<T> max) -> void
+Silk.NET.Maths.Box2D<T>.Box2D(T minX, T minY, T maxX, T maxY) -> void
+Silk.NET.Maths.Box2D<T>.Center.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Box2D<T>.Contains(Silk.NET.Maths.Box2D<T> other) -> bool
+Silk.NET.Maths.Box2D<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
+Silk.NET.Maths.Box2D<T>.Equals(Silk.NET.Maths.Box2D<T> other) -> bool
+Silk.NET.Maths.Box2D<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
+Silk.NET.Maths.Box2D<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Box2D<T>
+Silk.NET.Maths.Box2D<T>.GetScaled(Silk.NET.Maths.Vector2D<T> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Box2D<T>
+Silk.NET.Maths.Box2D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Box2D<T>
+Silk.NET.Maths.Box2D<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Box2D<T>
+Silk.NET.Maths.Box2D<T>.Max -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Box2D<T>.Min -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Box2D<T>.Size.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Box3D<T>
+Silk.NET.Maths.Box3D<T>.As<TOther>() -> Silk.NET.Maths.Box3D<TOther>
+Silk.NET.Maths.Box3D<T>.Box3D() -> void
+Silk.NET.Maths.Box3D<T>.Box3D(Silk.NET.Maths.Vector3D<T> min, Silk.NET.Maths.Vector3D<T> max) -> void
+Silk.NET.Maths.Box3D<T>.Box3D(Silk.NET.Maths.Vector3D<T> min, T maxX, T maxY, T maxZ) -> void
+Silk.NET.Maths.Box3D<T>.Box3D(T minX, T minY, T minZ, Silk.NET.Maths.Vector3D<T> max) -> void
+Silk.NET.Maths.Box3D<T>.Box3D(T minX, T minY, T minZ, T maxX, T maxY, T maxZ) -> void
+Silk.NET.Maths.Box3D<T>.Center.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Box3D<T>.Contains(Silk.NET.Maths.Box3D<T> other) -> bool
+Silk.NET.Maths.Box3D<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
+Silk.NET.Maths.Box3D<T>.Equals(Silk.NET.Maths.Box3D<T> other) -> bool
+Silk.NET.Maths.Box3D<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
+Silk.NET.Maths.Box3D<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Box3D<T>
+Silk.NET.Maths.Box3D<T>.GetScaled(Silk.NET.Maths.Vector3D<T> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Box3D<T>
+Silk.NET.Maths.Box3D<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Box3D<T>
+Silk.NET.Maths.Box3D<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Box3D<T>
+Silk.NET.Maths.Box3D<T>.Max -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Box3D<T>.Min -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Box3D<T>.Size.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Circle<T>
+Silk.NET.Maths.Circle<T>.As<TOther>() -> Silk.NET.Maths.Circle<TOther>
+Silk.NET.Maths.Circle<T>.Center -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Circle<T>.Circle() -> void
+Silk.NET.Maths.Circle<T>.Circle(Silk.NET.Maths.Vector2D<T> center, T radius) -> void
+Silk.NET.Maths.Circle<T>.Circle(T centerX, T centerY, T radius) -> void
+Silk.NET.Maths.Circle<T>.Circumference.get -> T
+Silk.NET.Maths.Circle<T>.Contains(Silk.NET.Maths.Circle<T> other) -> bool
+Silk.NET.Maths.Circle<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
+Silk.NET.Maths.Circle<T>.Diameter.get -> T
+Silk.NET.Maths.Circle<T>.Equals(Silk.NET.Maths.Circle<T> other) -> bool
+Silk.NET.Maths.Circle<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
+Silk.NET.Maths.Circle<T>.GetDistanceToNearestEdgeSquared(Silk.NET.Maths.Vector2D<T> point) -> T
+Silk.NET.Maths.Circle<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Circle<T>
+Silk.NET.Maths.Circle<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Circle<T>
+Silk.NET.Maths.Circle<T>.Radius -> T
+Silk.NET.Maths.Circle<T>.SquaredRadius.get -> T
+Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.As<TOther>() -> Silk.NET.Maths.Cube<TOther>
+Silk.NET.Maths.Cube<T>.Center.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Cube<T>.Contains(Silk.NET.Maths.Cube<T> other) -> bool
+Silk.NET.Maths.Cube<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
+Silk.NET.Maths.Cube<T>.Cube() -> void
+Silk.NET.Maths.Cube<T>.Cube(Silk.NET.Maths.Vector3D<T> origin, Silk.NET.Maths.Vector3D<T> size) -> void
+Silk.NET.Maths.Cube<T>.Cube(Silk.NET.Maths.Vector3D<T> origin, T sizeX, T sizeY, T sizeZ) -> void
+Silk.NET.Maths.Cube<T>.Cube(T originX, T originY, T originZ, Silk.NET.Maths.Vector3D<T> size) -> void
+Silk.NET.Maths.Cube<T>.Cube(T originX, T originY, T originZ, T sizeX, T sizeY, T sizeZ) -> void
+Silk.NET.Maths.Cube<T>.Equals(Silk.NET.Maths.Cube<T> other) -> bool
+Silk.NET.Maths.Cube<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
+Silk.NET.Maths.Cube<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.GetScaled(Silk.NET.Maths.Vector3D<T> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.GetScaled<TScale>(Silk.NET.Maths.Vector3D<TScale> scale, Silk.NET.Maths.Vector3D<T> anchor) -> Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Cube<T>
+Silk.NET.Maths.Cube<T>.HalfSize.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Cube<T>.Max.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Cube<T>.Origin -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Cube<T>.Size -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix2X2
+Silk.NET.Maths.Matrix2X2<T>
+Silk.NET.Maths.Matrix2X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X2<TOther>
+Silk.NET.Maths.Matrix2X2<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix2X2<TOther>
+Silk.NET.Maths.Matrix2X2<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix2X2<TOther>
+Silk.NET.Maths.Matrix2X2<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix2X2<TOther>
+Silk.NET.Maths.Matrix2X2<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X2<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X2<T>.Equals(Silk.NET.Maths.Matrix2X2<T> other) -> bool
+Silk.NET.Maths.Matrix2X2<T>.GetDeterminant() -> T
+Silk.NET.Maths.Matrix2X2<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix2X2<T>.M11.get -> T
+Silk.NET.Maths.Matrix2X2<T>.M12.get -> T
+Silk.NET.Maths.Matrix2X2<T>.M21.get -> T
+Silk.NET.Maths.Matrix2X2<T>.M22.get -> T
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2() -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2) -> void
+Silk.NET.Maths.Matrix2X2<T>.Matrix2X2(T m11, T m12, T m21, T m22) -> void
+Silk.NET.Maths.Matrix2X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X2<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix2X2<T>.this[int row].get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X2<T>.Transpose() -> Silk.NET.Maths.Matrix2X2<T>
+Silk.NET.Maths.Matrix2X3
+Silk.NET.Maths.Matrix2X3<T>
+Silk.NET.Maths.Matrix2X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X3<TOther>
+Silk.NET.Maths.Matrix2X3<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix2X3<TOther>
+Silk.NET.Maths.Matrix2X3<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix2X3<TOther>
+Silk.NET.Maths.Matrix2X3<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix2X3<TOther>
+Silk.NET.Maths.Matrix2X3<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X3<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X3<T>.Column3.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X3<T>.Equals(Silk.NET.Maths.Matrix2X3<T> other) -> bool
+Silk.NET.Maths.Matrix2X3<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix2X3<T>.M11.get -> T
+Silk.NET.Maths.Matrix2X3<T>.M12.get -> T
+Silk.NET.Maths.Matrix2X3<T>.M13.get -> T
+Silk.NET.Maths.Matrix2X3<T>.M21.get -> T
+Silk.NET.Maths.Matrix2X3<T>.M22.get -> T
+Silk.NET.Maths.Matrix2X3<T>.M23.get -> T
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3() -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2) -> void
+Silk.NET.Maths.Matrix2X3<T>.Matrix2X3(T m11, T m12, T m13, T m21, T m22, T m23) -> void
+Silk.NET.Maths.Matrix2X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix2X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix2X3<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix2X3<T>.this[int row].get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix2X3<T>.Transpose() -> Silk.NET.Maths.Matrix3X2<T>
+Silk.NET.Maths.Matrix2X4
+Silk.NET.Maths.Matrix2X4<T>
+Silk.NET.Maths.Matrix2X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix2X4<TOther>
+Silk.NET.Maths.Matrix2X4<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix2X4<TOther>
+Silk.NET.Maths.Matrix2X4<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix2X4<TOther>
+Silk.NET.Maths.Matrix2X4<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix2X4<TOther>
+Silk.NET.Maths.Matrix2X4<T>.Column1.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X4<T>.Column2.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X4<T>.Column3.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X4<T>.Column4.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix2X4<T>.Equals(Silk.NET.Maths.Matrix2X4<T> other) -> bool
+Silk.NET.Maths.Matrix2X4<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix2X4<T>.M11.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M12.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M13.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M14.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M21.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M22.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M23.get -> T
+Silk.NET.Maths.Matrix2X4<T>.M24.get -> T
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4() -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2) -> void
+Silk.NET.Maths.Matrix2X4<T>.Matrix2X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24) -> void
+Silk.NET.Maths.Matrix2X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix2X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix2X4<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix2X4<T>.this[int row].get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix2X4<T>.Transpose() -> Silk.NET.Maths.Matrix4X2<T>
+Silk.NET.Maths.Matrix3X2
+Silk.NET.Maths.Matrix3X2<T>
+Silk.NET.Maths.Matrix3X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X2<TOther>
+Silk.NET.Maths.Matrix3X2<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix3X2<TOther>
+Silk.NET.Maths.Matrix3X2<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix3X2<TOther>
+Silk.NET.Maths.Matrix3X2<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix3X2<TOther>
+Silk.NET.Maths.Matrix3X2<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X2<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X2<T>.Equals(Silk.NET.Maths.Matrix3X2<T> other) -> bool
+Silk.NET.Maths.Matrix3X2<T>.GetDeterminant() -> T
+Silk.NET.Maths.Matrix3X2<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix3X2<T>.M11.get -> T
+Silk.NET.Maths.Matrix3X2<T>.M12.get -> T
+Silk.NET.Maths.Matrix3X2<T>.M21.get -> T
+Silk.NET.Maths.Matrix3X2<T>.M22.get -> T
+Silk.NET.Maths.Matrix3X2<T>.M31.get -> T
+Silk.NET.Maths.Matrix3X2<T>.M32.get -> T
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2() -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2, Silk.NET.Maths.Vector2D<T> row3) -> void
+Silk.NET.Maths.Matrix3X2<T>.Matrix3X2(T m11, T m12, T m21, T m22, T m31, T m32) -> void
+Silk.NET.Maths.Matrix3X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix3X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix3X2<T>.Row3 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix3X2<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix3X2<T>.this[int row].get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix3X2<T>.Transpose() -> Silk.NET.Maths.Matrix2X3<T>
+Silk.NET.Maths.Matrix3X3
+Silk.NET.Maths.Matrix3X3<T>
+Silk.NET.Maths.Matrix3X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X3<TOther>
+Silk.NET.Maths.Matrix3X3<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix3X3<TOther>
+Silk.NET.Maths.Matrix3X3<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix3X3<TOther>
+Silk.NET.Maths.Matrix3X3<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix3X3<TOther>
+Silk.NET.Maths.Matrix3X3<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Column3.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Equals(Silk.NET.Maths.Matrix3X3<T> other) -> bool
+Silk.NET.Maths.Matrix3X3<T>.GetDeterminant() -> T
+Silk.NET.Maths.Matrix3X3<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix3X3<T>.M11.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M12.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M13.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M21.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M22.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M23.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M31.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M32.get -> T
+Silk.NET.Maths.Matrix3X3<T>.M33.get -> T
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3() -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Matrix4X4<T> value) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2, Silk.NET.Maths.Vector3D<T> row3) -> void
+Silk.NET.Maths.Matrix3X3<T>.Matrix3X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33) -> void
+Silk.NET.Maths.Matrix3X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Row3 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix3X3<T>.this[int row].get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X3<T>.Transpose() -> Silk.NET.Maths.Matrix3X3<T>
+Silk.NET.Maths.Matrix3X4
+Silk.NET.Maths.Matrix3X4<T>
+Silk.NET.Maths.Matrix3X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix3X4<TOther>
+Silk.NET.Maths.Matrix3X4<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix3X4<TOther>
+Silk.NET.Maths.Matrix3X4<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix3X4<TOther>
+Silk.NET.Maths.Matrix3X4<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix3X4<TOther>
+Silk.NET.Maths.Matrix3X4<T>.Column1.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X4<T>.Column2.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X4<T>.Column3.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X4<T>.Column4.get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix3X4<T>.Equals(Silk.NET.Maths.Matrix3X4<T> other) -> bool
+Silk.NET.Maths.Matrix3X4<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix3X4<T>.M11.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M12.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M13.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M14.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M21.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M22.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M23.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M24.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M31.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M32.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M33.get -> T
+Silk.NET.Maths.Matrix3X4<T>.M34.get -> T
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4() -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3) -> void
+Silk.NET.Maths.Matrix3X4<T>.Matrix3X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34) -> void
+Silk.NET.Maths.Matrix3X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix3X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix3X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix3X4<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix3X4<T>.this[int row].get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix3X4<T>.Transpose() -> Silk.NET.Maths.Matrix4X3<T>
+Silk.NET.Maths.Matrix4X2
+Silk.NET.Maths.Matrix4X2<T>
+Silk.NET.Maths.Matrix4X2<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X2<TOther>
+Silk.NET.Maths.Matrix4X2<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix4X2<TOther>
+Silk.NET.Maths.Matrix4X2<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix4X2<TOther>
+Silk.NET.Maths.Matrix4X2<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix4X2<TOther>
+Silk.NET.Maths.Matrix4X2<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X2<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X2<T>.Equals(Silk.NET.Maths.Matrix4X2<T> other) -> bool
+Silk.NET.Maths.Matrix4X2<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix4X2<T>.M11.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M12.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M21.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M22.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M31.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M32.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M41.get -> T
+Silk.NET.Maths.Matrix4X2<T>.M42.get -> T
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2() -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(Silk.NET.Maths.Vector2D<T> row1, Silk.NET.Maths.Vector2D<T> row2, Silk.NET.Maths.Vector2D<T> row3, Silk.NET.Maths.Vector2D<T> row4) -> void
+Silk.NET.Maths.Matrix4X2<T>.Matrix4X2(T m11, T m12, T m21, T m22, T m31, T m32, T m41, T m42) -> void
+Silk.NET.Maths.Matrix4X2<T>.Row1 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix4X2<T>.Row2 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix4X2<T>.Row3 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix4X2<T>.Row4 -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix4X2<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix4X2<T>.this[int row].get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Matrix4X2<T>.Transpose() -> Silk.NET.Maths.Matrix2X4<T>
+Silk.NET.Maths.Matrix4X3
+Silk.NET.Maths.Matrix4X3<T>
+Silk.NET.Maths.Matrix4X3<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X3<TOther>
+Silk.NET.Maths.Matrix4X3<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix4X3<TOther>
+Silk.NET.Maths.Matrix4X3<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix4X3<TOther>
+Silk.NET.Maths.Matrix4X3<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix4X3<TOther>
+Silk.NET.Maths.Matrix4X3<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X3<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X3<T>.Column3.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X3<T>.Equals(Silk.NET.Maths.Matrix4X3<T> other) -> bool
+Silk.NET.Maths.Matrix4X3<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix4X3<T>.M11.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M12.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M13.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M21.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M22.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M23.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M31.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M32.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M33.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M41.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M42.get -> T
+Silk.NET.Maths.Matrix4X3<T>.M43.get -> T
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3() -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Matrix4X4<T> value) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(Silk.NET.Maths.Vector3D<T> row1, Silk.NET.Maths.Vector3D<T> row2, Silk.NET.Maths.Vector3D<T> row3, Silk.NET.Maths.Vector3D<T> row4) -> void
+Silk.NET.Maths.Matrix4X3<T>.Matrix4X3(T m11, T m12, T m13, T m21, T m22, T m23, T m31, T m32, T m33, T m41, T m42, T m43) -> void
+Silk.NET.Maths.Matrix4X3<T>.Row1 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix4X3<T>.Row2 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix4X3<T>.Row3 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix4X3<T>.Row4 -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix4X3<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix4X3<T>.this[int row].get -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Matrix4X3<T>.Transpose() -> Silk.NET.Maths.Matrix3X4<T>
+Silk.NET.Maths.Matrix4X4
+Silk.NET.Maths.Matrix4X4<T>
+Silk.NET.Maths.Matrix4X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix4X4<TOther>
+Silk.NET.Maths.Matrix4X4<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix4X4<TOther>
+Silk.NET.Maths.Matrix4X4<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix4X4<TOther>
+Silk.NET.Maths.Matrix4X4<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix4X4<TOther>
+Silk.NET.Maths.Matrix4X4<T>.Column1.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Column2.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Column3.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Column4.get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Equals(Silk.NET.Maths.Matrix4X4<T> other) -> bool
+Silk.NET.Maths.Matrix4X4<T>.GetDeterminant() -> T
+Silk.NET.Maths.Matrix4X4<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix4X4<T>.M11.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M12.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M13.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M14.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M21.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M22.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M23.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M24.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M31.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M32.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M33.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M34.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M41.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M42.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M43.get -> T
+Silk.NET.Maths.Matrix4X4<T>.M44.get -> T
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4() -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3, Silk.NET.Maths.Vector4D<T> row4) -> void
+Silk.NET.Maths.Matrix4X4<T>.Matrix4X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34, T m41, T m42, T m43, T m44) -> void
+Silk.NET.Maths.Matrix4X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Row4 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix4X4<T>.this[int row].get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix4X4<T>.Transpose() -> Silk.NET.Maths.Matrix4X4<T>
+Silk.NET.Maths.Matrix5X4
+Silk.NET.Maths.Matrix5X4<T>
+Silk.NET.Maths.Matrix5X4<T>.As<TOther>() -> Silk.NET.Maths.Matrix5X4<TOther>
+Silk.NET.Maths.Matrix5X4<T>.AsChecked<TOther>() -> Silk.NET.Maths.Matrix5X4<TOther>
+Silk.NET.Maths.Matrix5X4<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Matrix5X4<TOther>
+Silk.NET.Maths.Matrix5X4<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Matrix5X4<TOther>
+Silk.NET.Maths.Matrix5X4<T>.Equals(Silk.NET.Maths.Matrix5X4<T> other) -> bool
+Silk.NET.Maths.Matrix5X4<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Matrix5X4<T>.M11.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M12.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M13.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M14.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M21.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M22.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M23.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M24.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M31.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M32.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M33.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M34.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M41.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M42.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M43.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M44.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M51.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M52.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M53.get -> T
+Silk.NET.Maths.Matrix5X4<T>.M54.get -> T
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4() -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix2X4<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X2<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X3<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix3X4<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X2<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X3<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Matrix4X4<T> value) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(Silk.NET.Maths.Vector4D<T> row1, Silk.NET.Maths.Vector4D<T> row2, Silk.NET.Maths.Vector4D<T> row3, Silk.NET.Maths.Vector4D<T> row4, Silk.NET.Maths.Vector4D<T> row5) -> void
+Silk.NET.Maths.Matrix5X4<T>.Matrix5X4(T m11, T m12, T m13, T m14, T m21, T m22, T m23, T m24, T m31, T m32, T m33, T m34, T m41, T m42, T m43, T m44, T m51, T m52, T m53, T m54) -> void
+Silk.NET.Maths.Matrix5X4<T>.Row1 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix5X4<T>.Row2 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix5X4<T>.Row3 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix5X4<T>.Row4 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix5X4<T>.Row5 -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Matrix5X4<T>.this[int row, int column].get -> T
+Silk.NET.Maths.Matrix5X4<T>.this[int row].get -> Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Plane
+Silk.NET.Maths.Plane<T>
+Silk.NET.Maths.Plane<T>.As<TOther>() -> Silk.NET.Maths.Plane<TOther>
+Silk.NET.Maths.Plane<T>.Distance -> T
+Silk.NET.Maths.Plane<T>.Equals(Silk.NET.Maths.Plane<T> other) -> bool
+Silk.NET.Maths.Plane<T>.Normal -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Plane<T>.Plane() -> void
+Silk.NET.Maths.Plane<T>.Plane(Silk.NET.Maths.Vector3D<T> normal, T distance) -> void
+Silk.NET.Maths.Plane<T>.Plane(Silk.NET.Maths.Vector4D<T> value) -> void
+Silk.NET.Maths.Plane<T>.Plane(T x, T y, T z, T distance) -> void
+Silk.NET.Maths.Quaternion<T>
+Silk.NET.Maths.Quaternion<T>.Angle.get -> T
+Silk.NET.Maths.Quaternion<T>.As<TOther>() -> Silk.NET.Maths.Quaternion<TOther>
+Silk.NET.Maths.Quaternion<T>.Equals(Silk.NET.Maths.Quaternion<T> other) -> bool
+Silk.NET.Maths.Quaternion<T>.IsIdentity.get -> bool
+Silk.NET.Maths.Quaternion<T>.Length() -> T
+Silk.NET.Maths.Quaternion<T>.LengthSquared() -> T
+Silk.NET.Maths.Quaternion<T>.Quaternion() -> void
+Silk.NET.Maths.Quaternion<T>.Quaternion(Silk.NET.Maths.Vector3D<T> vectorPart, T scalarPart) -> void
+Silk.NET.Maths.Quaternion<T>.Quaternion(T x, T y, T z, T w) -> void
+Silk.NET.Maths.Quaternion<T>.this[int index].get -> T
+Silk.NET.Maths.Quaternion<T>.W -> T
+Silk.NET.Maths.Quaternion<T>.X -> T
+Silk.NET.Maths.Quaternion<T>.Y -> T
+Silk.NET.Maths.Quaternion<T>.Z -> T
+Silk.NET.Maths.Ray2D<T>
+Silk.NET.Maths.Ray2D<T>.As<TOther>() -> Silk.NET.Maths.Ray2D<TOther>
+Silk.NET.Maths.Ray2D<T>.Direction -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Ray2D<T>.Equals(Silk.NET.Maths.Ray2D<T> other) -> bool
+Silk.NET.Maths.Ray2D<T>.GetPoint(T distance) -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Ray2D<T>.Origin -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Ray2D<T>.Ray2D() -> void
+Silk.NET.Maths.Ray2D<T>.Ray2D(Silk.NET.Maths.Vector2D<T> origin, Silk.NET.Maths.Vector2D<T> direction) -> void
+Silk.NET.Maths.Ray2D<T>.Ray2D(Silk.NET.Maths.Vector2D<T> origin, T directionX, T directionY) -> void
+Silk.NET.Maths.Ray2D<T>.Ray2D(T originX, T originY, Silk.NET.Maths.Vector2D<T> direction) -> void
+Silk.NET.Maths.Ray2D<T>.Ray2D(T originX, T originY, T directionX, T directionY) -> void
+Silk.NET.Maths.Ray3D<T>
+Silk.NET.Maths.Ray3D<T>.As<TOther>() -> Silk.NET.Maths.Ray3D<TOther>
+Silk.NET.Maths.Ray3D<T>.Direction -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Ray3D<T>.Equals(Silk.NET.Maths.Ray3D<T> other) -> bool
+Silk.NET.Maths.Ray3D<T>.GetPoint(T distance) -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Ray3D<T>.Origin -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Ray3D<T>.Ray3D() -> void
+Silk.NET.Maths.Ray3D<T>.Ray3D(Silk.NET.Maths.Vector3D<T> origin, Silk.NET.Maths.Vector3D<T> direction) -> void
+Silk.NET.Maths.Ray3D<T>.Ray3D(Silk.NET.Maths.Vector3D<T> origin, T directionX, T directionY, T directionZ) -> void
+Silk.NET.Maths.Ray3D<T>.Ray3D(T originX, T originY, T originZ, Silk.NET.Maths.Vector3D<T> direction) -> void
+Silk.NET.Maths.Ray3D<T>.Ray3D(T originX, T originY, T originZ, T directionX, T directionY, T directionZ) -> void
+Silk.NET.Maths.Rectangle
+Silk.NET.Maths.Rectangle<T>
+Silk.NET.Maths.Rectangle<T>.As<TOther>() -> Silk.NET.Maths.Rectangle<TOther>
+Silk.NET.Maths.Rectangle<T>.Center.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Rectangle<T>.Contains(Silk.NET.Maths.Rectangle<T> other) -> bool
+Silk.NET.Maths.Rectangle<T>.Contains(Silk.NET.Maths.Vector2D<T> point) -> bool
+Silk.NET.Maths.Rectangle<T>.Equals(Silk.NET.Maths.Rectangle<T> other) -> bool
+Silk.NET.Maths.Rectangle<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector2D<T> point) -> T
+Silk.NET.Maths.Rectangle<T>.GetInflated(Silk.NET.Maths.Vector2D<T> point) -> Silk.NET.Maths.Rectangle<T>
+Silk.NET.Maths.Rectangle<T>.GetScaled(Silk.NET.Maths.Vector2D<T> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Rectangle<T>
+Silk.NET.Maths.Rectangle<T>.GetScaled<TScale>(Silk.NET.Maths.Vector2D<TScale> scale, Silk.NET.Maths.Vector2D<T> anchor) -> Silk.NET.Maths.Rectangle<T>
+Silk.NET.Maths.Rectangle<T>.GetTranslated(Silk.NET.Maths.Vector2D<T> distance) -> Silk.NET.Maths.Rectangle<T>
+Silk.NET.Maths.Rectangle<T>.HalfSize.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Rectangle<T>.Max.get -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Rectangle<T>.Origin -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Rectangle<T>.Rectangle() -> void
+Silk.NET.Maths.Rectangle<T>.Rectangle(Silk.NET.Maths.Vector2D<T> origin, Silk.NET.Maths.Vector2D<T> size) -> void
+Silk.NET.Maths.Rectangle<T>.Rectangle(Silk.NET.Maths.Vector2D<T> origin, T sizeX, T sizeY) -> void
+Silk.NET.Maths.Rectangle<T>.Rectangle(T originX, T originY, Silk.NET.Maths.Vector2D<T> size) -> void
+Silk.NET.Maths.Rectangle<T>.Rectangle(T originX, T originY, T sizeX, T sizeY) -> void
+Silk.NET.Maths.Rectangle<T>.Size -> Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Scalar
+Silk.NET.Maths.Scalar<T>
+Silk.NET.Maths.Sphere<T>
+Silk.NET.Maths.Sphere<T>.As<TOther>() -> Silk.NET.Maths.Sphere<TOther>
+Silk.NET.Maths.Sphere<T>.Center -> Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Sphere<T>.Contains(Silk.NET.Maths.Sphere<T> other) -> bool
+Silk.NET.Maths.Sphere<T>.Contains(Silk.NET.Maths.Vector3D<T> point) -> bool
+Silk.NET.Maths.Sphere<T>.Diameter.get -> T
+Silk.NET.Maths.Sphere<T>.Equals(Silk.NET.Maths.Sphere<T> other) -> bool
+Silk.NET.Maths.Sphere<T>.GetDistanceToNearestEdge(Silk.NET.Maths.Vector3D<T> point) -> T
+Silk.NET.Maths.Sphere<T>.GetDistanceToNearestEdgeSquared(Silk.NET.Maths.Vector3D<T> point) -> T
+Silk.NET.Maths.Sphere<T>.GetInflated(Silk.NET.Maths.Vector3D<T> point) -> Silk.NET.Maths.Sphere<T>
+Silk.NET.Maths.Sphere<T>.GetTranslated(Silk.NET.Maths.Vector3D<T> distance) -> Silk.NET.Maths.Sphere<T>
+Silk.NET.Maths.Sphere<T>.Radius -> T
+Silk.NET.Maths.Sphere<T>.Sphere() -> void
+Silk.NET.Maths.Sphere<T>.Sphere(Silk.NET.Maths.Vector3D<T> center, T radius) -> void
+Silk.NET.Maths.Sphere<T>.Sphere(T centerX, T centerY, T centerZ, T radius) -> void
+Silk.NET.Maths.Sphere<T>.SquaredRadius.get -> T
+Silk.NET.Maths.SystemNumericsExtensions
+Silk.NET.Maths.Vector2D
+Silk.NET.Maths.Vector2D.extension<T>(Silk.NET.Maths.Vector2D<T>)
+Silk.NET.Maths.Vector2D.extension<T>(Silk.NET.Maths.Vector2D<T>).Length.get -> T
+Silk.NET.Maths.Vector2D.extension<T>(Silk.NET.Maths.Vector2D<T>).LengthSquared.get -> T
+Silk.NET.Maths.Vector2D<T>
+Silk.NET.Maths.Vector2D<T>.As<TOther>() -> Silk.NET.Maths.Vector2D<TOther>
+Silk.NET.Maths.Vector2D<T>.AsChecked<TOther>() -> Silk.NET.Maths.Vector2D<TOther>
+Silk.NET.Maths.Vector2D<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Vector2D<TOther>
+Silk.NET.Maths.Vector2D<T>.AsSpan() -> System.Span<T>
+Silk.NET.Maths.Vector2D<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Vector2D<TOther>
+Silk.NET.Maths.Vector2D<T>.CopyTo(System.Span<T> span) -> void
+Silk.NET.Maths.Vector2D<T>.CopyTo(System.Span<T> span, int startIndex) -> void
+Silk.NET.Maths.Vector2D<T>.CopyTo(T[]! array) -> void
+Silk.NET.Maths.Vector2D<T>.CopyTo(T[]! array, int startIndex) -> void
+Silk.NET.Maths.Vector2D<T>.Count.get -> int
+Silk.NET.Maths.Vector2D<T>.Equals(Silk.NET.Maths.Vector2D<T> other) -> bool
+Silk.NET.Maths.Vector2D<T>.GetEnumerator() -> System.Collections.Generic.IEnumerator<T>!
+Silk.NET.Maths.Vector2D<T>.this[int index].get -> T
+Silk.NET.Maths.Vector2D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
+Silk.NET.Maths.Vector2D<T>.TryFormat(System.Span<byte> utf8Destination, out int bytesWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector2D<T>.TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector2D<T>.Vector2D() -> void
+Silk.NET.Maths.Vector2D<T>.Vector2D(System.ReadOnlySpan<T> values) -> void
+Silk.NET.Maths.Vector2D<T>.Vector2D(T value) -> void
+Silk.NET.Maths.Vector2D<T>.Vector2D(T x, T y) -> void
+Silk.NET.Maths.Vector2D<T>.X -> T
+Silk.NET.Maths.Vector2D<T>.Y -> T
+Silk.NET.Maths.Vector3D
+Silk.NET.Maths.Vector3D.extension<T>(Silk.NET.Maths.Vector3D<T>)
+Silk.NET.Maths.Vector3D.extension<T>(Silk.NET.Maths.Vector3D<T>).Length.get -> T
+Silk.NET.Maths.Vector3D.extension<T>(Silk.NET.Maths.Vector3D<T>).LengthSquared.get -> T
+Silk.NET.Maths.Vector3D<T>
+Silk.NET.Maths.Vector3D<T>.As<TOther>() -> Silk.NET.Maths.Vector3D<TOther>
+Silk.NET.Maths.Vector3D<T>.AsChecked<TOther>() -> Silk.NET.Maths.Vector3D<TOther>
+Silk.NET.Maths.Vector3D<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Vector3D<TOther>
+Silk.NET.Maths.Vector3D<T>.AsSpan() -> System.Span<T>
+Silk.NET.Maths.Vector3D<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Vector3D<TOther>
+Silk.NET.Maths.Vector3D<T>.CopyTo(System.Span<T> span) -> void
+Silk.NET.Maths.Vector3D<T>.CopyTo(System.Span<T> span, int startIndex) -> void
+Silk.NET.Maths.Vector3D<T>.CopyTo(T[]! array) -> void
+Silk.NET.Maths.Vector3D<T>.CopyTo(T[]! array, int startIndex) -> void
+Silk.NET.Maths.Vector3D<T>.Count.get -> int
+Silk.NET.Maths.Vector3D<T>.Equals(Silk.NET.Maths.Vector3D<T> other) -> bool
+Silk.NET.Maths.Vector3D<T>.GetEnumerator() -> System.Collections.Generic.IEnumerator<T>!
+Silk.NET.Maths.Vector3D<T>.this[int index].get -> T
+Silk.NET.Maths.Vector3D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
+Silk.NET.Maths.Vector3D<T>.TryFormat(System.Span<byte> utf8Destination, out int bytesWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector3D<T>.TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector3D<T>.Vector3D() -> void
+Silk.NET.Maths.Vector3D<T>.Vector3D(Silk.NET.Maths.Vector2D<T> other, T z) -> void
+Silk.NET.Maths.Vector3D<T>.Vector3D(System.ReadOnlySpan<T> values) -> void
+Silk.NET.Maths.Vector3D<T>.Vector3D(T value) -> void
+Silk.NET.Maths.Vector3D<T>.Vector3D(T x, T y, T z) -> void
+Silk.NET.Maths.Vector3D<T>.X -> T
+Silk.NET.Maths.Vector3D<T>.Y -> T
+Silk.NET.Maths.Vector3D<T>.Z -> T
+Silk.NET.Maths.Vector4D
+Silk.NET.Maths.Vector4D.extension<T>(Silk.NET.Maths.Vector4D<T>)
+Silk.NET.Maths.Vector4D.extension<T>(Silk.NET.Maths.Vector4D<T>).Length.get -> T
+Silk.NET.Maths.Vector4D.extension<T>(Silk.NET.Maths.Vector4D<T>).LengthSquared.get -> T
+Silk.NET.Maths.Vector4D<T>
+Silk.NET.Maths.Vector4D<T>.As<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
+Silk.NET.Maths.Vector4D<T>.AsChecked<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
+Silk.NET.Maths.Vector4D<T>.AsSaturating<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
+Silk.NET.Maths.Vector4D<T>.AsSpan() -> System.Span<T>
+Silk.NET.Maths.Vector4D<T>.AsTruncating<TOther>() -> Silk.NET.Maths.Vector4D<TOther>
+Silk.NET.Maths.Vector4D<T>.CopyTo(System.Span<T> span) -> void
+Silk.NET.Maths.Vector4D<T>.CopyTo(System.Span<T> span, int startIndex) -> void
+Silk.NET.Maths.Vector4D<T>.CopyTo(T[]! array) -> void
+Silk.NET.Maths.Vector4D<T>.CopyTo(T[]! array, int startIndex) -> void
+Silk.NET.Maths.Vector4D<T>.Count.get -> int
+Silk.NET.Maths.Vector4D<T>.Equals(Silk.NET.Maths.Vector4D<T> other) -> bool
+Silk.NET.Maths.Vector4D<T>.GetEnumerator() -> System.Collections.Generic.IEnumerator<T>!
+Silk.NET.Maths.Vector4D<T>.this[int index].get -> T
+Silk.NET.Maths.Vector4D<T>.ToString(string? format, System.IFormatProvider? formatProvider) -> string!
+Silk.NET.Maths.Vector4D<T>.TryFormat(System.Span<byte> utf8Destination, out int bytesWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector4D<T>.TryFormat(System.Span<char> destination, out int charsWritten, System.ReadOnlySpan<char> format, System.IFormatProvider? provider) -> bool
+Silk.NET.Maths.Vector4D<T>.Vector4D() -> void
+Silk.NET.Maths.Vector4D<T>.Vector4D(Silk.NET.Maths.Vector2D<T> other, T z, T w) -> void
+Silk.NET.Maths.Vector4D<T>.Vector4D(Silk.NET.Maths.Vector3D<T> other, T w) -> void
+Silk.NET.Maths.Vector4D<T>.Vector4D(System.ReadOnlySpan<T> values) -> void
+Silk.NET.Maths.Vector4D<T>.Vector4D(T value) -> void
+Silk.NET.Maths.Vector4D<T>.Vector4D(T x, T y, T z, T w) -> void
+Silk.NET.Maths.Vector4D<T>.W -> T
+Silk.NET.Maths.Vector4D<T>.X -> T
+Silk.NET.Maths.Vector4D<T>.Y -> T
+Silk.NET.Maths.Vector4D<T>.Z -> T
+static readonly Silk.NET.Maths.Scalar<T>.DegreesPerRadian -> T
+static readonly Silk.NET.Maths.Scalar<T>.E -> T
+static readonly Silk.NET.Maths.Scalar<T>.Epsilon -> T
+static readonly Silk.NET.Maths.Scalar<T>.MaxValue -> T
+static readonly Silk.NET.Maths.Scalar<T>.MinusOne -> T
+static readonly Silk.NET.Maths.Scalar<T>.MinusTwo -> T
+static readonly Silk.NET.Maths.Scalar<T>.MinValue -> T
+static readonly Silk.NET.Maths.Scalar<T>.NaN -> T
+static readonly Silk.NET.Maths.Scalar<T>.NegativeInfinity -> T
+static readonly Silk.NET.Maths.Scalar<T>.One -> T
+static readonly Silk.NET.Maths.Scalar<T>.Pi -> T
+static readonly Silk.NET.Maths.Scalar<T>.PiOver2 -> T
+static readonly Silk.NET.Maths.Scalar<T>.PositiveInfinity -> T
+static readonly Silk.NET.Maths.Scalar<T>.RadiansPerDegree -> T
+static readonly Silk.NET.Maths.Scalar<T>.Tau -> T
+static readonly Silk.NET.Maths.Scalar<T>.Two -> T
+static readonly Silk.NET.Maths.Scalar<T>.Zero -> T
+static Silk.NET.Maths.Box2D<T>.operator !=(Silk.NET.Maths.Box2D<T> value1, Silk.NET.Maths.Box2D<T> value2) -> bool
+static Silk.NET.Maths.Box2D<T>.operator ==(Silk.NET.Maths.Box2D<T> value1, Silk.NET.Maths.Box2D<T> value2) -> bool
+static Silk.NET.Maths.Box3D<T>.operator !=(Silk.NET.Maths.Box3D<T> value1, Silk.NET.Maths.Box3D<T> value2) -> bool
+static Silk.NET.Maths.Box3D<T>.operator ==(Silk.NET.Maths.Box3D<T> value1, Silk.NET.Maths.Box3D<T> value2) -> bool
+static Silk.NET.Maths.Circle<T>.operator !=(Silk.NET.Maths.Circle<T> value1, Silk.NET.Maths.Circle<T> value2) -> bool
+static Silk.NET.Maths.Circle<T>.operator ==(Silk.NET.Maths.Circle<T> value1, Silk.NET.Maths.Circle<T> value2) -> bool
+static Silk.NET.Maths.Cube<T>.operator !=(Silk.NET.Maths.Cube<T> value1, Silk.NET.Maths.Cube<T> value2) -> bool
+static Silk.NET.Maths.Cube<T>.operator ==(Silk.NET.Maths.Cube<T> value1, Silk.NET.Maths.Cube<T> value2) -> bool
+static Silk.NET.Maths.Matrix2X2.Add<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Lerp<T>(Silk.NET.Maths.Matrix2X2<T> value1, Silk.NET.Maths.Matrix2X2<T> value2, T amount) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, T right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X2.Multiply<T>(T left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Negate<T>(Silk.NET.Maths.Matrix2X2<T> value) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2.Subtract<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix2X2<TOther> other) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix2X2<TOther> other) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix2X2<TOther> other) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<byte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<byte>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<decimal>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<decimal>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<double>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<double>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<float>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<float>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<int>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<int>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<long>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<long>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<sbyte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<sbyte>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<short>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<short>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<System.Half>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<System.Half>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<uint>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<uint>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<ulong>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ulong>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator checked Silk.NET.Maths.Matrix2X2<ushort>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ushort>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<byte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<byte>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<decimal>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<decimal>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<double>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<double>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<float>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<float>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<int>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<int>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<long>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<long>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<sbyte>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<sbyte>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<short>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<short>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<System.Half>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<System.Half>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<uint>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<uint>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<ulong>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ulong>
+static Silk.NET.Maths.Matrix2X2<T>.explicit operator Silk.NET.Maths.Matrix2X2<ushort>(Silk.NET.Maths.Matrix2X2<T> from) -> Silk.NET.Maths.Matrix2X2<ushort>
+static Silk.NET.Maths.Matrix2X2<T>.Identity.get -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator !=(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> bool
+static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Matrix2X2<T> left, T right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Matrix2X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator *(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator *(T left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator +(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator -(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator -(Silk.NET.Maths.Matrix2X2<T> value) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X2<T>.operator ==(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> bool
+static Silk.NET.Maths.Matrix2X3.Add<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Lerp<T>(Silk.NET.Maths.Matrix2X3<T> value1, Silk.NET.Maths.Matrix2X3<T> value2, T amount) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, T right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix2X3.Multiply<T>(T left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Negate<T>(Silk.NET.Maths.Matrix2X3<T> value) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Subtract<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3.Transform<T>(Silk.NET.Maths.Matrix2X3<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix2X3<TOther> other) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix2X3<TOther> other) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix2X3<TOther> other) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<byte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<byte>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<decimal>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<decimal>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<double>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<double>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<float>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<float>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<int>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<int>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<long>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<long>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<sbyte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<sbyte>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<short>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<short>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<System.Half>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<System.Half>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<uint>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<uint>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<ulong>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ulong>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator checked Silk.NET.Maths.Matrix2X3<ushort>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ushort>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<byte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<byte>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<decimal>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<decimal>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<double>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<double>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<float>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<float>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<int>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<int>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<long>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<long>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<sbyte>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<sbyte>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<short>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<short>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<System.Half>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<System.Half>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<uint>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<uint>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<ulong>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ulong>
+static Silk.NET.Maths.Matrix2X3<T>.explicit operator Silk.NET.Maths.Matrix2X3<ushort>(Silk.NET.Maths.Matrix2X3<T> from) -> Silk.NET.Maths.Matrix2X3<ushort>
+static Silk.NET.Maths.Matrix2X3<T>.Identity.get -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator !=(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> bool
+static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> left, T right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator *(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator *(T left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator +(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator -(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator -(Silk.NET.Maths.Matrix2X3<T> value) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X3<T>.operator ==(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> bool
+static Silk.NET.Maths.Matrix2X4.Add<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Lerp<T>(Silk.NET.Maths.Matrix2X4<T> value1, Silk.NET.Maths.Matrix2X4<T> value2, T amount) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, T right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix2X4.Multiply<T>(T left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Negate<T>(Silk.NET.Maths.Matrix2X4<T> value) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4.Subtract<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix2X4<TOther> other) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix2X4<TOther> other) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix2X4<TOther> other) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<byte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<byte>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<decimal>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<decimal>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<double>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<double>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<float>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<float>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<int>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<int>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<long>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<long>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<sbyte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<sbyte>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<short>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<short>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<System.Half>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<System.Half>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<uint>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<uint>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<ulong>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ulong>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator checked Silk.NET.Maths.Matrix2X4<ushort>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ushort>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<byte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<byte>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<decimal>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<decimal>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<double>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<double>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<float>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<float>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<int>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<int>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<long>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<long>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<sbyte>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<sbyte>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<short>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<short>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<System.Half>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<System.Half>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<uint>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<uint>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<ulong>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ulong>
+static Silk.NET.Maths.Matrix2X4<T>.explicit operator Silk.NET.Maths.Matrix2X4<ushort>(Silk.NET.Maths.Matrix2X4<T> from) -> Silk.NET.Maths.Matrix2X4<ushort>
+static Silk.NET.Maths.Matrix2X4<T>.Identity.get -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator !=(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> bool
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> left, T right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(Silk.NET.Maths.Vector2D<T> rowVector, Silk.NET.Maths.Matrix2X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator *(T left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator +(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator -(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator -(Silk.NET.Maths.Matrix2X4<T> value) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix2X4<T>.operator ==(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> bool
+static Silk.NET.Maths.Matrix3X2.Add<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateRotation<T>(T radians) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateRotation<T>(T radians, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(Silk.NET.Maths.Vector2D<T> scales) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(Silk.NET.Maths.Vector2D<T> scales, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T scale, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T xScale, T yScale) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateScale<T>(T xScale, T yScale, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateSkew<T>(T radiansX, T radiansY) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateSkew<T>(T radiansX, T radiansY, Silk.NET.Maths.Vector2D<T> centerPoint) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateTranslation<T>(Silk.NET.Maths.Vector2D<T> position) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.CreateTranslation<T>(T xPosition, T yPosition) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Invert<T>(Silk.NET.Maths.Matrix3X2<T> matrix, out Silk.NET.Maths.Matrix3X2<T> result) -> bool
+static Silk.NET.Maths.Matrix3X2.Lerp<T>(Silk.NET.Maths.Matrix3X2<T> value1, Silk.NET.Maths.Matrix3X2<T> value2, T amount) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> left, T right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix3X2.Multiply<T>(T left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Negate<T>(Silk.NET.Maths.Matrix3X2<T> value) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2.Subtract<T>(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix3X2<TOther> other) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix3X2<TOther> other) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix3X2<TOther> other) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<byte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<byte>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<decimal>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<decimal>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<double>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<double>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<float>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<float>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<int>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<int>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<long>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<long>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<sbyte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<sbyte>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<short>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<short>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<System.Half>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<System.Half>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<uint>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<uint>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<ulong>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ulong>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator checked Silk.NET.Maths.Matrix3X2<ushort>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ushort>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<byte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<byte>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<decimal>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<decimal>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<double>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<double>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<float>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<float>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<int>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<int>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<long>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<long>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<sbyte>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<sbyte>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<short>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<short>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<System.Half>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<System.Half>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<uint>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<uint>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<ulong>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ulong>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator Silk.NET.Maths.Matrix3X2<ushort>(Silk.NET.Maths.Matrix3X2<T> from) -> Silk.NET.Maths.Matrix3X2<ushort>
+static Silk.NET.Maths.Matrix3X2<T>.explicit operator System.Numerics.Matrix3x2(Silk.NET.Maths.Matrix3X2<T> from) -> System.Numerics.Matrix3x2
+static Silk.NET.Maths.Matrix3X2<T>.Identity.get -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator !=(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> bool
+static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> left, T right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Matrix3X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator *(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator *(T left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator +(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator -(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator -(Silk.NET.Maths.Matrix3X2<T> value) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X2<T>.operator ==(Silk.NET.Maths.Matrix3X2<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> bool
+static Silk.NET.Maths.Matrix3X3.Add<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateRotationX<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateRotationY<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateRotationZ<T>(T radians) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.CreateScale<T>(T xScale, T yScale, T zScale) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Lerp<T>(Silk.NET.Maths.Matrix3X3<T> value1, Silk.NET.Maths.Matrix3X3<T> value2, T amount) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, T right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X3.Multiply<T>(T left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Negate<T>(Silk.NET.Maths.Matrix3X3<T> value) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Subtract<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Transform<T>(Silk.NET.Maths.Matrix3X3<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3.Transpose<T>(Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix3X3<TOther> other) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix3X3<TOther> other) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix3X3<TOther> other) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<byte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<byte>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<decimal>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<decimal>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<double>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<double>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<float>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<float>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<int>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<int>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<long>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<long>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<sbyte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<sbyte>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<short>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<short>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<System.Half>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<System.Half>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<uint>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<uint>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<ulong>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ulong>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator checked Silk.NET.Maths.Matrix3X3<ushort>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ushort>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<byte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<byte>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<decimal>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<decimal>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<double>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<double>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<float>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<float>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<int>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<int>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<long>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<long>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<sbyte>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<sbyte>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<short>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<short>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<System.Half>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<System.Half>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<uint>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<uint>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<ulong>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ulong>
+static Silk.NET.Maths.Matrix3X3<T>.explicit operator Silk.NET.Maths.Matrix3X3<ushort>(Silk.NET.Maths.Matrix3X3<T> from) -> Silk.NET.Maths.Matrix3X3<ushort>
+static Silk.NET.Maths.Matrix3X3<T>.Identity.get -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator !=(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> bool
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> left, T right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Matrix3X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator *(T left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator +(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator -(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator -(Silk.NET.Maths.Matrix3X3<T> value) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X3<T>.operator ==(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> bool
+static Silk.NET.Maths.Matrix3X4.Add<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Lerp<T>(Silk.NET.Maths.Matrix3X4<T> value1, Silk.NET.Maths.Matrix3X4<T> value2, T amount) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, T right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix3X4.Multiply<T>(T left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Negate<T>(Silk.NET.Maths.Matrix3X4<T> value) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4.Subtract<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix3X4<TOther> other) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix3X4<TOther> other) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix3X4<TOther> other) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<byte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<byte>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<decimal>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<decimal>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<double>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<double>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<float>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<float>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<int>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<int>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<long>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<long>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<sbyte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<sbyte>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<short>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<short>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<System.Half>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<System.Half>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<uint>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<uint>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<ulong>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ulong>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator checked Silk.NET.Maths.Matrix3X4<ushort>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ushort>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<byte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<byte>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<decimal>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<decimal>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<double>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<double>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<float>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<float>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<int>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<int>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<long>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<long>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<sbyte>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<sbyte>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<short>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<short>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<System.Half>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<System.Half>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<uint>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<uint>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<ulong>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ulong>
+static Silk.NET.Maths.Matrix3X4<T>.explicit operator Silk.NET.Maths.Matrix3X4<ushort>(Silk.NET.Maths.Matrix3X4<T> from) -> Silk.NET.Maths.Matrix3X4<ushort>
+static Silk.NET.Maths.Matrix3X4<T>.Identity.get -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator !=(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> bool
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix2X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> left, T right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(Silk.NET.Maths.Vector3D<T> rowVector, Silk.NET.Maths.Matrix3X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator *(T left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator +(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator -(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator -(Silk.NET.Maths.Matrix3X4<T> value) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix3X4<T>.operator ==(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> bool
+static Silk.NET.Maths.Matrix4X2.Add<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Lerp<T>(Silk.NET.Maths.Matrix4X2<T> value1, Silk.NET.Maths.Matrix4X2<T> value2, T amount) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix2X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix3X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> left, T right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix4X2.Multiply<T>(T left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Negate<T>(Silk.NET.Maths.Matrix4X2<T> value) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2.Subtract<T>(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix4X2<TOther> other) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix4X2<TOther> other) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix4X2<TOther> other) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<byte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<byte>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<decimal>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<decimal>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<double>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<double>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<float>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<float>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<int>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<int>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<long>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<long>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<sbyte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<sbyte>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<short>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<short>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<System.Half>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<System.Half>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<uint>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<uint>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<ulong>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ulong>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator checked Silk.NET.Maths.Matrix4X2<ushort>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ushort>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<byte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<byte>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<decimal>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<decimal>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<double>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<double>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<float>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<float>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<int>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<int>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<long>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<long>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<sbyte>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<sbyte>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<short>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<short>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<System.Half>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<System.Half>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<uint>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<uint>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<ulong>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ulong>
+static Silk.NET.Maths.Matrix4X2<T>.explicit operator Silk.NET.Maths.Matrix4X2<ushort>(Silk.NET.Maths.Matrix4X2<T> from) -> Silk.NET.Maths.Matrix4X2<ushort>
+static Silk.NET.Maths.Matrix4X2<T>.Identity.get -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator !=(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> bool
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix2X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> left, T right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Matrix4X2<T> matrix, Silk.NET.Maths.Vector2D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X2<T> matrix) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator *(T left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator +(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator -(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator -(Silk.NET.Maths.Matrix4X2<T> value) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X2<T>.operator ==(Silk.NET.Maths.Matrix4X2<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> bool
+static Silk.NET.Maths.Matrix4X3.Add<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Lerp<T>(Silk.NET.Maths.Matrix4X3<T> value1, Silk.NET.Maths.Matrix4X3<T> value2, T amount) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix3X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> left, T right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix4X3.Multiply<T>(T left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Negate<T>(Silk.NET.Maths.Matrix4X3<T> value) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3.Subtract<T>(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix4X3<TOther> other) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix4X3<TOther> other) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix4X3<TOther> other) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<byte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<byte>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<decimal>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<decimal>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<double>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<double>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<float>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<float>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<int>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<int>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<long>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<long>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<sbyte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<sbyte>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<short>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<short>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<System.Half>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<System.Half>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<uint>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<uint>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<ulong>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ulong>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator checked Silk.NET.Maths.Matrix4X3<ushort>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ushort>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<byte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<byte>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<decimal>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<decimal>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<double>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<double>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<float>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<float>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<int>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<int>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<long>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<long>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<sbyte>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<sbyte>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<short>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<short>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<System.Half>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<System.Half>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<uint>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<uint>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<ulong>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ulong>
+static Silk.NET.Maths.Matrix4X3<T>.explicit operator Silk.NET.Maths.Matrix4X3<ushort>(Silk.NET.Maths.Matrix4X3<T> from) -> Silk.NET.Maths.Matrix4X3<ushort>
+static Silk.NET.Maths.Matrix4X3<T>.Identity.get -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator !=(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> bool
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix2X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix3X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> left, T right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Matrix4X3<T> matrix, Silk.NET.Maths.Vector3D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X3<T> matrix) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator *(T left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator +(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator -(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator -(Silk.NET.Maths.Matrix4X3<T> value) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X3<T>.operator ==(Silk.NET.Maths.Matrix4X3<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> bool
+static Silk.NET.Maths.Matrix4X4.Add<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraUpVector, Silk.NET.Maths.Vector3D<T> cameraForwardVector) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateConstrainedBillboard<T>(Silk.NET.Maths.Vector3D<T> objectPosition, Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> rotateAxis, Silk.NET.Maths.Vector3D<T> cameraForwardVector, Silk.NET.Maths.Vector3D<T> objectForwardVector) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateFromAxisAngle<T>(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateFromQuaternion<T>(Silk.NET.Maths.Quaternion<T> quaternion) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateFromYawPitchRoll<T>(T yaw, T pitch, T roll) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateLookAt<T>(Silk.NET.Maths.Vector3D<T> cameraPosition, Silk.NET.Maths.Vector3D<T> cameraTarget, Silk.NET.Maths.Vector3D<T> cameraUpVector) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateOrthographic<T>(T width, T height, T zNearPlane, T zFarPlane) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateOrthographicOffCenter<T>(T left, T right, T bottom, T top, T zNearPlane, T zFarPlane) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreatePerspective<T>(T width, T height, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreatePerspectiveFieldOfView<T>(T fieldOfView, T aspectRatio, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreatePerspectiveOffCenter<T>(T left, T right, T bottom, T top, T nearPlaneDistance, T farPlaneDistance) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateReflection<T>(Silk.NET.Maths.Plane<T> value) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationX<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationX<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationY<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationY<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationZ<T>(T radians) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateRotationZ<T>(T radians, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(Silk.NET.Maths.Vector3D<T> scales, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T scale) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T scale, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T xScale, T yScale, T zScale) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateScale<T>(T xScale, T yScale, T zScale, Silk.NET.Maths.Vector3D<T> centerPoint) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateShadow<T>(Silk.NET.Maths.Vector3D<T> lightDirection, Silk.NET.Maths.Plane<T> plane) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateTranslation<T>(Silk.NET.Maths.Vector3D<T> position) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateTranslation<T>(T xPosition, T yPosition, T zPosition) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.CreateWorld<T>(Silk.NET.Maths.Vector3D<T> position, Silk.NET.Maths.Vector3D<T> forward, Silk.NET.Maths.Vector3D<T> up) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Invert<T>(Silk.NET.Maths.Matrix4X4<T> matrix, out Silk.NET.Maths.Matrix4X4<T> result) -> bool
+static Silk.NET.Maths.Matrix4X4.Lerp<T>(Silk.NET.Maths.Matrix4X4<T> value1, Silk.NET.Maths.Matrix4X4<T> value2, T amount) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> left, T right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix4X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X4.Multiply<T>(T left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Negate<T>(Silk.NET.Maths.Matrix4X4<T> value) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Subtract<T>(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Transform<T>(Silk.NET.Maths.Matrix4X4<T> value, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4.Transpose<T>(Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix4X4<TOther> other) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix4X4<TOther> other) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix4X4<TOther> other) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<byte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<byte>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<decimal>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<decimal>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<double>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<double>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<float>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<float>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<int>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<int>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<long>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<long>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<sbyte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<sbyte>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<short>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<short>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<System.Half>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<System.Half>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<uint>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<uint>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<ulong>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ulong>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator checked Silk.NET.Maths.Matrix4X4<ushort>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ushort>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<byte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<byte>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<decimal>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<decimal>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<double>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<double>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<float>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<float>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<int>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<int>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<long>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<long>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<sbyte>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<sbyte>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<short>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<short>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<System.Half>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<System.Half>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<uint>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<uint>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<ulong>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ulong>
+static Silk.NET.Maths.Matrix4X4<T>.explicit operator Silk.NET.Maths.Matrix4X4<ushort>(Silk.NET.Maths.Matrix4X4<T> from) -> Silk.NET.Maths.Matrix4X4<ushort>
+static Silk.NET.Maths.Matrix4X4<T>.Identity.get -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator !=(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> bool
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix2X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix2X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix3X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix3X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X2<T> right) -> Silk.NET.Maths.Matrix4X2<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X3<T> right) -> Silk.NET.Maths.Matrix4X3<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> left, T right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Matrix4X4<T> matrix, Silk.NET.Maths.Vector4D<T> columnVector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(Silk.NET.Maths.Vector4D<T> rowVector, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator *(T left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator +(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator -(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator -(Silk.NET.Maths.Matrix4X4<T> value) -> Silk.NET.Maths.Matrix4X4<T>
+static Silk.NET.Maths.Matrix4X4<T>.operator ==(Silk.NET.Maths.Matrix4X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> bool
+static Silk.NET.Maths.Matrix5X4.Add<T>(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Lerp<T>(Silk.NET.Maths.Matrix5X4<T> value1, Silk.NET.Maths.Matrix5X4<T> value2, T amount) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Multiply<T>(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Multiply<T>(Silk.NET.Maths.Matrix5X4<T> left, T right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Multiply<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix5X4.Multiply<T>(T left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Negate<T>(Silk.NET.Maths.Matrix5X4<T> value) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4.Subtract<T>(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.CreateChecked<TOther>(Silk.NET.Maths.Matrix5X4<TOther> other) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.CreateSaturating<TOther>(Silk.NET.Maths.Matrix5X4<TOther> other) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.CreateTruncating<TOther>(Silk.NET.Maths.Matrix5X4<TOther> other) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<byte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<byte>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<decimal>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<decimal>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<double>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<double>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<float>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<float>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<int>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<int>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<long>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<long>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<sbyte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<sbyte>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<short>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<short>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<System.Half>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<System.Half>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<uint>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<uint>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<ulong>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ulong>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator checked Silk.NET.Maths.Matrix5X4<ushort>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ushort>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<byte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<byte>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<decimal>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<decimal>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<double>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<double>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<float>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<float>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<int>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<int>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<long>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<long>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<sbyte>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<sbyte>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<short>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<short>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<System.Half>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<System.Half>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<uint>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<uint>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<ulong>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ulong>
+static Silk.NET.Maths.Matrix5X4<T>.explicit operator Silk.NET.Maths.Matrix5X4<ushort>(Silk.NET.Maths.Matrix5X4<T> from) -> Silk.NET.Maths.Matrix5X4<ushort>
+static Silk.NET.Maths.Matrix5X4<T>.Identity.get -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator !=(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> bool
+static Silk.NET.Maths.Matrix5X4<T>.operator *(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix4X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator *(Silk.NET.Maths.Matrix5X4<T> left, T right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator *(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Matrix5X4<T> value2) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator *(T left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator +(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator -(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator -(Silk.NET.Maths.Matrix5X4<T> value) -> Silk.NET.Maths.Matrix5X4<T>
+static Silk.NET.Maths.Matrix5X4<T>.operator ==(Silk.NET.Maths.Matrix5X4<T> left, Silk.NET.Maths.Matrix5X4<T> right) -> bool
+static Silk.NET.Maths.Plane.CreateFromVertices<T>(Silk.NET.Maths.Vector3D<T> point1, Silk.NET.Maths.Vector3D<T> point2, Silk.NET.Maths.Vector3D<T> point3) -> Silk.NET.Maths.Plane<T>
+static Silk.NET.Maths.Plane.Dot<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector4D<T> value) -> T
+static Silk.NET.Maths.Plane.DotCoordinate<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector3D<T> value) -> T
+static Silk.NET.Maths.Plane.DotNormal<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Vector3D<T> value) -> T
+static Silk.NET.Maths.Plane.Normalize<T>(Silk.NET.Maths.Plane<T> value) -> Silk.NET.Maths.Plane<T>
+static Silk.NET.Maths.Plane.Transform<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Plane<T>
+static Silk.NET.Maths.Plane.Transform<T>(Silk.NET.Maths.Plane<T> plane, Silk.NET.Maths.Quaternion<T> rotation) -> Silk.NET.Maths.Plane<T>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<byte>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<byte>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<decimal>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<decimal>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<double>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<double>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<float>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<float>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<int>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<int>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<long>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<long>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<sbyte>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<sbyte>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<short>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<short>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<System.Half>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<System.Half>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<uint>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<uint>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<ulong>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<ulong>
+static Silk.NET.Maths.Plane<T>.explicit operator Silk.NET.Maths.Plane<ushort>(Silk.NET.Maths.Plane<T> from) -> Silk.NET.Maths.Plane<ushort>
+static Silk.NET.Maths.Plane<T>.explicit operator System.Numerics.Plane(Silk.NET.Maths.Plane<T> from) -> System.Numerics.Plane
+static Silk.NET.Maths.Plane<T>.operator !=(Silk.NET.Maths.Plane<T> value1, Silk.NET.Maths.Plane<T> value2) -> bool
+static Silk.NET.Maths.Plane<T>.operator ==(Silk.NET.Maths.Plane<T> value1, Silk.NET.Maths.Plane<T> value2) -> bool
+static Silk.NET.Maths.Quaternion<T>.Add(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Concatenate(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Conjugate(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.CreateFromAxisAngle(Silk.NET.Maths.Vector3D<T> axis, T angle) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.CreateFromRotationMatrix(Silk.NET.Maths.Matrix3X3<T> matrix) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.CreateFromRotationMatrix(Silk.NET.Maths.Matrix4X4<T> matrix) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.CreateFromYawPitchRoll(T yaw, T pitch, T roll) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Divide(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Dot(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2) -> T
+static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<double>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<double>
+static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<float>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<float>
+static Silk.NET.Maths.Quaternion<T>.explicit operator Silk.NET.Maths.Quaternion<System.Half>(Silk.NET.Maths.Quaternion<T> from) -> Silk.NET.Maths.Quaternion<System.Half>
+static Silk.NET.Maths.Quaternion<T>.explicit operator System.Numerics.Quaternion(Silk.NET.Maths.Quaternion<T> from) -> System.Numerics.Quaternion
+static Silk.NET.Maths.Quaternion<T>.Identity.get -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Inverse(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Lerp(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2, T amount) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Multiply(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Multiply(Silk.NET.Maths.Quaternion<T> value1, T value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Negate(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Normalize(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator !=(Silk.NET.Maths.Quaternion<T> left, Silk.NET.Maths.Quaternion<T> right) -> bool
+static Silk.NET.Maths.Quaternion<T>.operator *(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator *(Silk.NET.Maths.Quaternion<T> value1, T value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator +(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator -(Silk.NET.Maths.Quaternion<T> value) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator -(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator /(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.operator ==(Silk.NET.Maths.Quaternion<T> left, Silk.NET.Maths.Quaternion<T> right) -> bool
+static Silk.NET.Maths.Quaternion<T>.Slerp(Silk.NET.Maths.Quaternion<T> quaternion1, Silk.NET.Maths.Quaternion<T> quaternion2, T amount) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Quaternion<T>.Subtract(Silk.NET.Maths.Quaternion<T> value1, Silk.NET.Maths.Quaternion<T> value2) -> Silk.NET.Maths.Quaternion<T>
+static Silk.NET.Maths.Ray2D<T>.operator !=(Silk.NET.Maths.Ray2D<T> value1, Silk.NET.Maths.Ray2D<T> value2) -> bool
+static Silk.NET.Maths.Ray2D<T>.operator ==(Silk.NET.Maths.Ray2D<T> value1, Silk.NET.Maths.Ray2D<T> value2) -> bool
+static Silk.NET.Maths.Ray3D<T>.operator !=(Silk.NET.Maths.Ray3D<T> value1, Silk.NET.Maths.Ray3D<T> value2) -> bool
+static Silk.NET.Maths.Ray3D<T>.operator ==(Silk.NET.Maths.Ray3D<T> value1, Silk.NET.Maths.Ray3D<T> value2) -> bool
+static Silk.NET.Maths.Rectangle.FromLTRB<T>(T left, T top, T right, T bottom) -> Silk.NET.Maths.Rectangle<T>
+static Silk.NET.Maths.Rectangle<T>.operator !=(Silk.NET.Maths.Rectangle<T> value1, Silk.NET.Maths.Rectangle<T> value2) -> bool
+static Silk.NET.Maths.Rectangle<T>.operator ==(Silk.NET.Maths.Rectangle<T> value1, Silk.NET.Maths.Rectangle<T> value2) -> bool
+static Silk.NET.Maths.Scalar.Abs<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Acos<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Acosh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Add<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.And<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.As<TFrom, TTo>(TFrom val) -> TTo
+static Silk.NET.Maths.Scalar.Asin<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Asinh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Atan2<T>(T y, T x) -> T
+static Silk.NET.Maths.Scalar.Atan<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Atanh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Cbrt<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Ceiling<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Cos<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Cosh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.DegreesToRadians<T>(T degrees) -> T
+static Silk.NET.Maths.Scalar.Divide<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.Equal<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.Exp<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Floor<T>(T x) -> T
+static Silk.NET.Maths.Scalar.GreaterThan<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.GreaterThanOrEqual<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.IEEERemainder<T>(T x, T y) -> T
+static Silk.NET.Maths.Scalar.IsFinite<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsHardwareAccelerated.get -> bool
+static Silk.NET.Maths.Scalar.IsInfinity<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsNaN<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsNegative<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsNegativeInfinity<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsNormal<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsPositiveInfinity<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.IsSubnormal<T>(T f) -> bool
+static Silk.NET.Maths.Scalar.LessThan<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.LessThanOrEqual<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.Log10<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Log<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Log<T>(T x, T y) -> T
+static Silk.NET.Maths.Scalar.Max<T>(T x, T y) -> T
+static Silk.NET.Maths.Scalar.Min<T>(T x, T y) -> T
+static Silk.NET.Maths.Scalar.Multiply<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.Negate<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Not<T>(T value) -> T
+static Silk.NET.Maths.Scalar.NotEqual<T>(T left, T right) -> bool
+static Silk.NET.Maths.Scalar.Or<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.Pow<T>(T x, T y) -> T
+static Silk.NET.Maths.Scalar.RadiansToDegrees<T>(T radians) -> T
+static Silk.NET.Maths.Scalar.Reciprocal<T>(T x) -> T
+static Silk.NET.Maths.Scalar.RotateLeft<T>(T value, int offset) -> T
+static Silk.NET.Maths.Scalar.RotateRight<T>(T value, int offset) -> T
+static Silk.NET.Maths.Scalar.Round<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Round<T>(T x, int digits) -> T
+static Silk.NET.Maths.Scalar.Round<T>(T x, int digits, System.MidpointRounding mode) -> T
+static Silk.NET.Maths.Scalar.Round<T>(T x, System.MidpointRounding mode) -> T
+static Silk.NET.Maths.Scalar.ShiftLeft<T>(T value, int offset) -> T
+static Silk.NET.Maths.Scalar.ShiftRight<T>(T value, int offset) -> T
+static Silk.NET.Maths.Scalar.Sign<T>(T x) -> int
+static Silk.NET.Maths.Scalar.Sin<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Sinh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Sqrt<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Subtract<T>(T left, T right) -> T
+static Silk.NET.Maths.Scalar.Tan<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Tanh<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Truncate<T>(T x) -> T
+static Silk.NET.Maths.Scalar.Xor<T>(T left, T right) -> T
+static Silk.NET.Maths.Sphere<T>.operator !=(Silk.NET.Maths.Sphere<T> value1, Silk.NET.Maths.Sphere<T> value2) -> bool
+static Silk.NET.Maths.Sphere<T>.operator ==(Silk.NET.Maths.Sphere<T> value1, Silk.NET.Maths.Sphere<T> value2) -> bool
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Matrix3x2 value) -> Silk.NET.Maths.Matrix3X2<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Matrix4x4 value) -> Silk.NET.Maths.Matrix4X4<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Plane value) -> Silk.NET.Maths.Plane<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Quaternion value) -> Silk.NET.Maths.Quaternion<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector2 value) -> Silk.NET.Maths.Vector2D<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector3 value) -> Silk.NET.Maths.Vector3D<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToGeneric(this System.Numerics.Vector4 value) -> Silk.NET.Maths.Vector4D<float>
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Matrix3X2<float> value) -> System.Numerics.Matrix3x2
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Matrix4X4<float> value) -> System.Numerics.Matrix4x4
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Plane<float> value) -> System.Numerics.Plane
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Quaternion<float> value) -> System.Numerics.Quaternion
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector2D<float> value) -> System.Numerics.Vector2
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector3D<float> value) -> System.Numerics.Vector3
+static Silk.NET.Maths.SystemNumericsExtensions.ToSystem(this Silk.NET.Maths.Vector4D<float> value) -> System.Numerics.Vector4
+static Silk.NET.Maths.Vector2D.Abs<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Acos<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Acosh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.AcosPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Asin<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Asinh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.AsinPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Atan2<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> y, Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Atan2Pi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> y, Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Atan<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Atanh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.AtanPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.BitDecrement<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.BitIncrement<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Cbrt<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Ceiling<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Clamp<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value, Silk.NET.Maths.Vector2D<TSelf> min, Silk.NET.Maths.Vector2D<TSelf> max) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Clamp<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value, TSelf min, TSelf max) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.CopySign<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value, Silk.NET.Maths.Vector2D<TSelf> sign) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.CopySign<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value, TSelf sign) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Cos<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Cosh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.CosPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Cross<T>(this Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> T
+static Silk.NET.Maths.Vector2D.Deconstruct<T>(this Silk.NET.Maths.Vector2D<T> vector, out T x, out T y) -> void
+static Silk.NET.Maths.Vector2D.DegreesToRadians<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> degrees) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Distance<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> T
+static Silk.NET.Maths.Vector2D.DistanceSquared<T>(Silk.NET.Maths.Vector2D<T> value1, Silk.NET.Maths.Vector2D<T> value2) -> T
+static Silk.NET.Maths.Vector2D.DivRem<T>(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> (Silk.NET.Maths.Vector2D<T> Quotient, Silk.NET.Maths.Vector2D<T> Remainder)
+static Silk.NET.Maths.Vector2D.Dot<T>(this Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> T
+static Silk.NET.Maths.Vector2D.Exp10<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Exp10M1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Exp2<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Exp2M1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Exp<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ExpM1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Floor<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> left, Silk.NET.Maths.Vector2D<TSelf> right, Silk.NET.Maths.Vector2D<TSelf> addend) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> left, TSelf right, TSelf addend) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Hypot<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> left, Silk.NET.Maths.Vector2D<TSelf> right) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> left, TSelf right) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ILogB<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<int>
+static Silk.NET.Maths.Vector2D.Lerp<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value1, Silk.NET.Maths.Vector2D<TSelf> value2, TSelf amount) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.LerpClamped<T>(Silk.NET.Maths.Vector2D<T> a, Silk.NET.Maths.Vector2D<T> b, Silk.NET.Maths.Vector2D<T> amount) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.LerpClamped<T>(Silk.NET.Maths.Vector2D<T> a, Silk.NET.Maths.Vector2D<T> b, T amount) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.Log10<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Log10P1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Log2<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Log2P1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Log<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Log<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf newBase) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.LogP1<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Max<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Max<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MaxMagnitude<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MaxMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Min<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Min<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MinMagnitude<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MinMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MinNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.MinNumber<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Multiply<T>(Silk.NET.Maths.Vector2D<T> left, T right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.Multiply<T>(T left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.Normalize<T>(this Silk.NET.Maths.Vector2D<T> vector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.PopCount<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Pow<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<TSelf> y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Pow<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.RadiansToDegrees<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> radians) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ReciprocalEstimate<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ReciprocalSqrtEstimate<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Reflect<T>(Silk.NET.Maths.Vector2D<T> vector, Silk.NET.Maths.Vector2D<T> normal) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D.RootN<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, int n) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.RootN<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<int> n) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Round<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Round<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, int digits, System.MidpointRounding mode) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ScaleB<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, int n) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.ScaleB<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x, Silk.NET.Maths.Vector2D<int> n) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Sign<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value) -> Silk.NET.Maths.Vector2D<int>
+static Silk.NET.Maths.Vector2D.Sin<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.SinCos<T>(this Silk.NET.Maths.Vector2D<T> x) -> (Silk.NET.Maths.Vector2D<T> Sin, Silk.NET.Maths.Vector2D<T> Cos)
+static Silk.NET.Maths.Vector2D.SinCosPi<T>(this Silk.NET.Maths.Vector2D<T> x) -> (Silk.NET.Maths.Vector2D<T> SinPi, Silk.NET.Maths.Vector2D<T> CosPi)
+static Silk.NET.Maths.Vector2D.Sinh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.SinPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Sqrt<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Tan<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Tanh<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.TanPi<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.TrailingZeroCount<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> value) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D.Truncate<TSelf>(this Silk.NET.Maths.Vector2D<TSelf> x) -> Silk.NET.Maths.Vector2D<TSelf>
+static Silk.NET.Maths.Vector2D<T>.CreateChecked<TOther>(Silk.NET.Maths.Vector2D<TOther> source) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.CreateSaturating<TOther>(Silk.NET.Maths.Vector2D<TOther> source) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.CreateTruncating<TOther>(Silk.NET.Maths.Vector2D<TOther> source) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<byte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<byte>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<decimal>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<decimal>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<double>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<double>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<float>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<float>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<int>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<int>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<long>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<long>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<sbyte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<sbyte>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<short>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<short>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<System.Half>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<System.Half>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<uint>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<uint>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<ulong>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ulong>
+static Silk.NET.Maths.Vector2D<T>.explicit operator checked Silk.NET.Maths.Vector2D<ushort>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ushort>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<byte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<byte>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<decimal>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<decimal>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<double>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<double>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<float>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<float>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<int>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<int>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<long>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<long>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<sbyte>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<sbyte>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<short>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<short>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<System.Half>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<System.Half>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<T>(System.Numerics.Vector2 v) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<uint>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<uint>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<ulong>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ulong>
+static Silk.NET.Maths.Vector2D<T>.explicit operator Silk.NET.Maths.Vector2D<ushort>(Silk.NET.Maths.Vector2D<T> from) -> Silk.NET.Maths.Vector2D<ushort>
+static Silk.NET.Maths.Vector2D<T>.explicit operator System.Numerics.Vector2(Silk.NET.Maths.Vector2D<T> v) -> System.Numerics.Vector2
+static Silk.NET.Maths.Vector2D<T>.implicit operator (T X, T Y)(Silk.NET.Maths.Vector2D<T> v) -> (T X, T Y)
+static Silk.NET.Maths.Vector2D<T>.implicit operator Silk.NET.Maths.Vector2D<T>((T X, T Y) v) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.One.get -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator !=(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> bool
+static Silk.NET.Maths.Vector2D<T>.operator *(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator *(Silk.NET.Maths.Vector2D<T> vector, T scalar) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator *(T scalar, Silk.NET.Maths.Vector2D<T> vector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator +(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator +(Silk.NET.Maths.Vector2D<T> vector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator +(Silk.NET.Maths.Vector2D<T> vector, T scalar) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator -(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator -(Silk.NET.Maths.Vector2D<T> vector) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator -(Silk.NET.Maths.Vector2D<T> vector, T scalar) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator /(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator /(Silk.NET.Maths.Vector2D<T> vector, T scalar) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.operator ==(Silk.NET.Maths.Vector2D<T> left, Silk.NET.Maths.Vector2D<T> right) -> bool
+static Silk.NET.Maths.Vector2D<T>.Parse(string! s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.Parse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.Parse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.TryParse(string? s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector2D<T> result) -> bool
+static Silk.NET.Maths.Vector2D<T>.TryParse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider, out Silk.NET.Maths.Vector2D<T> result) -> bool
+static Silk.NET.Maths.Vector2D<T>.TryParse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector2D<T> result) -> bool
+static Silk.NET.Maths.Vector2D<T>.UnitX.get -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.UnitY.get -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector2D<T>.Zero.get -> Silk.NET.Maths.Vector2D<T>
+static Silk.NET.Maths.Vector3D.Abs<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Acos<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Acosh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.AcosPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Asin<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Asinh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.AsinPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Atan2<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> y, Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Atan2Pi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> y, Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Atan<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Atanh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.AtanPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.BitDecrement<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.BitIncrement<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Cbrt<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Ceiling<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Clamp<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value, Silk.NET.Maths.Vector3D<TSelf> min, Silk.NET.Maths.Vector3D<TSelf> max) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Clamp<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value, TSelf min, TSelf max) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.CopySign<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value, Silk.NET.Maths.Vector3D<TSelf> sign) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.CopySign<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value, TSelf sign) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Cos<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Cosh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.CosPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Cross<T>(this Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.Deconstruct<T>(this Silk.NET.Maths.Vector3D<T> vector, out T x, out T y, out T z) -> void
+static Silk.NET.Maths.Vector3D.DegreesToRadians<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> degrees) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Distance<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> T
+static Silk.NET.Maths.Vector3D.DistanceSquared<T>(Silk.NET.Maths.Vector3D<T> value1, Silk.NET.Maths.Vector3D<T> value2) -> T
+static Silk.NET.Maths.Vector3D.DivRem<T>(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> (Silk.NET.Maths.Vector3D<T> Quotient, Silk.NET.Maths.Vector3D<T> Remainder)
+static Silk.NET.Maths.Vector3D.Dot<T>(this Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> T
+static Silk.NET.Maths.Vector3D.Exp10<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Exp10M1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Exp2<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Exp2M1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Exp<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ExpM1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Floor<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> left, Silk.NET.Maths.Vector3D<TSelf> right, Silk.NET.Maths.Vector3D<TSelf> addend) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> left, TSelf right, TSelf addend) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Hypot<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> left, Silk.NET.Maths.Vector3D<TSelf> right) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> left, TSelf right) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ILogB<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<int>
+static Silk.NET.Maths.Vector3D.Lerp<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value1, Silk.NET.Maths.Vector3D<TSelf> value2, TSelf amount) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.LerpClamped<T>(Silk.NET.Maths.Vector3D<T> a, Silk.NET.Maths.Vector3D<T> b, Silk.NET.Maths.Vector3D<T> amount) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.LerpClamped<T>(Silk.NET.Maths.Vector3D<T> a, Silk.NET.Maths.Vector3D<T> b, T amount) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.Log10<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Log10P1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Log2<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Log2P1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Log<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Log<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf newBase) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.LogP1<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Max<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Max<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MaxMagnitude<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MaxMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Min<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Min<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MinMagnitude<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MinMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MinNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.MinNumber<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Multiply<T>(Silk.NET.Maths.Vector3D<T> left, T right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.Multiply<T>(T left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.Normalize<T>(this Silk.NET.Maths.Vector3D<T> vector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.PopCount<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Pow<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<TSelf> y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Pow<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.RadiansToDegrees<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> radians) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ReciprocalEstimate<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ReciprocalSqrtEstimate<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Reflect<T>(Silk.NET.Maths.Vector3D<T> vector, Silk.NET.Maths.Vector3D<T> normal) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D.RootN<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, int n) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.RootN<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<int> n) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Round<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Round<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, int digits, System.MidpointRounding mode) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ScaleB<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, int n) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.ScaleB<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x, Silk.NET.Maths.Vector3D<int> n) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Sign<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value) -> Silk.NET.Maths.Vector3D<int>
+static Silk.NET.Maths.Vector3D.Sin<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.SinCos<T>(this Silk.NET.Maths.Vector3D<T> x) -> (Silk.NET.Maths.Vector3D<T> Sin, Silk.NET.Maths.Vector3D<T> Cos)
+static Silk.NET.Maths.Vector3D.SinCosPi<T>(this Silk.NET.Maths.Vector3D<T> x) -> (Silk.NET.Maths.Vector3D<T> SinPi, Silk.NET.Maths.Vector3D<T> CosPi)
+static Silk.NET.Maths.Vector3D.Sinh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.SinPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Sqrt<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Tan<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Tanh<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.TanPi<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.TrailingZeroCount<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> value) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D.Truncate<TSelf>(this Silk.NET.Maths.Vector3D<TSelf> x) -> Silk.NET.Maths.Vector3D<TSelf>
+static Silk.NET.Maths.Vector3D<T>.CreateChecked<TOther>(Silk.NET.Maths.Vector3D<TOther> source) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.CreateSaturating<TOther>(Silk.NET.Maths.Vector3D<TOther> source) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.CreateTruncating<TOther>(Silk.NET.Maths.Vector3D<TOther> source) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<byte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<byte>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<decimal>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<decimal>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<double>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<double>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<float>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<float>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<int>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<int>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<long>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<long>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<sbyte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<sbyte>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<short>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<short>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<System.Half>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<System.Half>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<uint>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<uint>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<ulong>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ulong>
+static Silk.NET.Maths.Vector3D<T>.explicit operator checked Silk.NET.Maths.Vector3D<ushort>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ushort>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<byte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<byte>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<decimal>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<decimal>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<double>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<double>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<float>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<float>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<int>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<int>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<long>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<long>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<sbyte>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<sbyte>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<short>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<short>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<System.Half>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<System.Half>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<T>(System.Numerics.Vector3 v) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<uint>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<uint>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<ulong>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ulong>
+static Silk.NET.Maths.Vector3D<T>.explicit operator Silk.NET.Maths.Vector3D<ushort>(Silk.NET.Maths.Vector3D<T> from) -> Silk.NET.Maths.Vector3D<ushort>
+static Silk.NET.Maths.Vector3D<T>.explicit operator System.Numerics.Vector3(Silk.NET.Maths.Vector3D<T> v) -> System.Numerics.Vector3
+static Silk.NET.Maths.Vector3D<T>.implicit operator (T X, T Y, T Z)(Silk.NET.Maths.Vector3D<T> v) -> (T X, T Y, T Z)
+static Silk.NET.Maths.Vector3D<T>.implicit operator Silk.NET.Maths.Vector3D<T>((T X, T Y, T Z) v) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.One.get -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator !=(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> bool
+static Silk.NET.Maths.Vector3D<T>.operator *(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator *(Silk.NET.Maths.Vector3D<T> vector, T scalar) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator *(T scalar, Silk.NET.Maths.Vector3D<T> vector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator +(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator +(Silk.NET.Maths.Vector3D<T> vector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator +(Silk.NET.Maths.Vector3D<T> vector, T scalar) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator -(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator -(Silk.NET.Maths.Vector3D<T> vector) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator -(Silk.NET.Maths.Vector3D<T> vector, T scalar) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator /(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator /(Silk.NET.Maths.Vector3D<T> vector, T scalar) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.operator ==(Silk.NET.Maths.Vector3D<T> left, Silk.NET.Maths.Vector3D<T> right) -> bool
+static Silk.NET.Maths.Vector3D<T>.Parse(string! s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.Parse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.Parse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.TryParse(string? s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector3D<T> result) -> bool
+static Silk.NET.Maths.Vector3D<T>.TryParse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider, out Silk.NET.Maths.Vector3D<T> result) -> bool
+static Silk.NET.Maths.Vector3D<T>.TryParse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector3D<T> result) -> bool
+static Silk.NET.Maths.Vector3D<T>.UnitX.get -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.UnitY.get -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.UnitZ.get -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector3D<T>.Zero.get -> Silk.NET.Maths.Vector3D<T>
+static Silk.NET.Maths.Vector4D.Abs<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Acos<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Acosh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.AcosPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Asin<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Asinh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.AsinPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Atan2<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> y, Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Atan2Pi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> y, Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Atan<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Atanh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.AtanPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.BitDecrement<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.BitIncrement<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Cbrt<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Ceiling<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Clamp<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value, Silk.NET.Maths.Vector4D<TSelf> min, Silk.NET.Maths.Vector4D<TSelf> max) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Clamp<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value, TSelf min, TSelf max) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.CopySign<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value, Silk.NET.Maths.Vector4D<TSelf> sign) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.CopySign<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value, TSelf sign) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Cos<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Cosh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.CosPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Deconstruct<T>(this Silk.NET.Maths.Vector4D<T> vector, out T x, out T y, out T z, out T w) -> void
+static Silk.NET.Maths.Vector4D.DegreesToRadians<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> degrees) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Distance<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> T
+static Silk.NET.Maths.Vector4D.DistanceSquared<T>(Silk.NET.Maths.Vector4D<T> value1, Silk.NET.Maths.Vector4D<T> value2) -> T
+static Silk.NET.Maths.Vector4D.DivRem<T>(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> (Silk.NET.Maths.Vector4D<T> Quotient, Silk.NET.Maths.Vector4D<T> Remainder)
+static Silk.NET.Maths.Vector4D.Dot<T>(this Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> T
+static Silk.NET.Maths.Vector4D.Exp10<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Exp10M1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Exp2<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Exp2M1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Exp<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ExpM1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Floor<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> left, Silk.NET.Maths.Vector4D<TSelf> right, Silk.NET.Maths.Vector4D<TSelf> addend) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.FusedMultiplyAdd<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> left, TSelf right, TSelf addend) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Hypot<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> left, Silk.NET.Maths.Vector4D<TSelf> right) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Ieee754Remainder<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> left, TSelf right) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ILogB<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<int>
+static Silk.NET.Maths.Vector4D.Lerp<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value1, Silk.NET.Maths.Vector4D<TSelf> value2, TSelf amount) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.LerpClamped<T>(Silk.NET.Maths.Vector4D<T> a, Silk.NET.Maths.Vector4D<T> b, Silk.NET.Maths.Vector4D<T> amount) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.LerpClamped<T>(Silk.NET.Maths.Vector4D<T> a, Silk.NET.Maths.Vector4D<T> b, T amount) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.Log10<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Log10P1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Log2<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Log2P1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Log<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Log<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf newBase) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.LogP1<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Max<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Max<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MaxMagnitude<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MaxMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MaxNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Min<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Min<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MinMagnitude<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MinMagnitudeNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MinNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.MinNumber<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Multiply<T>(Silk.NET.Maths.Vector4D<T> left, T right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.Multiply<T>(T left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.Normalize<T>(this Silk.NET.Maths.Vector4D<T> vector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.PopCount<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Pow<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<TSelf> y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Pow<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, TSelf y) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.RadiansToDegrees<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> radians) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ReciprocalEstimate<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ReciprocalSqrtEstimate<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Reflect<T>(Silk.NET.Maths.Vector4D<T> vector, Silk.NET.Maths.Vector4D<T> normal) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D.RootN<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, int n) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.RootN<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<int> n) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Round<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Round<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, int digits, System.MidpointRounding mode) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ScaleB<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, int n) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.ScaleB<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x, Silk.NET.Maths.Vector4D<int> n) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Sign<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value) -> Silk.NET.Maths.Vector4D<int>
+static Silk.NET.Maths.Vector4D.Sin<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.SinCos<T>(this Silk.NET.Maths.Vector4D<T> x) -> (Silk.NET.Maths.Vector4D<T> Sin, Silk.NET.Maths.Vector4D<T> Cos)
+static Silk.NET.Maths.Vector4D.SinCosPi<T>(this Silk.NET.Maths.Vector4D<T> x) -> (Silk.NET.Maths.Vector4D<T> SinPi, Silk.NET.Maths.Vector4D<T> CosPi)
+static Silk.NET.Maths.Vector4D.Sinh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.SinPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Sqrt<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Tan<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Tanh<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.TanPi<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.TrailingZeroCount<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> value) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D.Truncate<TSelf>(this Silk.NET.Maths.Vector4D<TSelf> x) -> Silk.NET.Maths.Vector4D<TSelf>
+static Silk.NET.Maths.Vector4D<T>.CreateChecked<TOther>(Silk.NET.Maths.Vector4D<TOther> source) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.CreateSaturating<TOther>(Silk.NET.Maths.Vector4D<TOther> source) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.CreateTruncating<TOther>(Silk.NET.Maths.Vector4D<TOther> source) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<byte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<byte>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<decimal>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<decimal>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<double>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<double>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<float>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<float>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<int>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<int>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<long>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<long>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<sbyte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<sbyte>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<short>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<short>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<System.Half>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<System.Half>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<uint>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<uint>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<ulong>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ulong>
+static Silk.NET.Maths.Vector4D<T>.explicit operator checked Silk.NET.Maths.Vector4D<ushort>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ushort>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<byte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<byte>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<decimal>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<decimal>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<double>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<double>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<float>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<float>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<int>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<int>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<long>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<long>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<sbyte>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<sbyte>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<short>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<short>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<System.Half>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<System.Half>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<T>(System.Numerics.Vector4 v) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<uint>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<uint>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<ulong>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ulong>
+static Silk.NET.Maths.Vector4D<T>.explicit operator Silk.NET.Maths.Vector4D<ushort>(Silk.NET.Maths.Vector4D<T> from) -> Silk.NET.Maths.Vector4D<ushort>
+static Silk.NET.Maths.Vector4D<T>.explicit operator System.Numerics.Vector4(Silk.NET.Maths.Vector4D<T> v) -> System.Numerics.Vector4
+static Silk.NET.Maths.Vector4D<T>.implicit operator (T X, T Y, T Z, T W)(Silk.NET.Maths.Vector4D<T> v) -> (T X, T Y, T Z, T W)
+static Silk.NET.Maths.Vector4D<T>.implicit operator Silk.NET.Maths.Vector4D<T>((T X, T Y, T Z, T W) v) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.One.get -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator !=(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> bool
+static Silk.NET.Maths.Vector4D<T>.operator *(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator *(Silk.NET.Maths.Vector4D<T> vector, T scalar) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator *(T scalar, Silk.NET.Maths.Vector4D<T> vector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator +(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator +(Silk.NET.Maths.Vector4D<T> vector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator +(Silk.NET.Maths.Vector4D<T> vector, T scalar) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator -(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator -(Silk.NET.Maths.Vector4D<T> vector) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator -(Silk.NET.Maths.Vector4D<T> vector, T scalar) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator /(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator /(Silk.NET.Maths.Vector4D<T> vector, T scalar) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.operator ==(Silk.NET.Maths.Vector4D<T> left, Silk.NET.Maths.Vector4D<T> right) -> bool
+static Silk.NET.Maths.Vector4D<T>.Parse(string! s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.Parse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.Parse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider) -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.TryParse(string? s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector4D<T> result) -> bool
+static Silk.NET.Maths.Vector4D<T>.TryParse(System.ReadOnlySpan<byte> utf8Text, System.IFormatProvider? provider, out Silk.NET.Maths.Vector4D<T> result) -> bool
+static Silk.NET.Maths.Vector4D<T>.TryParse(System.ReadOnlySpan<char> s, System.IFormatProvider? provider, out Silk.NET.Maths.Vector4D<T> result) -> bool
+static Silk.NET.Maths.Vector4D<T>.UnitW.get -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.UnitX.get -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.UnitY.get -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.UnitZ.get -> Silk.NET.Maths.Vector4D<T>
+static Silk.NET.Maths.Vector4D<T>.Zero.get -> Silk.NET.Maths.Vector4D<T>