Matrix2x3 and Matrix2x4 implementatinos

Source/OpenTK/Math/Matrix2.cs

@@ -47,7 +47,7 @@ namespace OpenTK
         /// <summary>
         /// The identity matrix.
         /// </summary>
-        public static Matrix2 Identity = new Matrix2(Vector2.UnitX, Vector2.UnitY);
+        public static readonly Matrix2 Identity = new Matrix2(Vector2.UnitX, Vector2.UnitY);
 
         /// <summary>
         /// The zero matrix.
@@ -169,7 +169,17 @@ namespace OpenTK
 
         #region Instance
 
+        #region public void Transpose()
 
+        /// <summary>
+        /// Converts this instance to it's transpose.
+        /// </summary>
+        public void Transpose()
+        {
+            this = Matrix2.Transpose(this);
+        }
+
+        #endregion
 
         #endregion
 
@@ -530,7 +540,7 @@ namespace OpenTK
         /// <returns>A new Matrix2 which holds the result of the multiplication</returns>
         public static Matrix2 operator *(float left, Matrix2 right)
         {
-            return Matrix2.Mult(right, left);
+            return Mult(right, left);
         }
 
         /// <summary>
@@ -541,7 +551,7 @@ namespace OpenTK
         /// <returns>A new Matrix2 which holds the result of the multiplication</returns>
         public static Matrix2 operator *(Matrix2 left, float right)
         {
-            return Matrix2.Mult(left, right);
+            return Mult(left, right);
         }
 
         /// <summary>
@@ -552,7 +562,7 @@ namespace OpenTK
         /// <returns>A new Matrix2 which holds the result of the multiplication</returns>
         public static Matrix2 operator *(Matrix2 left, Matrix2 right)
         {
-            return Matrix2.Mult(left, right);
+            return Mult(left, right);
         }
 
         /// <summary>
@@ -563,7 +573,7 @@ namespace OpenTK
         /// <returns>A new Matrix2x3 which holds the result of the multiplication</returns>
         public static Matrix2x3 operator *(Matrix2 left, Matrix2x3 right)
         {
-            return Matrix2.Mult(left, right);
+            return Mult(left, right);
         }
 
         /// <summary>
@@ -574,7 +584,7 @@ namespace OpenTK
         /// <returns>A new Matrix2x4 which holds the result of the multiplication</returns>
         public static Matrix2x4 operator *(Matrix2 left, Matrix2x4 right)
         {
-            return Matrix2.Mult(left, right);
+            return Mult(left, right);
         }
 
         /// <summary>
@@ -585,7 +595,7 @@ namespace OpenTK
         /// <returns>A new Matrix2 which holds the result of the addition</returns>
         public static Matrix2 operator +(Matrix2 left, Matrix2 right)
         {
-            return Matrix2.Add(left, right);
+            return Add(left, right);
         }
 
         /// <summary>
@@ -596,7 +606,7 @@ namespace OpenTK
         /// <returns>A new Matrix2 which holds the result of the subtraction</returns>
         public static Matrix2 operator -(Matrix2 left, Matrix2 right)
         {
-            return Matrix2.Subtract(left, right);
+            return Subtract(left, right);
         }
 
         /// <summary>

Source/OpenTK/Math/Matrix2x3.cs

@@ -47,7 +47,7 @@ namespace OpenTK
         /// <summary>
         /// The zero matrix.
         /// </summary>
-        public static Matrix2x3 Zero = new Matrix2x3(Vector3.Zero, Vector3.Zero);
+        public static readonly Matrix2x3 Zero = new Matrix2x3(Vector3.Zero, Vector3.Zero);
 
         #endregion
 
@@ -174,12 +174,435 @@ namespace OpenTK
 
         #region Static
 
+        #region CreateRotation
 
+        /// <summary>
+        /// Builds a rotation matrix.
+        /// </summary>
+        /// <param name="angle">The counter-clockwise angle in radians.</param>
+        /// <param name="result">The resulting Matrix2x3 instance.</param>
+        public static void CreateRotation(float angle, out Matrix2x3 result)
+        {
+            float cos = (float)System.Math.Cos(angle);
+            float sin = (float)System.Math.Sin(angle);
+
+            result.Row0.X = cos;
+            result.Row0.Y = sin;
+            result.Row0.Z = 0;
+            result.Row1.X = -sin;
+            result.Row1.Y = cos;
+            result.Row1.Z = 0;
+        }
+
+        /// <summary>
+        /// Builds a rotation matrix.
+        /// </summary>
+        /// <param name="angle">The counter-clockwise angle in radians.</param>
+        /// <returns>The resulting Matrix2x3 instance.</returns>
+        public static Matrix2x3 CreateRotation(float angle)
+        {
+            Matrix2x3 result;
+            CreateRotation(angle, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region CreateScale
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Single scale factor for the x, y, and z axes.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(float scale, out Matrix2x3 result)
+        {
+            result.Row0.X = scale;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = scale;
+            result.Row1.Z = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Single scale factor for the x and y axes.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x3 CreateScale(float scale)
+        {
+            Matrix2x3 result;
+            CreateScale(scale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Scale factors for the x and y axes.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(Vector2 scale, out Matrix2x3 result)
+        {
+            result.Row0.X = scale.X;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = scale.Y;
+            result.Row1.Z = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Scale factors for the x and y axes.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x3 CreateScale(Vector2 scale)
+        {
+            Matrix2x3 result;
+            CreateScale(scale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="x">Scale factor for the x axis.</param>
+        /// <param name="y">Scale factor for the y axis.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(float x, float y, out Matrix2x3 result)
+        {
+            result.Row0.X = x;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = y;
+            result.Row1.Z = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="x">Scale factor for the x axis.</param>
+        /// <param name="y">Scale factor for the y axis.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x3 CreateScale(float x, float y)
+        {
+            Matrix2x3 result;
+            CreateScale(x, y, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Multiply Functions
+
+        /// <summary>
+        /// Multiplies and instance by a scalar.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x3 left, float right, out Matrix2x3 result)
+        {
+            result.Row0.X = left.Row0.X * right;
+            result.Row0.Y = left.Row0.Y * right;
+            result.Row0.Z = left.Row0.Z * right;
+            result.Row1.X = left.Row1.X * right;
+            result.Row1.Y = left.Row1.Y * right;
+            result.Row1.Z = left.Row1.Z * right;
+        }
+
+        /// <summary>
+        /// Multiplies and instance by a scalar.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x3 Mult(Matrix2x3 left, float right)
+        {
+            Matrix2x3 result;
+            Mult(ref left, right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x3 left, ref Matrix3x2 right, out Matrix2 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y,
+                rM31 = right.Row2.X, rM32 = right.Row2.Y;
+
+            result.Row0.X = ((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31);
+            result.Row0.Y = ((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32);
+            result.Row1.X = ((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31);
+            result.Row1.Y = ((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2 Mult(Matrix2x3 left, Matrix3x2 right)
+        {
+            Matrix2 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x3 left, ref Matrix3 right, out Matrix2x3 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z,
+                rM31 = right.Row2.X, rm32 = right.Row2.Y, rM33 = right.Row2.Z;
+
+            result.Row0.X = ((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31);
+            result.Row0.Y = ((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rm32);
+            result.Row0.Z = ((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33);
+            result.Row1.X = ((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31);
+            result.Row1.Y = ((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rm32);
+            result.Row1.Z = ((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x3 Mult(Matrix2x3 left, Matrix3 right)
+        {
+            Matrix2x3 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x3 left, ref Matrix3x4 right, out Matrix2x4 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z, rM14 = right.Row0.W,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z, rM24 = right.Row1.W,
+                rM31 = right.Row2.X, rm32 = right.Row2.Y, rM33 = right.Row2.Z, rM34 = right.Row2.W;
+
+            result.Row0.X = ((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31);
+            result.Row0.Y = ((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rm32);
+            result.Row0.Z = ((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33);
+            result.Row0.W = ((lM11 * rM14) + (lM12 * rM24)) + (lM13 * rM34);
+            result.Row1.X = ((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31);
+            result.Row1.Y = ((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rm32);
+            result.Row1.Z = ((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33);
+            result.Row1.W = ((lM21 * rM14) + (lM22 * rM24)) + (lM23 * rM34);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x4 Mult(Matrix2x3 left, Matrix3x4 right)
+        {
+            Matrix2x4 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Add
+
+        /// <summary>
+        /// Adds two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the addition.</param>
+        /// <param name="right">The right operand of the addition.</param>
+        /// <param name="result">A new instance that is the result of the addition.</param>
+        public static void Add(ref Matrix2x3 left, ref Matrix2x3 right, out Matrix2x3 result)
+        {
+            result.Row0.X = left.Row0.X + right.Row0.X;
+            result.Row0.Y = left.Row0.Y + right.Row0.Y;
+            result.Row0.Z = left.Row0.Z + right.Row0.Z;
+            result.Row1.X = left.Row1.X + right.Row1.X;
+            result.Row1.Y = left.Row1.Y + right.Row1.Y;
+            result.Row1.Z = left.Row1.Z + right.Row1.Z;
+        }
+
+        /// <summary>
+        /// Adds two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the addition.</param>
+        /// <param name="right">The right operand of the addition.</param>
+        /// <returns>A new instance that is the result of the addition.</returns>
+        public static Matrix2x3 Add(Matrix2x3 left, Matrix2x3 right)
+        {
+            Matrix2x3 result;
+            Add(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Subtract
+
+        /// <summary>
+        /// Subtracts two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the subtraction.</param>
+        /// <param name="right">The right operand of the subtraction.</param>
+        /// <param name="result">A new instance that is the result of the subtraction.</param>
+        public static void Subtract(ref Matrix2x3 left, ref Matrix2x3 right, out Matrix2x3 result)
+        {
+            result.Row0.X = left.Row0.X - right.Row0.X;
+            result.Row0.Y = left.Row0.Y - right.Row0.Y;
+            result.Row0.Z = left.Row0.Z - right.Row0.Z;
+            result.Row1.X = left.Row1.X - right.Row1.X;
+            result.Row1.Y = left.Row1.Y - right.Row1.Y;
+            result.Row1.Z = left.Row1.Z - right.Row1.Z;
+        }
+
+        /// <summary>
+        /// Subtracts two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the subtraction.</param>
+        /// <param name="right">The right operand of the subtraction.</param>
+        /// <returns>A new instance that is the result of the subtraction.</returns>
+        public static Matrix2x3 Subtract(Matrix2x3 left, Matrix2x3 right)
+        {
+            Matrix2x3 result;
+            Subtract(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Invert Functions
+
+        #endregion
+
+        #region Transpose
+
+        /// <summary>
+        /// Calculate the transpose of the given matrix.
+        /// </summary>
+        /// <param name="mat">The matrix to transpose.</param>
+        /// <param name="result">The transpose of the given matrix.</param>
+        public static void Transpose(ref Matrix2x3 mat, out Matrix3x2 result)
+        {
+            result.Row0.X = mat.Row0.X;
+            result.Row0.Y = mat.Row1.X;
+            result.Row1.X = mat.Row0.Y;
+            result.Row1.Y = mat.Row1.Y;
+            result.Row2.X = mat.Row0.Z;
+            result.Row2.Y = mat.Row1.Z;
+        }
+
+        #endregion
 
         #endregion
 
         #region Operators
 
+        /// <summary>
+        /// Scalar multiplication.
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the multiplication</returns>
+        public static Matrix2x3 operator *(float left, Matrix2x3 right)
+        {
+            return Mult(right, left);
+        }
+
+        /// <summary>
+        /// Scalar multiplication.
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the multiplication</returns>
+        public static Matrix2x3 operator *(Matrix2x3 left, float right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2 which holds the result of the multiplication</returns>
+        public static Matrix2 operator *(Matrix2x3 left, Matrix3x2 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the multiplication</returns>
+        public static Matrix2x3 operator *(Matrix2x3 left, Matrix3 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x4 which holds the result of the multiplication</returns>
+        public static Matrix2x4 operator *(Matrix2x3 left, Matrix3x4 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix addition
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the addition</returns>
+        public static Matrix2x3 operator +(Matrix2x3 left, Matrix2x3 right)
+        {
+            return Add(left, right);
+        }
+
+        /// <summary>
+        /// Matrix subtraction
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the subtraction</returns>
+        public static Matrix2x3 operator -(Matrix2x3 left, Matrix2x3 right)
+        {
+            return Subtract(left, right);
+        }
+
         /// <summary>
         /// Compares two instances for equality.
         /// </summary>

Source/OpenTK/Math/Matrix2x4.cs

@@ -31,24 +31,47 @@ namespace OpenTK
     {
         #region Fields
 
+        /// <summary>
+        /// Top row of the matrix.
+        /// </summary>
         public Vector4 Row0;
+
+        /// <summary>
+        /// Bottom row of the matrix.
+        /// </summary>
         public Vector4 Row1;
 
         /// <summary>
         /// The zero matrix.
         /// </summary>
-		public static Matrix2x4 Zero = new Matrix2x4(Vector4.Zero, Vector4.Zero);
+        public static readonly Matrix2x4 Zero = new Matrix2x4(Vector4.Zero, Vector4.Zero);
 
         #endregion
 
         #region Constructors
 
+        /// <summary>
+        /// Constructs a new instance.
+        /// </summary>
+        /// <param name="row0">Top row of the matrix.</param>
+        /// <param name="row1">Bottom row of the matrix.</param>
         public Matrix2x4(Vector4 row0, Vector4 row1)
         {
             Row0 = row0;
             Row1 = row1;
         }
 
+        /// <summary>
+        /// Constructs a new instance
+        /// </summary>
+        /// <param name="m00">First item of the first row of the matrix.</param>
+        /// <param name="m01">Second item of the first row of the matrix.</param>
+        /// <param name="m02">Third item of the first row of the matrix.</param>
+        /// <param name="m03">Fourth item of the first row of the matrix.</param>
+        /// <param name="m10">First item of the second row of the matrix.</param>
+        /// <param name="m11">Second item of the second row of the matrix.</param>
+        /// <param name="m12">Third item of the second row of the matrix.</param>
+        /// <param name="m13">Fourth item of the second row of the matrix.</param>
         public Matrix2x4(
             float m00, float m01, float m02, float m03,
             float m10, float m11, float m12, float m13)
@@ -121,6 +144,539 @@ namespace OpenTK
 
         #endregion
 
+        #region Static
+
+        #region CreateRotation
+
+        /// <summary>
+        /// Builds a rotation matrix.
+        /// </summary>
+        /// <param name="angle">The counter-clockwise angle in radians.</param>
+        /// <param name="result">The resulting Matrix2x4 instance.</param>
+        public static void CreateRotation(float angle, out Matrix2x4 result)
+        {
+            float cos = (float)System.Math.Cos(angle);
+            float sin = (float)System.Math.Sin(angle);
+
+            result.Row0.X = cos;
+            result.Row0.Y = sin;
+            result.Row0.Z = 0;
+            result.Row0.W = 0;
+            result.Row1.X = -sin;
+            result.Row1.Y = cos;
+            result.Row1.Z = 0;
+            result.Row1.W = 0;
+        }
+
+        /// <summary>
+        /// Builds a rotation matrix.
+        /// </summary>
+        /// <param name="angle">The counter-clockwise angle in radians.</param>
+        /// <returns>The resulting Matrix2x3 instance.</returns>
+        public static Matrix2x4 CreateRotation(float angle)
+        {
+            Matrix2x4 result;
+            CreateRotation(angle, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region CreateScale
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Single scale factor for the x, y, and z axes.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(float scale, out Matrix2x4 result)
+        {
+            result.Row0.X = scale;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row0.W = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = scale;
+            result.Row1.Z = 0;
+            result.Row1.W = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Single scale factor for the x and y axes.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x4 CreateScale(float scale)
+        {
+            Matrix2x4 result;
+            CreateScale(scale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Scale factors for the x and y axes.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(Vector2 scale, out Matrix2x4 result)
+        {
+            result.Row0.X = scale.X;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row0.W = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = scale.Y;
+            result.Row1.Z = 0;
+            result.Row1.W = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="scale">Scale factors for the x and y axes.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x4 CreateScale(Vector2 scale)
+        {
+            Matrix2x4 result;
+            CreateScale(scale, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="x">Scale factor for the x axis.</param>
+        /// <param name="y">Scale factor for the y axis.</param>
+        /// <param name="result">A scale matrix.</param>
+        public static void CreateScale(float x, float y, out Matrix2x4 result)
+        {
+            result.Row0.X = x;
+            result.Row0.Y = 0;
+            result.Row0.Z = 0;
+            result.Row0.W = 0;
+            result.Row1.X = 0;
+            result.Row1.Y = y;
+            result.Row1.Z = 0;
+            result.Row1.W = 0;
+        }
+
+        /// <summary>
+        /// Creates a scale matrix.
+        /// </summary>
+        /// <param name="x">Scale factor for the x axis.</param>
+        /// <param name="y">Scale factor for the y axis.</param>
+        /// <returns>A scale matrix.</returns>
+        public static Matrix2x4 CreateScale(float x, float y)
+        {
+            Matrix2x4 result;
+            CreateScale(x, y, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Multiply Functions
+
+        /// <summary>
+        /// Multiplies and instance by a scalar.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x4 left, float right, out Matrix2x4 result)
+        {
+            result.Row0.X = left.Row0.X * right;
+            result.Row0.Y = left.Row0.Y * right;
+            result.Row0.Z = left.Row0.Z * right;
+            result.Row0.W = left.Row0.W * right;
+            result.Row1.X = left.Row1.X * right;
+            result.Row1.Y = left.Row1.Y * right;
+            result.Row1.Z = left.Row1.Z * right;
+            result.Row1.W = left.Row1.W * right;
+        }
+
+        /// <summary>
+        /// Multiplies and instance by a scalar.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x4 Mult(Matrix2x4 left, float right)
+        {
+            Matrix2x4 result;
+            Mult(ref left, right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x4 left, ref Matrix4x2 right, out Matrix2 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z, lM14 = left.Row0.W,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z, lM24 = left.Row1.W,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y,
+                rM31 = right.Row2.X, rM32 = right.Row2.Y,
+                rM41 = right.Row3.X, rM42 = right.Row3.Y;
+
+            result.Row0.X = (((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31)) + (lM14 * rM41);
+            result.Row0.Y = (((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32)) + (lM14 * rM42);
+            result.Row1.X = (((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31)) + (lM24 * rM41);
+            result.Row1.Y = (((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32)) + (lM24 * rM42);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2 Mult(Matrix2x4 left, Matrix4x2 right)
+        {
+            Matrix2 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x4 left, ref Matrix4x3 right, out Matrix2x3 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z, lM14 = left.Row0.W,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z, lM24 = left.Row1.W,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z,
+                rM31 = right.Row2.X, rM32 = right.Row2.Y, rM33 = right.Row2.Z,
+                rM41 = right.Row3.X, rM42 = right.Row3.Y, rM43 = right.Row3.Z;
+
+            result.Row0.X = (((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31)) + (lM14 * rM41);
+            result.Row0.Y = (((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32)) + (lM14 * rM42);
+            result.Row0.Z = (((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33)) + (lM14 * rM43);
+            result.Row1.X = (((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31)) + (lM24 * rM41);
+            result.Row1.Y = (((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32)) + (lM24 * rM42);
+            result.Row1.Z = (((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33)) + (lM24 * rM43);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x3 Mult(Matrix2x4 left, Matrix4x3 right)
+        {
+            Matrix2x3 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <param name="result">A new instance that is the result of the multiplication.</param>
+        public static void Mult(ref Matrix2x4 left, ref Matrix4 right, out Matrix2x4 result)
+        {
+            float lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z, lM14 = left.Row0.W,
+                lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z, lM24 = left.Row1.W,
+                rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z, rM14 = right.Row0.W,
+                rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z, rM24 = right.Row1.W,
+                rM31 = right.Row2.X, rM32 = right.Row2.Y, rM33 = right.Row2.Z, rM34 = right.Row2.W,
+                rM41 = right.Row3.X, rM42 = right.Row3.Y, rM43 = right.Row3.Z, rM44 = right.Row3.W;
+
+            result.Row0.X = (((lM11 * rM11) + (lM12 * rM21)) + (lM13 * rM31)) + (lM14 * rM41);
+            result.Row0.Y = (((lM11 * rM12) + (lM12 * rM22)) + (lM13 * rM32)) + (lM14 * rM42);
+            result.Row0.Z = (((lM11 * rM13) + (lM12 * rM23)) + (lM13 * rM33)) + (lM14 * rM43);
+            result.Row0.W = (((lM11 * rM14) + (lM12 * rM24)) + (lM13 * rM34)) + (lM14 * rM44);
+            result.Row1.X = (((lM21 * rM11) + (lM22 * rM21)) + (lM23 * rM31)) + (lM24 * rM41);
+            result.Row1.Y = (((lM21 * rM12) + (lM22 * rM22)) + (lM23 * rM32)) + (lM24 * rM42);
+            result.Row1.Z = (((lM21 * rM13) + (lM22 * rM23)) + (lM23 * rM33)) + (lM24 * rM43);
+            result.Row1.W = (((lM21 * rM14) + (lM22 * rM24)) + (lM23 * rM34)) + (lM24 * rM44);
+        }
+
+        /// <summary>
+        /// Multiplies two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the multiplication.</param>
+        /// <param name="right">The right operand of the multiplication.</param>
+        /// <returns>A new instance that is the result of the multiplication.</returns>
+        public static Matrix2x4 Mult(Matrix2x4 left, Matrix4 right)
+        {
+            Matrix2x4 result;
+            Mult(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Add
+
+        /// <summary>
+        /// Adds two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the addition.</param>
+        /// <param name="right">The right operand of the addition.</param>
+        /// <param name="result">A new instance that is the result of the addition.</param>
+        public static void Add(ref Matrix2x4 left, ref Matrix2x4 right, out Matrix2x4 result)
+        {
+            result.Row0.X = left.Row0.X + right.Row0.X;
+            result.Row0.Y = left.Row0.Y + right.Row0.Y;
+            result.Row0.Z = left.Row0.Z + right.Row0.Z;
+            result.Row0.W = left.Row0.W + right.Row0.W;
+            result.Row1.X = left.Row1.X + right.Row1.X;
+            result.Row1.Y = left.Row1.Y + right.Row1.Y;
+            result.Row1.Z = left.Row1.Z + right.Row1.Z;
+            result.Row1.W = left.Row1.W + right.Row1.W;
+        }
+
+        /// <summary>
+        /// Adds two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the addition.</param>
+        /// <param name="right">The right operand of the addition.</param>
+        /// <returns>A new instance that is the result of the addition.</returns>
+        public static Matrix2x4 Add(Matrix2x4 left, Matrix2x4 right)
+        {
+            Matrix2x4 result;
+            Add(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Subtract
+
+        /// <summary>
+        /// Subtracts two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the subtraction.</param>
+        /// <param name="right">The right operand of the subtraction.</param>
+        /// <param name="result">A new instance that is the result of the subtraction.</param>
+        public static void Subtract(ref Matrix2x4 left, ref Matrix2x4 right, out Matrix2x4 result)
+        {
+            result.Row0.X = left.Row0.X - right.Row0.X;
+            result.Row0.Y = left.Row0.Y - right.Row0.Y;
+            result.Row0.Z = left.Row0.Z - right.Row0.Z;
+            result.Row0.W = left.Row0.W - right.Row0.W;
+            result.Row1.X = left.Row1.X - right.Row1.X;
+            result.Row1.Y = left.Row1.Y - right.Row1.Y;
+            result.Row1.Z = left.Row1.Z - right.Row1.Z;
+            result.Row1.W = left.Row1.W - right.Row1.W;
+        }
+
+        /// <summary>
+        /// Subtracts two instances.
+        /// </summary>
+        /// <param name="left">The left operand of the subtraction.</param>
+        /// <param name="right">The right operand of the subtraction.</param>
+        /// <returns>A new instance that is the result of the subtraction.</returns>
+        public static Matrix2x4 Subtract(Matrix2x4 left, Matrix2x4 right)
+        {
+            Matrix2x4 result;
+            Subtract(ref left, ref right, out result);
+            return result;
+        }
+
+        #endregion
+
+        #region Invert Functions
+
+        #endregion
+
+        #region Transpose
+
+        /// <summary>
+        /// Calculate the transpose of the given matrix.
+        /// </summary>
+        /// <param name="mat">The matrix to transpose.</param>
+        /// <param name="result">The transpose of the given matrix.</param>
+        public static void Transpose(ref Matrix2x4 mat, out Matrix4x2 result)
+        {
+            result.Row0.X = mat.Row0.X;
+            result.Row0.Y = mat.Row1.X;
+            result.Row1.X = mat.Row0.Y;
+            result.Row1.Y = mat.Row1.Y;
+            result.Row2.X = mat.Row0.Z;
+            result.Row2.Y = mat.Row1.Z;
+            result.Row3.X = mat.Row0.W;
+            result.Row3.Y = mat.Row1.W;
+        }
+
+        /// <summary>
+        /// Calculate the transpose of the given matrix.
+        /// </summary>
+        /// <param name="mat">The matrix to transpose.</param>
+        /// <returns>The transpose of the given matrix.</returns>
+        public static Matrix4x2 Transpose(Matrix2x4 mat)
+        {
+            Matrix4x2 result;
+            Transpose(ref mat, out result);
+            return result;
+        }
+
+        #endregion
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Scalar multiplication.
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x4 which holds the result of the multiplication</returns>
+        public static Matrix2x4 operator *(float left, Matrix2x4 right)
+        {
+            return Mult(right, left);
+        }
+
+        /// <summary>
+        /// Scalar multiplication.
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x4 which holds the result of the multiplication</returns>
+        public static Matrix2x4 operator *(Matrix2x4 left, float right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2 which holds the result of the multiplication</returns>
+        public static Matrix2 operator *(Matrix2x4 left, Matrix4x2 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x3 which holds the result of the multiplication</returns>
+        public static Matrix2x3 operator *(Matrix2x4 left, Matrix4x3 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix multiplication
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x4 which holds the result of the multiplication</returns>
+        public static Matrix2x4 operator *(Matrix2x4 left, Matrix4 right)
+        {
+            return Mult(left, right);
+        }
+
+        /// <summary>
+        /// Matrix addition
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2 which holds the result of the addition</returns>
+        public static Matrix2x4 operator +(Matrix2x4 left, Matrix2x4 right)
+        {
+            return Add(left, right);
+        }
+
+        /// <summary>
+        /// Matrix subtraction
+        /// </summary>
+        /// <param name="left">left-hand operand</param>
+        /// <param name="right">right-hand operand</param>
+        /// <returns>A new Matrix2x4 which holds the result of the subtraction</returns>
+        public static Matrix2x4 operator -(Matrix2x4 left, Matrix2x4 right)
+        {
+            return Subtract(left, right);
+        }
+
+        /// <summary>
+        /// Compares two instances for equality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>True, if left equals right; false otherwise.</returns>
+        public static bool operator ==(Matrix2x4 left, Matrix2x4 right)
+        {
+            return left.Equals(right);
+        }
+
+        /// <summary>
+        /// Compares two instances for inequality.
+        /// </summary>
+        /// <param name="left">The first instance.</param>
+        /// <param name="right">The second instance.</param>
+        /// <returns>True, if left does not equal right; false otherwise.</returns>
+        public static bool operator !=(Matrix2x4 left, Matrix2x4 right)
+        {
+            return !left.Equals(right);
+        }
+
+        #endregion
+
+        #region Overrides
+
+        #region public override string ToString()
+
+        /// <summary>
+        /// Returns a System.String that represents the current Matrix4.
+        /// </summary>
+        /// <returns>The string representation of the matrix.</returns>
+        public override string ToString()
+        {
+            return String.Format("{0}\n{1}", Row0, Row1);
+        }
+
+        #endregion
+
+        #region public override int GetHashCode()
+
+        /// <summary>
+        /// Returns the hashcode for this instance.
+        /// </summary>
+        /// <returns>A System.Int32 containing the unique hashcode for this instance.</returns>
+        public override int GetHashCode()
+        {
+            return Row0.GetHashCode() ^ Row1.GetHashCode();
+        }
+
+        #endregion
+
+        #region public override bool Equals(object obj)
+
+        /// <summary>
+        /// Indicates whether this instance and a specified object are equal.
+        /// </summary>
+        /// <param name="obj">The object to compare to.</param>
+        /// <returns>True if the instances are equal; false otherwise.</returns>
+        public override bool Equals(object obj)
+        {
+            if (!(obj is Matrix2x4))
+                return false;
+
+            return this.Equals((Matrix2x4)obj);
+        }
+
+        #endregion
+
+        #endregion
+
         #endregion
 
         #region IEquatable<Matrix2x4> Members

Source/OpenTK/Math/Matrix3x2.cs

@@ -55,6 +55,12 @@ namespace OpenTK
 
 		#region Constructors
 
+		/// <summary>
+		/// Constructs a new instance.
+		/// </summary>
+		/// <param name="row0">Top row of the matrix.</param>
+		/// <param name="row1">Second row of the matrix.</param>
+		/// <param name="row2">Bottom row of the matrix.</param>
 		public Matrix3x2(Vector2 row0, Vector2 row1, Vector2 row2)
 		{
 			Row0 = row0;
@@ -62,6 +68,15 @@ namespace OpenTK
 			Row2 = row2;
 		}
 
+		/// <summary>
+		/// Constructs a new instance
+		/// </summary>
+		/// <param name="m00">First item of the first row of the matrix.</param>
+		/// <param name="m01">Second item of the first row of the matrix.</param>
+		/// <param name="m10">First item of the second row of the matrix.</param>
+		/// <param name="m11">Second item of the second row of the matrix.</param>
+		/// <param name="m20">First item of the third row of the matrix.</param>
+		/// <param name="m21">Second item of the third row of the matrix.</param>
 		public Matrix3x2(
 			float m00, float m01,
 			float m10, float m11,