Copied float matrix classes to their double equivalents.

Source/OpenTK/Math/Matrix2.cs

@@ -181,6 +181,18 @@ namespace OpenTK
 
         #endregion
 
+        #region public void Invert()
+
+        /// <summary>
+        /// Converts this instance into its inverse.
+        /// </summary>
+        public void Invert()
+        {
+            this = Matrix2.Invert(this);
+        }
+
+        #endregion
+
         #endregion
 
         #region Static
@@ -495,7 +507,39 @@ namespace OpenTK
 
         #region Invert Functions
 
-        //TODO implement
+        /// <summary>
+        /// Calculate the inverse of the given matrix
+        /// </summary>
+        /// <param name="mat">The matrix to invert</param>
+        /// <param name="result">The inverse of the given matrix if it has one, or the input if it is singular</param>
+        /// <exception cref="InvalidOperationException">Thrown if the Matrix2 is singular.</exception>
+        public static void Invert(ref Matrix2 mat, out Matrix2 result)
+        {
+            float det = mat.Determinant;
+
+            if (det == 0)
+                throw new InvalidOperationException("Matrix is singular and cannot be inverted.");
+
+            float invDet = 1f / det;
+
+            result.Row0.X = mat.Row1.Y * invDet;
+            result.Row0.Y = -mat.Row0.Y * invDet;
+            result.Row1.X = -mat.Row1.X * invDet;
+            result.Row1.Y = mat.Row0.X * invDet;
+        }
+
+        /// <summary>
+        /// Calculate the inverse of the given matrix
+        /// </summary>
+        /// <param name="mat">The matrix to invert</param>
+        /// <returns>The inverse of the given matrix if it has one, or the input if it is singular</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the Matrix2 is singular.</exception>
+        public static Matrix2 Invert(Matrix2 mat)
+        {
+            Matrix2 result;
+            Invert(ref mat, out result);
+            return result;
+        }
         
         #endregion
 

Source/OpenTK/Math/Matrix2d.cs

@@ -27,8 +27,717 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix2.cs when it's mostly feature-complete.
-	/*public struct Matrix2d : IEquatable<Matrix2d>
+	/// <summary>
+	/// Represents a 2x2 matrix
+	/// </summary>
+	public struct Matrix2d : IEquatable<Matrix2d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix.
+		/// </summary>
+		public Vector2d Row0;
+
+		/// <summary>
+		/// Bottom row of the matrix.
+		/// </summary>
+		public Vector2d Row1;
+
+		/// <summary>
+		/// The identity matrix.
+		/// </summary>
+		public static readonly Matrix2d Identity = new Matrix2d(Vector2d.UnitX, Vector2d.UnitY);
+
+		/// <summary>
+		/// The zero matrix.
+		/// </summary>
+		public static readonly Matrix2d Zero = new Matrix2d(Vector2d.Zero, Vector2d.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 Matrix2d(Vector2d row0, Vector2d 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="m10">First item of the second row of the matrix.</param>
+		/// <param name="m11">Second item of the second row of the matrix.</param>
+		public Matrix2d(
+			double m00, double m01,
+			double m10, double m11)
+		{
+			Row0 = new Vector2d(m00, m01);
+			Row1 = new Vector2d(m10, m11);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets the determinant of this matrix.
+		/// </summary>
+		public double Determinant
+		{
+			get
+			{
+				double m11 = Row0.X, m12 = Row0.Y,
+					  m21 = Row1.X, m22 = Row1.Y;
+
+				return m11 * m22 - m12 * m21;
+			}
+		}
+
+		/// <summary>
+		/// Gets or sets the first column of this matrix.
+		/// </summary>
+		public Vector2d Column0
+		{
+			get { return new Vector2d(Row0.X, Row1.X); }
+			set { Row0.X = value.X; Row1.X = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the second column of this matrix.
+		/// </summary>
+		public Vector2d Column1
+		{
+			get { return new Vector2d(Row0.Y, Row1.Y); }
+			set { Row0.Y = value.X; Row1.Y = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#endregion
+
+		#region Instance
+
+		#region public void Transpose()
+
+		/// <summary>
+		/// Converts this instance to it's transpose.
+		/// </summary>
+		public void Transpose()
+		{
+			this = Matrix2d.Transpose(this);
+		}
+
+		#endregion
+
+		#region public void Invert()
+
+		/// <summary>
+		/// Converts this instance into its inverse.
+		/// </summary>
+		public void Invert()
+		{
+			this = Matrix2d.Invert(this);
+		}
+
+		#endregion
+
+		#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 Matrix2d instance.</param>
+		public static void CreateRotation(double angle, out Matrix2d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = cos;
+			result.Row0.Y = sin;
+			result.Row1.X = -sin;
+			result.Row1.Y = cos;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix2d instance.</returns>
+		public static Matrix2d CreateRotation(double angle)
+		{
+			Matrix2d 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(double scale, out Matrix2d result)
+		{
+			result.Row0.X = scale;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale;
+		}
+
+		/// <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 Matrix2d CreateScale(double scale)
+		{
+			Matrix2d 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(Vector2d scale, out Matrix2d result)
+		{
+			result.Row0.X = scale.X;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale.Y;
+		}
+
+		/// <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 Matrix2d CreateScale(Vector2d scale)
+		{
+			Matrix2d 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(double x, double y, out Matrix2d result)
+		{
+			result.Row0.X = x;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = y;
+		}
+
+		/// <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 Matrix2d CreateScale(double x, double y)
+		{
+			Matrix2d 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 Matrix2d left, double right, out Matrix2d result)
+		{
+			result.Row0.X = left.Row0.X * right;
+			result.Row0.Y = left.Row0.Y * right;
+			result.Row1.X = left.Row1.X * right;
+			result.Row1.Y = left.Row1.Y * 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 Matrix2d Mult(Matrix2d left, double right)
+		{
+			Matrix2d 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 Matrix2d left, ref Matrix2d right, out Matrix2d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+		}
+
+		/// <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 Matrix2d Mult(Matrix2d left, Matrix2d right)
+		{
+			Matrix2d 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 Matrix2d left, ref Matrix2x3d right, out Matrix2x3d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+		}
+
+		/// <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 Matrix2x3d Mult(Matrix2d left, Matrix2x3d right)
+		{
+			Matrix2x3d 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 Matrix2d left, ref Matrix2x4d right, out Matrix2x4d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				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;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row0.W = (lM11 * rM14) + (lM12 * rM24);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+			result.Row1.W = (lM21 * rM14) + (lM22 * rM24);
+		}
+
+		/// <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 Matrix2x4d Mult(Matrix2d left, Matrix2x4d right)
+		{
+			Matrix2x4d 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 Matrix2d left, ref Matrix2d right, out Matrix2d result)
+		{
+			result.Row0.X = left.Row0.X + right.Row0.X;
+			result.Row0.Y = left.Row0.Y + right.Row0.Y;
+			result.Row1.X = left.Row1.X + right.Row1.X;
+			result.Row1.Y = left.Row1.Y + right.Row1.Y;
+		}
+
+		/// <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 Matrix2d Add(Matrix2d left, Matrix2d right)
+		{
+			Matrix2d 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 Matrix2d left, ref Matrix2d right, out Matrix2d result)
+		{
+			result.Row0.X = left.Row0.X - right.Row0.X;
+			result.Row0.Y = left.Row0.Y - right.Row0.Y;
+			result.Row1.X = left.Row1.X - right.Row1.X;
+			result.Row1.Y = left.Row1.Y - right.Row1.Y;
+		}
+
+		/// <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 Matrix2d Subtract(Matrix2d left, Matrix2d right)
+		{
+			Matrix2d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region Invert Functions
+
+		/// <summary>
+		/// Calculate the inverse of the given matrix
+		/// </summary>
+		/// <param name="mat">The matrix to invert</param>
+		/// <param name="result">The inverse of the given matrix if it has one, or the input if it is singular</param>
+		/// <exception cref="InvalidOperationException">Thrown if the Matrix2d is singular.</exception>
+		public static void Invert(ref Matrix2d mat, out Matrix2d result)
+		{
+			double det = mat.Determinant;
+
+			if (det == 0)
+				throw new InvalidOperationException("Matrix is singular and cannot be inverted.");
+
+			double invDet = 1f / det;
+
+			result.Row0.X = mat.Row1.Y * invDet;
+			result.Row0.Y = -mat.Row0.Y * invDet;
+			result.Row1.X = -mat.Row1.X * invDet;
+			result.Row1.Y = mat.Row0.X * invDet;
+		}
+
+		/// <summary>
+		/// Calculate the inverse of the given matrix
+		/// </summary>
+		/// <param name="mat">The matrix to invert</param>
+		/// <returns>The inverse of the given matrix if it has one, or the input if it is singular</returns>
+		/// <exception cref="InvalidOperationException">Thrown if the Matrix2d is singular.</exception>
+		public static Matrix2d Invert(Matrix2d mat)
+		{
+			Matrix2d result;
+			Invert(ref mat, out result);
+			return result;
+		}
+
+		#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 Matrix2d mat, out Matrix2d 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;
+		}
+
+		/// <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 Matrix2d Transpose(Matrix2d mat)
+		{
+			Matrix2d 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix2d operator *(double left, Matrix2d 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix2d operator *(Matrix2d left, double 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix2d operator *(Matrix2d left, Matrix2d 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 Matrix2x3d which holds the result of the multiplication</returns>
+		public static Matrix2x3d operator *(Matrix2d left, Matrix2x3d 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 Matrix2x4d which holds the result of the multiplication</returns>
+		public static Matrix2x4d operator *(Matrix2d left, Matrix2x4d 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 Matrix2d which holds the result of the addition</returns>
+		public static Matrix2d operator +(Matrix2d left, Matrix2d 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 Matrix2d which holds the result of the subtraction</returns>
+		public static Matrix2d operator -(Matrix2d left, Matrix2d 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 ==(Matrix2d left, Matrix2d 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 !=(Matrix2d left, Matrix2d 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 Matrix2d))
+				return false;
+
+			return this.Equals((Matrix2d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix2d> Members
+
+		/// <summary>Indicates whether the current matrix is equal to another matrix.</summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix2d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix2x3d.cs

@@ -23,12 +23,681 @@ SOFTWARE.
 #endregion
 
 using System;
-using System.Runtime.InteropServices;
+using System.Collections.Generic;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix2x3.cs when it's mostly feature-complete.
-	/*public struct Matrix2x3d : IEquatable<Matrix2x3d>
+	/// <summary>
+	/// Represents a 2x3 matrix.
+	/// </summary>
+	public struct Matrix2x3d : IEquatable<Matrix2x3d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix.
+		/// </summary>
+		public Vector3d Row0;
+
+		/// <summary>
+		/// Bottom row of the matrix.
+		/// </summary>
+		public Vector3d Row1;
+
+		/// <summary>
+		/// The zero matrix.
+		/// </summary>
+		public static readonly Matrix2x3d Zero = new Matrix2x3d(Vector3d.Zero, Vector3d.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 Matrix2x3d(Vector3d row0, Vector3d 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="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>
+		public Matrix2x3d(
+			double m00, double m01, double m02,
+			double m10, double m11, double m12)
+		{
+			Row0 = new Vector3d(m00, m01, m02);
+			Row1 = new Vector3d(m10, m11, m12);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the first column of this matrix.
+		/// </summary>
+		public Vector2d Column0
+		{
+			get { return new Vector2d(Row0.X, Row1.X); }
+			set { Row0.X = value.X; Row1.X = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the second column of this matrix.
+		/// </summary>
+		public Vector2d Column1
+		{
+			get { return new Vector2d(Row0.Y, Row1.Y); }
+			set { Row0.Y = value.X; Row1.Y = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the third column of this matrix.
+		/// </summary>
+		public Vector2d Column2
+		{
+			get { return new Vector2d(Row0.Z, Row1.Z); }
+			set { Row0.Z = value.X; Row1.Z = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 3 of this instance.
+		/// </summary>
+		public double M13 { get { return Row0.Z; } set { Row0.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 3 of this instance.
+		/// </summary>
+		public double M23 { get { return Row1.Z; } set { Row1.Z = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#endregion
+
+		#region Instance
+		#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 Matrix2x3d instance.</param>
+		public static void CreateRotation(double angle, out Matrix2x3d result)
+		{
+			double cos = System.Math.Cos(angle);
+			double sin = 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 Matrix2x3d instance.</returns>
+		public static Matrix2x3d CreateRotation(double angle)
+		{
+			Matrix2x3d 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(double scale, out Matrix2x3d 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 Matrix2x3d CreateScale(double scale)
+		{
+			Matrix2x3d 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(Vector2d scale, out Matrix2x3d 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 Matrix2x3d CreateScale(Vector2d scale)
+		{
+			Matrix2x3d 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(double x, double y, out Matrix2x3d 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 Matrix2x3d CreateScale(double x, double y)
+		{
+			Matrix2x3d 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 Matrix2x3d left, double right, out Matrix2x3d 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 Matrix2x3d Mult(Matrix2x3d left, double right)
+		{
+			Matrix2x3d 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 Matrix2x3d left, ref Matrix3x2 right, out Matrix2d result)
+		{
+			double 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 Matrix2d Mult(Matrix2x3d left, Matrix3x2 right)
+		{
+			Matrix2d 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 Matrix2x3d left, ref Matrix3 right, out Matrix2x3d result)
+		{
+			double 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 Matrix2x3d Mult(Matrix2x3d left, Matrix3 right)
+		{
+			Matrix2x3d 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 Matrix2x3d left, ref Matrix3x4 right, out Matrix2x4d result)
+		{
+			double 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 Matrix2x4d Mult(Matrix2x3d left, Matrix3x4 right)
+		{
+			Matrix2x4d 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 Matrix2x3d left, ref Matrix2x3d right, out Matrix2x3d 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 Matrix2x3d Add(Matrix2x3d left, Matrix2x3d right)
+		{
+			Matrix2x3d 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 Matrix2x3d left, ref Matrix2x3d right, out Matrix2x3d 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 Matrix2x3d Subtract(Matrix2x3d left, Matrix2x3d right)
+		{
+			Matrix2x3d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		#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 Matrix2x3d mat, out Matrix3x2d 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;
+		}
+
+		/// <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 Matrix3x2d Transpose(Matrix2x3d mat)
+		{
+			Matrix3x2d 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 Matrix2x3d which holds the result of the multiplication</returns>
+		public static Matrix2x3d operator *(double left, Matrix2x3d 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 Matrix2x3d which holds the result of the multiplication</returns>
+		public static Matrix2x3d operator *(Matrix2x3d left, double 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix2d operator *(Matrix2x3d 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 Matrix2x3d which holds the result of the multiplication</returns>
+		public static Matrix2x3d operator *(Matrix2x3d 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 Matrix2x4d which holds the result of the multiplication</returns>
+		public static Matrix2x4d operator *(Matrix2x3d 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 Matrix2x3d which holds the result of the addition</returns>
+		public static Matrix2x3d operator +(Matrix2x3d left, Matrix2x3d 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 Matrix2x3d which holds the result of the subtraction</returns>
+		public static Matrix2x3d operator -(Matrix2x3d left, Matrix2x3d 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 ==(Matrix2x3d left, Matrix2x3d 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 !=(Matrix2x3d left, Matrix2x3d right)
+		{
+			return !left.Equals(right);
+		}
+
+		#endregion
+
+		#region Overrides
+
+		#region public override string ToString()
+
+		/// <summary>
+		/// Returns a System.String that represents the current Matrix2x3d.
+		/// </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 tresult.</param>
+		/// <returns>True if the instances are equal; false otherwise.</returns>
+		public override bool Equals(object obj)
+		{
+			if (!(obj is Matrix2x3d))
+				return false;
+
+			return this.Equals((Matrix2x3d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix2x3d> Members
+
+		/// <summary>
+		/// Indicates whether the current matrix is equal to another matrix.
+		/// </summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix2x3d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix2x4d.cs

@@ -27,8 +27,714 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix2x4.cs when it's mostly feature-complete.
-	/*public struct Matrix2x4d : IEquatable<Matrix2x4d>
+	/// <summary>
+	/// Represents a 2x4 matrix.
+	/// </summary>
+	public struct Matrix2x4d : IEquatable<Matrix2x4d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix.
+		/// </summary>
+		public Vector4d Row0;
+
+		/// <summary>
+		/// Bottom row of the matrix.
+		/// </summary>
+		public Vector4d Row1;
+
+		/// <summary>
+		/// The zero matrix.
+		/// </summary>
+		public static readonly Matrix2x4d Zero = new Matrix2x4d(Vector4d.Zero, Vector4d.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 Matrix2x4d(Vector4d row0, Vector4d 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 Matrix2x4d(
+			double m00, double m01, double m02, double m03,
+			double m10, double m11, double m12, double m13)
+		{
+			Row0 = new Vector4d(m00, m01, m02, m03);
+			Row1 = new Vector4d(m10, m11, m12, m13);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the first column of the matrix.
+		/// </summary>
+		public Vector2d Column0
+		{
+			get { return new Vector2d(Row0.X, Row1.X); }
+			set { Row0.X = value.X; Row1.X = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the second column of the matrix.
+		/// </summary>
+		public Vector2d Column1
+		{
+			get { return new Vector2d(Row0.Y, Row1.Y); }
+			set { Row0.Y = value.X; Row1.Y = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the third column of the matrix.
+		/// </summary>
+		public Vector2d Column2
+		{
+			get { return new Vector2d(Row0.Z, Row1.Z); }
+			set { Row0.Z = value.X; Row1.Z = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the fourth column of the matrix.
+		/// </summary>
+		public Vector2d Column3
+		{
+			get { return new Vector2d(Row0.W, Row1.W); }
+			set { Row0.W = value.X; Row1.W = value.Y; }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 3 of this instance.
+		/// </summary>
+		public double M13 { get { return Row0.Z; } set { Row0.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 4 of this instance.
+		/// </summary>
+		public double M14 { get { return Row0.W; } set { Row0.W = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 3 of this instance.
+		/// </summary>
+		public double M23 { get { return Row1.Z; } set { Row1.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 4 of this instance.
+		/// </summary>
+		public double M24 { get { return Row1.W; } set { Row1.W = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#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 Matrix2x4d instance.</param>
+		public static void CreateRotation(double angle, out Matrix2x4d result)
+		{
+			double cos = System.Math.Cos(angle);
+			double sin = 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 Matrix2x3d instance.</returns>
+		public static Matrix2x4d CreateRotation(double angle)
+		{
+			Matrix2x4d 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(double scale, out Matrix2x4d 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 Matrix2x4d CreateScale(double scale)
+		{
+			Matrix2x4d 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(Vector2d scale, out Matrix2x4d 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 Matrix2x4d CreateScale(Vector2d scale)
+		{
+			Matrix2x4d 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(double x, double y, out Matrix2x4d 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 Matrix2x4d CreateScale(double x, double y)
+		{
+			Matrix2x4d 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 Matrix2x4d left, double right, out Matrix2x4d 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 Matrix2x4d Mult(Matrix2x4d left, double right)
+		{
+			Matrix2x4d 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 Matrix2x4d left, ref Matrix4x2 right, out Matrix2d result)
+		{
+			double 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 Matrix2d Mult(Matrix2x4d left, Matrix4x2 right)
+		{
+			Matrix2d 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 Matrix2x4d left, ref Matrix4x3 right, out Matrix2x3d result)
+		{
+			double 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 Matrix2x3d Mult(Matrix2x4d left, Matrix4x3 right)
+		{
+			Matrix2x3d 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 Matrix2x4d left, ref Matrix4 right, out Matrix2x4d result)
+		{
+			double 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 Matrix2x4d Mult(Matrix2x4d left, Matrix4 right)
+		{
+			Matrix2x4d 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 Matrix2x4d left, ref Matrix2x4d right, out Matrix2x4d 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 Matrix2x4d Add(Matrix2x4d left, Matrix2x4d right)
+		{
+			Matrix2x4d 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 Matrix2x4d left, ref Matrix2x4d right, out Matrix2x4d 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 Matrix2x4d Subtract(Matrix2x4d left, Matrix2x4d right)
+		{
+			Matrix2x4d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		#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 Matrix2x4d mat, out Matrix4x2d 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 Matrix4x2d Transpose(Matrix2x4d mat)
+		{
+			Matrix4x2d 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 Matrix2x4d which holds the result of the multiplication</returns>
+		public static Matrix2x4d operator *(double left, Matrix2x4d 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 Matrix2x4d which holds the result of the multiplication</returns>
+		public static Matrix2x4d operator *(Matrix2x4d left, double 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix2d operator *(Matrix2x4d 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 Matrix2x3d which holds the result of the multiplication</returns>
+		public static Matrix2x3d operator *(Matrix2x4d 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 Matrix2x4d which holds the result of the multiplication</returns>
+		public static Matrix2x4d operator *(Matrix2x4d 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 Matrix2d which holds the result of the addition</returns>
+		public static Matrix2x4d operator +(Matrix2x4d left, Matrix2x4d 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 Matrix2x4d which holds the result of the subtraction</returns>
+		public static Matrix2x4d operator -(Matrix2x4d left, Matrix2x4d 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 ==(Matrix2x4d left, Matrix2x4d 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 !=(Matrix2x4d left, Matrix2x4d 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 Matrix2x4d))
+				return false;
+
+			return this.Equals((Matrix2x4d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix2x4d> Members
+
+		/// <summary>
+		/// Indicates whether the current matrix is equal to another matrix.
+		/// </summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix2x4d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix3x2d.cs

@@ -27,8 +27,689 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix3x2.cs when it's mostly feature-complete.
-	/*public struct Matrix3x2d : IEquatable<Matrix3x2d>
+	/// <summary>
+	/// Represents a 3x2 matrix.
+	/// </summary>
+	public struct Matrix3x2d : IEquatable<Matrix3x2d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix.
+		/// </summary>
+		public Vector2d Row0;
+
+		/// <summary>
+		/// Second row of the matrix.
+		/// </summary>
+		public Vector2d Row1;
+
+		/// <summary>
+		/// Bottom row of the matrix.
+		/// </summary>
+		public Vector2d Row2;
+
+		/// <summary>
+		/// The zero matrix.
+		/// </summary>
+		public static readonly Matrix3x2d Zero = new Matrix3x2d(Vector2d.Zero, Vector2d.Zero, Vector2d.Zero);
+
+		#endregion
+
+		#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 Matrix3x2d(Vector2d row0, Vector2d row1, Vector2d row2)
+		{
+			Row0 = row0;
+			Row1 = row1;
+			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 Matrix3x2d(
+			double m00, double m01,
+			double m10, double m11,
+			double m20, double m21)
+		{
+			Row0 = new Vector2d(m00, m01);
+			Row1 = new Vector2d(m10, m11);
+			Row2 = new Vector2d(m20, m21);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the first column of this matrix.
+		/// </summary>
+		public Vector3d Column0
+		{
+			get { return new Vector3d(Row0.X, Row1.X, Row2.X); }
+			set { Row0.X = value.X; Row1.X = value.Y; Row2.X = value.Z; }
+		}
+
+		/// <summary>
+		/// Gets or sets the second column of this matrix.
+		/// </summary>
+		public Vector3d Column1
+		{
+			get { return new Vector3d(Row0.Y, Row1.Y, Row2.Y); }
+			set { Row0.Y = value.X; Row1.Y = value.Y; Row2.Y = value.Z; }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 1 of this instance.
+		/// </summary>
+		public double M31 { get { return Row2.X; } set { Row2.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 2 of this instance.
+		/// </summary>
+		public double M32 { get { return Row2.Y; } set { Row2.Y = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				else if (rowIndex == 2) return Row2[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				else if (rowIndex == 2) Row2[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#endregion
+
+		#region Instance
+		#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 Matrix3x2d instance.</param>
+		public static void CreateRotation(double angle, out Matrix3x2d result)
+		{
+			double cos = System.Math.Cos(angle);
+			double sin = System.Math.Sin(angle);
+
+			result.Row0.X = cos;
+			result.Row0.Y = sin;
+			result.Row1.X = -sin;
+			result.Row1.Y = cos;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix3x2d instance.</returns>
+		public static Matrix3x2d CreateRotation(double angle)
+		{
+			Matrix3x2d 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(double scale, out Matrix3x2d result)
+		{
+			result.Row0.X = scale;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale;
+			result.Row2.X = 0;
+			result.Row2.Y = 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 Matrix3x2d CreateScale(double scale)
+		{
+			Matrix3x2d 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(Vector2d scale, out Matrix3x2d result)
+		{
+			result.Row0.X = scale.X;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale.Y;
+			result.Row2.X = 0;
+			result.Row2.Y = 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 Matrix3x2d CreateScale(Vector2d scale)
+		{
+			Matrix3x2d 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(double x, double y, out Matrix3x2d result)
+		{
+			result.Row0.X = x;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = y;
+			result.Row2.X = 0;
+			result.Row2.Y = 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 Matrix3x2d CreateScale(double x, double y)
+		{
+			Matrix3x2d 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 Matrix3x2d left, double right, out Matrix3x2d result)
+		{
+			result.Row0.X = left.Row0.X * right;
+			result.Row0.Y = left.Row0.Y * right;
+			result.Row1.X = left.Row1.X * right;
+			result.Row1.Y = left.Row1.Y * right;
+			result.Row2.X = left.Row2.X * right;
+			result.Row2.Y = left.Row2.Y * 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 Matrix3x2d Mult(Matrix3x2d left, double right)
+		{
+			Matrix3x2d 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 Matrix3x2d left, ref Matrix2d right, out Matrix3x2d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+		}
+
+		/// <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 Matrix3x2d Mult(Matrix3x2d left, Matrix2d right)
+		{
+			Matrix3x2d 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 Matrix3x2d left, ref Matrix2x3d right, out Matrix3d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23);
+		}
+
+		/// <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 Matrix3d Mult(Matrix3x2d left, Matrix2x3d right)
+		{
+			Matrix3d 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 Matrix3x2d left, ref Matrix2x4d right, out Matrix3x4d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				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;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row0.W = (lM11 * rM14) + (lM12 * rM24);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+			result.Row1.W = (lM21 * rM14) + (lM22 * rM24);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23);
+			result.Row2.W = (lM31 * rM14) + (lM32 * rM24);
+		}
+
+		/// <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 Matrix3x4d Mult(Matrix3x2d left, Matrix2x4d right)
+		{
+			Matrix3x4d 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 Matrix3x2d left, ref Matrix3x2d right, out Matrix3x2d result)
+		{
+			result.Row0.X = left.Row0.X + right.Row0.X;
+			result.Row0.Y = left.Row0.Y + right.Row0.Y;
+			result.Row1.X = left.Row1.X + right.Row1.X;
+			result.Row1.Y = left.Row1.Y + right.Row1.Y;
+			result.Row2.X = left.Row2.X + right.Row2.X;
+			result.Row2.Y = left.Row2.Y + right.Row2.Y;
+		}
+
+		/// <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 Matrix3x2d Add(Matrix3x2d left, Matrix3x2d right)
+		{
+			Matrix3x2d 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 Matrix3x2d left, ref Matrix3x2d right, out Matrix3x2d result)
+		{
+			result.Row0.X = left.Row0.X - right.Row0.X;
+			result.Row0.Y = left.Row0.Y - right.Row0.Y;
+			result.Row1.X = left.Row1.X - right.Row1.X;
+			result.Row1.Y = left.Row1.Y - right.Row1.Y;
+			result.Row2.X = left.Row2.X - right.Row2.X;
+			result.Row2.Y = left.Row2.Y - right.Row2.Y;
+		}
+
+		/// <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 Matrix3x2d Subtract(Matrix3x2d left, Matrix3x2d right)
+		{
+			Matrix3x2d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		#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 Matrix3x2d mat, out Matrix2x3d result)
+		{
+			result.Row0.X = mat.Row0.X;
+			result.Row0.Y = mat.Row1.X;
+			result.Row0.Z = mat.Row2.X;
+			result.Row1.X = mat.Row0.Y;
+			result.Row1.Y = mat.Row1.Y;
+			result.Row1.Z = mat.Row2.Y;
+		}
+
+		/// <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 Matrix2x3d Transpose(Matrix3x2d mat)
+		{
+			Matrix2x3d 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 Matrix3x2d which holds the result of the multiplication</returns>
+		public static Matrix3x2d operator *(double left, Matrix3x2d 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 Matrix3x2d which holds the result of the multiplication</returns>
+		public static Matrix3x2d operator *(Matrix3x2d left, double 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 Matrix3x2d which holds the result of the multiplication</returns>
+		public static Matrix3x2d operator *(Matrix3x2d left, Matrix2d 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 Matrix3d which holds the result of the multiplication</returns>
+		public static Matrix3d operator *(Matrix3x2d left, Matrix2x3d 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 Matrix3x4 which holds the result of the multiplication</returns>
+		public static Matrix3x4d operator *(Matrix3x2d left, Matrix2x4d 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 Matrix3x2d which holds the result of the addition</returns>
+		public static Matrix3x2d operator +(Matrix3x2d left, Matrix3x2d 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 Matrix3x2d which holds the result of the subtraction</returns>
+		public static Matrix3x2d operator -(Matrix3x2d left, Matrix3x2d 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 ==(Matrix3x2d left, Matrix3x2d 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 !=(Matrix3x2d left, Matrix3x2d right)
+		{
+			return !left.Equals(right);
+		}
+
+		#endregion
+
+		#region Overrides
+
+		#region public override string ToString()
+
+		/// <summary>
+		/// Returns a System.String that represents the current Matrix3d.
+		/// </summary>
+		/// <returns>The string representation of the matrix.</returns>
+		public override string ToString()
+		{
+			return String.Format("{0}\n{1}\n{2}", Row0, Row1, Row2);
+		}
+
+		#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() ^ Row2.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 Matrix3x2d))
+				return false;
+
+			return this.Equals((Matrix3x2d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix3x2d> Members
+
+		/// <summary>
+		/// Indicates whether the current matrix is equal to another matrix.
+		/// </summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix3x2d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1 &&
+				Row2 == other.Row2;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix3x4d.cs

@@ -27,8 +27,824 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix3x4.cs when it's mostly feature-complete.
-	/*public struct Matrix3x4d : IEquatable<Matrix3x4d>
+	/// <summary>
+	/// Represents a 3x4 Matrix
+	/// </summary>
+	[Serializable]
+	[StructLayout(LayoutKind.Sequential)]
+	public struct Matrix3x4d : IEquatable<Matrix3x4d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix
+		/// </summary>
+		public Vector4d Row0;
+
+		/// <summary>
+		/// 2nd row of the matrix
+		/// </summary>
+		public Vector4d Row1;
+
+		/// <summary>
+		/// Bottom row of the matrix
+		/// </summary>
+		public Vector4d Row2;
+
+		/// <summary>
+		/// The zero matrix
+		/// </summary>
+		public static Matrix3x4d Zero = new Matrix3x4d(Vector4d.Zero, Vector4d.Zero, Vector4d.Zero);
+
+		#endregion
+
+		#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 Matrix3x4d(Vector4d row0, Vector4d row1, Vector4d row2)
+		{
+			Row0 = row0;
+			Row1 = row1;
+			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="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>
+		/// <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>
+		/// <param name="m22">Third item of the third row of the matrix.</param>
+		/// <param name="m23">First item of the third row of the matrix.</param>
+		public Matrix3x4d(
+			double m00, double m01, double m02, double m03,
+			double m10, double m11, double m12, double m13,
+			double m20, double m21, double m22, double m23)
+		{
+			Row0 = new Vector4d(m00, m01, m02, m03);
+			Row1 = new Vector4d(m10, m11, m12, m13);
+			Row2 = new Vector4d(m20, m21, m22, m23);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets the first column of this matrix.
+		/// </summary>
+		public Vector3d Column0
+		{
+			get { return new Vector3d(Row0.X, Row1.X, Row2.X); }
+		}
+
+		/// <summary>
+		/// Gets the second column of this matrix.
+		/// </summary>
+		public Vector3d Column1
+		{
+			get { return new Vector3d(Row0.Y, Row1.Y, Row2.Y); }
+		}
+
+		/// <summary>
+		/// Gets the third column of this matrix.
+		/// </summary>
+		public Vector3d Column2
+		{
+			get { return new Vector3d(Row0.Z, Row1.Z, Row2.Z); }
+		}
+
+		/// <summary>
+		/// Gets the fourth column of this matrix.
+		/// </summary>
+		public Vector3d Column3
+		{
+			get { return new Vector3d(Row0.W, Row1.W, Row2.W); }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 3 of this instance.
+		/// </summary>
+		public double M13 { get { return Row0.Z; } set { Row0.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 4 of this instance.
+		/// </summary>
+		public double M14 { get { return Row0.W; } set { Row0.W = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 3 of this instance.
+		/// </summary>
+		public double M23 { get { return Row1.Z; } set { Row1.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 4 of this instance.
+		/// </summary>
+		public double M24 { get { return Row1.W; } set { Row1.W = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 1 of this instance.
+		/// </summary>
+		public double M31 { get { return Row2.X; } set { Row2.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 2 of this instance.
+		/// </summary>
+		public double M32 { get { return Row2.Y; } set { Row2.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 3 of this instance.
+		/// </summary>
+		public double M33 { get { return Row2.Z; } set { Row2.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 4 of this instance.
+		/// </summary>
+		public double M34 { get { return Row2.W; } set { Row2.W = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				else if (rowIndex == 2) return Row2[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				else if (rowIndex == 2) Row2[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#endregion
+
+		#region Instance
+
+		#region public void Invert()
+
+		public void Invert()
+		{
+			this = Matrix3x4d.Invert(this);
+		}
+
+		#endregion
+
+		#endregion
+
+		#region Static
+
+		#region CreateFromAxisAngle
+
+		/// <summary>
+		/// Build a rotation matrix from the specified axis/angle rotation.
+		/// </summary>
+		/// <param name="axis">The axis to rotate about.</param>
+		/// <param name="angle">Angle in radians to rotate counter-clockwise (looking in the direction of the given axis).</param>
+		/// <param name="result">A matrix instance.</param>
+		public static void CreateFromAxisAngle(Vector3d axis, double angle, out Matrix3x4d result)
+		{
+			axis.Normalize();
+			double axisX = axis.X, axisY = axis.Y, axisZ = axis.Z;
+
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+			double t = 1.0f - cos;
+
+			double tXX = t * axisX * axisX,
+				tXY = t * axisX * axisY,
+				tXZ = t * axisX * axisZ,
+				tYY = t * axisY * axisY,
+				tYZ = t * axisY * axisZ,
+				tZZ = t * axisZ * axisZ;
+
+			double sinX = sin * axisX,
+				sinY = sin * axisY,
+				sinZ = sin * axisZ;
+
+			result.Row0.X = tXX + cos;
+			result.Row0.Y = tXY - sinZ;
+			result.Row0.Z = tXZ + sinY;
+			result.Row0.W = 0;
+			result.Row1.X = tXY + sinZ;
+			result.Row1.Y = tYY + cos;
+			result.Row1.Z = tYZ - sinX;
+			result.Row1.W = 0;
+			result.Row2.X = tXZ - sinY;
+			result.Row2.Y = tYZ + sinX;
+			result.Row2.Z = tZZ + cos;
+			result.Row2.W = 0;
+		}
+
+		/// <summary>
+		/// Build a rotation matrix from the specified axis/angle rotation.
+		/// </summary>
+		/// <param name="axis">The axis to rotate about.</param>
+		/// <param name="angle">Angle in radians to rotate counter-clockwise (looking in the direction of the given axis).</param>
+		/// <returns>A matrix instance.</returns>
+		public static Matrix3x4d CreateFromAxisAngle(Vector3d axis, double angle)
+		{
+			Matrix3x4d result;
+			CreateFromAxisAngle(axis, angle, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateFromQuaternion
+
+		/// <summary>
+		/// Builds a rotation matrix from a quaternion.
+		/// </summary>
+		/// <param name="q">The quaternion to rotate by.</param>
+		/// <param name="result">A matrix instance.</param>
+		public static void CreateFromQuaternion(ref Quaternion q, out Matrix3x4d result)
+		{
+			double x = q.X, y = q.Y, z = q.Z, w = q.W,
+				tx = 2 * x, ty = 2 * y, tz = 2 * z,
+				txx = tx * x, tyy = ty * y, tzz = tz * z,
+				txy = tx * y, txz = tx * z, tyz = ty * z,
+				txw = tx * w, tyw = ty * w, tzw = tz * w;
+
+			result.Row0.X = 1f - (tyy + tzz);
+			result.Row0.Y = txy + tzw;
+			result.Row0.Z = txz - tyw;
+			result.Row0.W = 0f;
+			result.Row1.X = txy - tzw;
+			result.Row1.Y = 1f - (txx + tzz);
+			result.Row1.Z = tyz + txw;
+			result.Row1.W = 0f;
+			result.Row2.X = txz + tyw;
+			result.Row2.Y = tyz - txw;
+			result.Row2.Z = 1f - (txx + tyy);
+			result.Row2.W = 0f;
+
+			/*Vector3d axis;
+			double angle;
+			q.ToAxisAngle(out axis, out angle);
+			CreateFromAxisAngle(axis, angle, out result);*/
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix from a quaternion.
+		/// </summary>
+		/// <param name="q">The quaternion to rotate by.</param>
+		/// <returns>A matrix instance.</returns>
+		public static Matrix3x4d CreateFromQuaternion(Quaternion q)
+		{
+			Matrix3x4d result;
+			CreateFromQuaternion(ref q, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateRotation[XYZ]
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the x-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4 instance.</param>
+		public static void CreateRotationX(double angle, out Matrix3x4d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row0.W = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = cos;
+			result.Row1.Z = sin;
+			result.Row1.W = 0;
+			result.Row2.X = 0;
+			result.Row2.Y = -sin;
+			result.Row2.Z = cos;
+			result.Row2.W = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the x-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4 instance.</returns>
+		public static Matrix3x4d CreateRotationX(double angle)
+		{
+			Matrix3x4d result;
+			CreateRotationX(angle, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the y-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4 instance.</param>
+		public static void CreateRotationY(double angle, out Matrix3x4d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = cos;
+			result.Row0.Y = 0;
+			result.Row0.Z = -sin;
+			result.Row0.W = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row1.W = 0;
+			result.Row2.X = sin;
+			result.Row2.Y = 0;
+			result.Row2.Z = cos;
+			result.Row2.W = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the y-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4 instance.</returns>
+		public static Matrix3x4d CreateRotationY(double angle)
+		{
+			Matrix3x4d result;
+			CreateRotationY(angle, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the z-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4 instance.</param>
+		public static void CreateRotationZ(double angle, out Matrix3x4d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)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;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row2.W = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the z-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4 instance.</returns>
+		public static Matrix3x4d CreateRotationZ(double angle)
+		{
+			Matrix3x4d result;
+			CreateRotationZ(angle, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateTranslation
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="x">X translation.</param>
+		/// <param name="y">Y translation.</param>
+		/// <param name="z">Z translation.</param>
+		/// <param name="result">The resulting Matrix4 instance.</param>
+		public static void CreateTranslation(double x, double y, double z, out Matrix3x4d result)
+		{
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row0.W = x;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row1.W = y;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row2.W = z;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="vector">The translation vector.</param>
+		/// <param name="result">The resulting Matrix4 instance.</param>
+		public static void CreateTranslation(ref Vector3d vector, out Matrix3x4d result)
+		{
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row0.W = vector.X;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row1.W = vector.Y;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row2.W = vector.Z;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="x">X translation.</param>
+		/// <param name="y">Y translation.</param>
+		/// <param name="z">Z translation.</param>
+		/// <returns>The resulting Matrix4 instance.</returns>
+		public static Matrix3x4d CreateTranslation(double x, double y, double z)
+		{
+			Matrix3x4d result;
+			CreateTranslation(x, y, z, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="vector">The translation vector.</param>
+		/// <returns>The resulting Matrix4 instance.</returns>
+		public static Matrix3x4d CreateTranslation(Vector3d vector)
+		{
+			Matrix3x4d result;
+			CreateTranslation(vector.X, vector.Y, vector.Z, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateScale
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="scale">Single scale factor for x,y and z axes</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix3x4d CreateScale(double scale)
+		{
+			return CreateScale(scale, scale, scale);
+		}
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="scale">Scale factors for x,y and z axes</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix3x4d CreateScale(Vector3d scale)
+		{
+			return CreateScale(scale.X, scale.Y, scale.Z);
+		}
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="x">Scale factor for x-axis</param>
+		/// <param name="y">Scale factor for y-axis</param>
+		/// <param name="z">Scale factor for z-axis</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix3x4d CreateScale(double x, double y, double z)
+		{
+			Matrix3x4d 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;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = z;
+			result.Row2.W = 0;
+			return result;
+		}
+
+		#endregion
+
+		#region Multiply Functions
+
+		/// <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 Matrix3d Mult(Matrix3x4d left, Matrix4x3d right)
+		{
+			Matrix3d 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 Matrix3x4d left, ref Matrix4x3d right, out Matrix3d result)
+		{
+			double 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,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y, lM33 = left.Row2.Z, lM34 = left.Row2.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);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21) + (lM33 * rM31) + (lM34 * rM41);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22) + (lM33 * rM32) + (lM34 * rM42);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23) + (lM33 * rM33) + (lM34 * rM43);
+		}
+
+		public static Matrix3x4d Mult(Matrix3x4d left, Matrix3x4d right)
+		{
+			Matrix3x4d result;
+			Mult(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Mult(ref Matrix3x4d left, ref Matrix3x4d right, out Matrix3x4d result)
+		{
+			double 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,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y, lM33 = left.Row2.Z, lM34 = left.Row2.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;
+
+			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) + lM14;
+			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) + lM24;
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21) + (lM33 * rM31);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22) + (lM33 * rM32);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23) + (lM33 * rM33);
+			result.Row2.W = (lM31 * rM14) + (lM32 * rM24) + (lM33 * rM34) + lM34;
+
+			/*result.Row0 = (right.Row0 * lM11 + right.Row1 * lM12 + right.Row2 * lM13);
+			result.Row0.W += lM14;
+
+			result.Row1 = (right.Row0 * lM21 + right.Row1 * lM22 + right.Row2 * lM23);
+			result.Row1.W += lM24;
+
+			result.Row2 = (right.Row0 * lM31 + right.Row1 * lM32 + right.Row2 * lM33);
+			result.Row2.W += lM34;*/
+		}
+
+		public static Matrix3x4d Mult(Matrix3x4d left, double right)
+		{
+			Matrix3x4d result;
+			Mult(ref left, right, out result);
+			return result;
+		}
+
+		public static void Mult(ref Matrix3x4d left, double right, out Matrix3x4d result)
+		{
+			result.Row0 = left.Row0 * right;
+			result.Row1 = left.Row1 * right;
+			result.Row2 = left.Row2 * right;
+		}
+
+		#endregion
+
+		#region Add Functions
+
+		public static Matrix3x4d Add(Matrix3x4d left, Matrix3x4d right)
+		{
+			Matrix3x4d result;
+			Add(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Add(ref Matrix3x4d left, ref Matrix3x4d right, out Matrix3x4d result)
+		{
+			result.Row0 = left.Row0 + right.Row0;
+			result.Row1 = left.Row1 + right.Row1;
+			result.Row2 = left.Row2 + right.Row2;
+		}
+
+		#endregion
+
+		#region Subtract Functions
+
+		public static Matrix3x4d Subtract(Matrix3x4d left, Matrix3x4d right)
+		{
+			Matrix3x4d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Subtract(ref Matrix3x4d left, ref Matrix3x4d right, out Matrix3x4d result)
+		{
+			result.Row0 = left.Row0 - right.Row0;
+			result.Row1 = left.Row1 - right.Row1;
+			result.Row2 = left.Row2 - right.Row2;
+		}
+
+		#endregion
+
+		#region Invert Functions
+
+		public static Matrix3x4d Invert(Matrix3x4d mat)
+		{
+			Matrix3x4d result;
+			Invert(ref mat, out result);
+			return result;
+		}
+
+		public static void Invert(ref Matrix3x4d mat, out Matrix3x4d result)
+		{
+			Matrix3d inverseRotation = new Matrix3d(mat.Column0, mat.Column1, mat.Column2);
+			inverseRotation.Row0 /= inverseRotation.Row0.LengthSquared;
+			inverseRotation.Row1 /= inverseRotation.Row1.LengthSquared;
+			inverseRotation.Row2 /= inverseRotation.Row2.LengthSquared;
+
+			Vector3d translation = new Vector3d(mat.Row0.W, mat.Row1.W, mat.Row2.W);
+
+			result.Row0 = new Vector4d(inverseRotation.Row0, -Vector3d.Dot(inverseRotation.Row0, translation));
+			result.Row1 = new Vector4d(inverseRotation.Row1, -Vector3d.Dot(inverseRotation.Row1, translation));
+			result.Row2 = new Vector4d(inverseRotation.Row2, -Vector3d.Dot(inverseRotation.Row2, translation));
+		}
+
+		#endregion
+
+		#region Transpose
+
+		public static Matrix4x3d Transpose(Matrix3x4d mat)
+		{
+			return new Matrix4x3d(mat.Column0, mat.Column1, mat.Column2, mat.Column3);
+		}
+
+		public static void Transpose(ref Matrix3x4d mat, out Matrix4x3d result)
+		{
+			result.Row0 = mat.Column0;
+			result.Row1 = mat.Column1;
+			result.Row2 = mat.Column2;
+			result.Row3 = mat.Column3;
+		}
+
+		#endregion
+
+		#endregion
+
+		#region Operators
+
+		public static Matrix3d operator *(Matrix3x4d left, Matrix4x3d right)
+		{
+			return Matrix3x4d.Mult(left, right);
+		}
+
+		public static Matrix3x4d operator *(Matrix3x4d left, Matrix3x4d right)
+		{
+			return Matrix3x4d.Mult(left, right);
+		}
+
+		public static Matrix3x4d operator *(Matrix3x4d left, double right)
+		{
+			return Matrix3x4d.Mult(left, right);
+		}
+
+		public static Matrix3x4d operator +(Matrix3x4d left, Matrix3x4d right)
+		{
+			return Matrix3x4d.Add(left, right);
+		}
+
+		public static Matrix3x4d operator -(Matrix3x4d left, Matrix3x4d right)
+		{
+			return Matrix3x4d.Subtract(left, right);
+		}
+
+		public static bool operator ==(Matrix3x4d left, Matrix3x4d right)
+		{
+			return left.Equals(right);
+		}
+
+		public static bool operator !=(Matrix3x4d left, Matrix3x4d right)
+		{
+			return !left.Equals(right);
+		}
+
+		#endregion
+
+		#region Overrides
+
+		#region public override string ToString()
+
+		public override string ToString()
+		{
+			return string.Format("{0}\n{1}\n{2}", Row0, Row1, Row2);
+		}
+
+		#endregion
+
+		#region public override int GetHashCode()
+
+		public override int GetHashCode()
+		{
+			return Row0.GetHashCode() ^ Row1.GetHashCode() ^ Row2.GetHashCode();
+		}
+
+		#endregion
+
+		#region public override bool Equals(object obj)
+
+		public override bool Equals(object obj)
+		{
+			if (!(obj is Matrix3x4d))
+				return false;
+
+			return this.Equals((Matrix3x4d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix3x4d> Members
+
+		/// <summary>
+		/// Indicates whether the current matrix is equal to another matrix.
+		/// </summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix3x4d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1 &&
+				Row2 == other.Row2;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix4x2d.cs

@@ -27,8 +27,739 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix4x2.cs when it's mostly feature-complete.
-	/*public struct Matrix4x2d : IEquatable<Matrix4x2d>
+	/// <summary>
+	/// Represents a 4x2 matrix.
+	/// </summary>
+	public struct Matrix4x2d : IEquatable<Matrix4x2d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix.
+		/// </summary>
+		public Vector2d Row0;
+
+		/// <summary>
+		/// Second row of the matrix.
+		/// </summary>
+		public Vector2d Row1;
+
+		/// <summary>
+		/// Third row of the matrix.
+		/// </summary>
+		public Vector2d Row2;
+
+		/// <summary>
+		/// Bottom row of the matrix.
+		/// </summary>
+		public Vector2d Row3;
+
+		/// <summary>
+		/// The zero matrix.
+		/// </summary>
+		public static readonly Matrix4x2d Zero = new Matrix4x2d(Vector2d.Zero, Vector2d.Zero, Vector2d.Zero, Vector2d.Zero);
+
+		#endregion
+
+		#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">Third row of the matrix.</param>
+		/// <param name="row3">Bottom row of the matrix.</param>
+		public Matrix4x2d(Vector2d row0, Vector2d row1, Vector2d row2, Vector2d row3)
+		{
+			Row0 = row0;
+			Row1 = row1;
+			Row2 = row2;
+			Row3 = row3;
+		}
+
+
+		/// <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>
+		/// <param name="m30">First item of the fourth row of the matrix.</param>
+		/// <param name="m31">Second item of the fourth row of the matrix.</param>
+		public Matrix4x2d(
+			double m00, double m01,
+			double m10, double m11,
+			double m20, double m21,
+			double m30, double m31)
+		{
+			Row0 = new Vector2d(m00, m01);
+			Row1 = new Vector2d(m10, m11);
+			Row2 = new Vector2d(m20, m21);
+			Row3 = new Vector2d(m30, m31);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets or sets the first column of this matrix.
+		/// </summary>
+		public Vector4d Column0
+		{
+			get { return new Vector4d(Row0.X, Row1.X, Row2.X, Row3.X); }
+			set { Row0.X = value.X; Row1.X = value.Y; Row2.X = value.Z; Row3.X = value.W; }
+		}
+
+		/// <summary>
+		/// Gets or sets the second column of this matrix.
+		/// </summary>
+		public Vector4d Column1
+		{
+			get { return new Vector4d(Row0.Y, Row1.Y, Row2.Y, Row3.X); }
+			set { Row0.Y = value.X; Row1.Y = value.Y; Row2.Y = value.Z; Row3.Y = value.W; }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 1 of this instance.
+		/// </summary>
+		public double M31 { get { return Row2.X; } set { Row2.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 2 of this instance.
+		/// </summary>
+		public double M32 { get { return Row2.Y; } set { Row2.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 4, column 1 of this instance.
+		/// </summary>
+		public double M41 { get { return Row3.X; } set { Row3.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 4, column 2 of this instance.
+		/// </summary>
+		public double M42 { get { return Row3.Y; } set { Row3.Y = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				else if (rowIndex == 2) return Row2[columnIndex];
+				else if (rowIndex == 3) return Row3[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				else if (rowIndex == 2) Row2[columnIndex] = value;
+				else if (rowIndex == 3) Row3[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#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 Matrix3x2 instance.</param>
+		public static void CreateRotation(double angle, out Matrix4x2d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = cos;
+			result.Row0.Y = sin;
+			result.Row1.X = -sin;
+			result.Row1.Y = cos;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix3x2 instance.</returns>
+		public static Matrix4x2d CreateRotation(double angle)
+		{
+			Matrix4x2d 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(double scale, out Matrix4x2d result)
+		{
+			result.Row0.X = scale;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row3.X = 0;
+			result.Row3.Y = 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 Matrix4x2d CreateScale(double scale)
+		{
+			Matrix4x2d 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(Vector2d scale, out Matrix4x2d result)
+		{
+			result.Row0.X = scale.X;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = scale.Y;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row3.X = 0;
+			result.Row3.Y = 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 Matrix4x2d CreateScale(Vector2d scale)
+		{
+			Matrix4x2d 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(double x, double y, out Matrix4x2d result)
+		{
+			result.Row0.X = x;
+			result.Row0.Y = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = y;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row3.X = 0;
+			result.Row3.Y = 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 Matrix4x2d CreateScale(double x, double y)
+		{
+			Matrix4x2d 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 Matrix4x2d left, double right, out Matrix4x2d result)
+		{
+			result.Row0.X = left.Row0.X * right;
+			result.Row0.Y = left.Row0.Y * right;
+			result.Row1.X = left.Row1.X * right;
+			result.Row1.Y = left.Row1.Y * right;
+			result.Row2.X = left.Row2.X * right;
+			result.Row2.Y = left.Row2.Y * right;
+			result.Row3.X = left.Row3.X * right;
+			result.Row3.Y = left.Row3.Y * 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 Matrix4x2d Mult(Matrix4x2d left, double right)
+		{
+			Matrix4x2d 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 Matrix4x2d left, ref Matrix2d right, out Matrix4x2d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				lM41 = left.Row3.X, lM42 = left.Row3.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+			result.Row3.X = (lM41 * rM11) + (lM42 * rM21);
+			result.Row3.Y = (lM41 * rM12) + (lM42 * rM22);
+		}
+
+		/// <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 Matrix4x2d Mult(Matrix4x2d left, Matrix2d right)
+		{
+			Matrix4x2d 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 Matrix4x2d left, ref Matrix2x3d right, out Matrix4x3d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				lM41 = left.Row3.X, lM42 = left.Row3.Y,
+				rM11 = right.Row0.X, rM12 = right.Row0.Y, rM13 = right.Row0.Z,
+				rM21 = right.Row1.X, rM22 = right.Row1.Y, rM23 = right.Row1.Z;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23);
+			result.Row3.X = (lM41 * rM11) + (lM42 * rM21);
+			result.Row3.Y = (lM41 * rM12) + (lM42 * rM22);
+			result.Row3.Z = (lM41 * rM13) + (lM42 * rM23);
+		}
+
+		/// <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 Matrix4x3d Mult(Matrix4x2d left, Matrix2x3d right)
+		{
+			Matrix4x3d 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 Matrix4x2d left, ref Matrix2x4d right, out Matrix4d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y,
+				lM41 = left.Row3.X, lM42 = left.Row3.Y,
+				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;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21);
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22);
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23);
+			result.Row0.W = (lM11 * rM14) + (lM12 * rM24);
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21);
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22);
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23);
+			result.Row1.W = (lM21 * rM14) + (lM22 * rM24);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23);
+			result.Row2.W = (lM31 * rM14) + (lM32 * rM24);
+			result.Row3.X = (lM41 * rM11) + (lM42 * rM21);
+			result.Row3.Y = (lM41 * rM12) + (lM42 * rM22);
+			result.Row3.Z = (lM41 * rM13) + (lM42 * rM23);
+			result.Row3.W = (lM41 * rM14) + (lM42 * rM24);
+		}
+
+		/// <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 Matrix4d Mult(Matrix4x2d left, Matrix2x4d right)
+		{
+			Matrix4d 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 Matrix4x2d left, ref Matrix4x2d right, out Matrix4x2d result)
+		{
+			result.Row0.X = left.Row0.X + right.Row0.X;
+			result.Row0.Y = left.Row0.Y + right.Row0.Y;
+			result.Row1.X = left.Row1.X + right.Row1.X;
+			result.Row1.Y = left.Row1.Y + right.Row1.Y;
+			result.Row2.X = left.Row2.X + right.Row2.X;
+			result.Row2.Y = left.Row2.Y + right.Row2.Y;
+			result.Row3.X = left.Row3.X + right.Row3.X;
+			result.Row3.Y = left.Row3.Y + right.Row3.Y;
+		}
+
+		/// <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 Matrix4x2d Add(Matrix4x2d left, Matrix4x2d right)
+		{
+			Matrix4x2d 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 Matrix4x2d left, ref Matrix4x2d right, out Matrix4x2d result)
+		{
+			result.Row0.X = left.Row0.X - right.Row0.X;
+			result.Row0.Y = left.Row0.Y - right.Row0.Y;
+			result.Row1.X = left.Row1.X - right.Row1.X;
+			result.Row1.Y = left.Row1.Y - right.Row1.Y;
+			result.Row2.X = left.Row2.X - right.Row2.X;
+			result.Row2.Y = left.Row2.Y - right.Row2.Y;
+			result.Row3.X = left.Row3.X - right.Row3.X;
+			result.Row3.Y = left.Row3.Y - right.Row3.Y;
+		}
+
+		/// <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 Matrix4x2d Subtract(Matrix4x2d left, Matrix4x2d right)
+		{
+			Matrix4x2d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		#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 Matrix4x2d mat, out Matrix2x4d result)
+		{
+			result.Row0.X = mat.Row0.X;
+			result.Row0.Y = mat.Row1.X;
+			result.Row0.Z = mat.Row2.X;
+			result.Row0.W = mat.Row3.X;
+			result.Row1.X = mat.Row0.Y;
+			result.Row1.Y = mat.Row1.Y;
+			result.Row1.Z = mat.Row2.Y;
+			result.Row1.W = mat.Row3.Y;
+		}
+
+		/// <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 Matrix2x4d Transpose(Matrix4x2d mat)
+		{
+			Matrix2x4d 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 Matrix4x2d which holds the result of the multiplication</returns>
+		public static Matrix4x2d operator *(double left, Matrix4x2d 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 Matrix4x2d which holds the result of the multiplication</returns>
+		public static Matrix4x2d operator *(Matrix4x2d left, double 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 Matrix2d which holds the result of the multiplication</returns>
+		public static Matrix4x2d operator *(Matrix4x2d left, Matrix2d 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 Matrix4x3d which holds the result of the multiplication</returns>
+		public static Matrix4x3d operator *(Matrix4x2d left, Matrix2x3d 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 Matrix4d which holds the result of the multiplication</returns>
+		public static Matrix4d operator *(Matrix4x2d left, Matrix2x4d 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 Matrix4x2d which holds the result of the addition</returns>
+		public static Matrix4x2d operator +(Matrix4x2d left, Matrix4x2d 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 Matrix4x2d which holds the result of the subtraction</returns>
+		public static Matrix4x2d operator -(Matrix4x2d left, Matrix4x2d 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 ==(Matrix4x2d left, Matrix4x2d 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 !=(Matrix4x2d left, Matrix4x2d right)
+		{
+			return !left.Equals(right);
+		}
+
+		#endregion
+
+		#region Overrides
+
+		#region public override string ToString()
+
+		/// <summary>
+		/// Returns a System.String that represents the current Matrix3d.
+		/// </summary>
+		/// <returns>The string representation of the matrix.</returns>
+		public override string ToString()
+		{
+			return String.Format("{0}\n{1}\n{2}\n{3}", Row0, Row1, Row2, Row3);
+		}
+
+		#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() ^ Row2.GetHashCode() ^ Row3.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 Matrix4x2d))
+				return false;
+
+			return this.Equals((Matrix4x2d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix4x2d> Members
+
+		/// <summary>
+		/// Indicates whether the current matrix is equal to another matrix.
+		/// </summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix4x2d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1 &&
+				Row2 == other.Row2 &&
+				Row3 == other.Row3;
+		}
+
+		#endregion
+	}
 }

Source/OpenTK/Math/Matrix4x3.cs

@@ -745,17 +745,17 @@ namespace OpenTK
 
 		#region Transpose
 
-		/*public static Matrix3x4 Transpose(Matrix4x3 mat)
+		public static Matrix3x4 Transpose(Matrix4x3 mat)
 		{
 			return new Matrix3x4(mat.Column0, mat.Column1, mat.Column2);
 		}
 
-		public static void Transpose(ref Matrix4x3 mat, out Matrix4x3 result)
+		public static void Transpose(ref Matrix4x3 mat, out Matrix3x4 result)
 		{
 			result.Row0 = mat.Column0;
 			result.Row1 = mat.Column1;
 			result.Row2 = mat.Column2;
-		}*/
+		}
 
 		#endregion
 

Source/OpenTK/Math/Matrix4x3d.cs

@@ -27,8 +27,842 @@ using System.Runtime.InteropServices;
 
 namespace OpenTK
 {
-	//TODO copy from Matrix4x3.cs when it's mostly feature-complete.
-	/*public struct Matrix4x3d : IEquatable<Matrix4x3d>
+	/// <summary>
+	/// Represents a 3x4 matrix.
+	/// </summary>
+	[Serializable]
+	[StructLayout(LayoutKind.Sequential)]
+	public struct Matrix4x3d : IEquatable<Matrix4x3d>
 	{
-	}*/
+		#region Fields
+
+		/// <summary>
+		/// Top row of the matrix
+		/// </summary>
+		public Vector3d Row0;
+
+		/// <summary>
+		/// 2nd row of the matrix
+		/// </summary>
+		public Vector3d Row1;
+
+		/// <summary>
+		/// 3rd row of the matrix
+		/// </summary>
+		public Vector3d Row2;
+
+		/// <summary>
+		/// Bottom row of the matrix
+		/// </summary>
+		public Vector3d Row3;
+
+		/// <summary>
+		/// The zero matrix
+		/// </summary>
+		public static Matrix4x3d Zero = new Matrix4x3d(Vector3d.Zero, Vector3d.Zero, Vector3d.Zero, Vector3d.Zero);
+
+		#endregion
+
+		#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">Third row of the matrix</param>
+		/// <param name="row3">Bottom row of the matrix</param>
+		public Matrix4x3d(Vector3d row0, Vector3d row1, Vector3d row2, Vector3d row3)
+		{
+			Row0 = row0;
+			Row1 = row1;
+			Row2 = row2;
+			Row3 = row3;
+		}
+
+		/// <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="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="m20">First item of the third row of the matrix.</param>
+		/// <param name="m21">Second item of the third row of the matrix.</param>
+		/// <param name="m22">Third item of the third row of the matrix.</param>
+		/// <param name="m30">First item of the fourth row of the matrix.</param>
+		/// <param name="m31">Second item of the fourth row of the matrix.</param>
+		/// <param name="m32">Third item of the fourth row of the matrix.</param>
+		public Matrix4x3d(
+			double m00, double m01, double m02,
+			double m10, double m11, double m12,
+			double m20, double m21, double m22,
+			double m30, double m31, double m32)
+		{
+			Row0 = new Vector3d(m00, m01, m02);
+			Row1 = new Vector3d(m10, m11, m12);
+			Row2 = new Vector3d(m20, m21, m22);
+			Row3 = new Vector3d(m30, m31, m32);
+		}
+
+		#endregion
+
+		#region Public Members
+
+		#region Properties
+
+		/// <summary>
+		/// Gets the first column of this matrix.
+		/// </summary>
+		public Vector4d Column0
+		{
+			get { return new Vector4d(Row0.X, Row1.X, Row2.X, Row3.X); }
+		}
+
+		/// <summary>
+		/// Gets the second column of this matrix.
+		/// </summary>
+		public Vector4d Column1
+		{
+			get { return new Vector4d(Row0.Y, Row1.Y, Row2.Y, Row3.Y); }
+		}
+
+		/// <summary>
+		/// Gets the third column of this matrix.
+		/// </summary>
+		public Vector4d Column2
+		{
+			get { return new Vector4d(Row0.Z, Row1.Z, Row2.Z, Row3.Z); }
+		}
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 1 of this instance.
+		/// </summary>
+		public double M11 { get { return Row0.X; } set { Row0.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 2 of this instance.
+		/// </summary>
+		public double M12 { get { return Row0.Y; } set { Row0.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 1, column 3 of this instance.
+		/// </summary>
+		public double M13 { get { return Row0.Z; } set { Row0.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 1 of this instance.
+		/// </summary>
+		public double M21 { get { return Row1.X; } set { Row1.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 2 of this instance.
+		/// </summary>
+		public double M22 { get { return Row1.Y; } set { Row1.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 2, column 3 of this instance.
+		/// </summary>
+		public double M23 { get { return Row1.Z; } set { Row1.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 1 of this instance.
+		/// </summary>
+		public double M31 { get { return Row2.X; } set { Row2.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 2 of this instance.
+		/// </summary>
+		public double M32 { get { return Row2.Y; } set { Row2.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 3, column 3 of this instance.
+		/// </summary>
+		public double M33 { get { return Row2.Z; } set { Row2.Z = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 4, column 1 of this instance.
+		/// </summary>
+		public double M41 { get { return Row3.X; } set { Row3.X = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 4, column 2 of this instance.
+		/// </summary>
+		public double M42 { get { return Row3.Y; } set { Row3.Y = value; } }
+
+		/// <summary>
+		/// Gets or sets the value at row 4, column 3 of this instance.
+		/// </summary>
+		public double M43 { get { return Row3.Z; } set { Row3.Z = value; } }
+
+		#endregion
+
+		#region Indexers
+
+		/// <summary>
+		/// Gets or sets the value at a specified row and column.
+		/// </summary>
+		public double this[int rowIndex, int columnIndex]
+		{
+			get
+			{
+				if (rowIndex == 0) return Row0[columnIndex];
+				else if (rowIndex == 1) return Row1[columnIndex];
+				else if (rowIndex == 2) return Row2[columnIndex];
+				else if (rowIndex == 3) return Row3[columnIndex];
+				throw new IndexOutOfRangeException("You tried to access this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+			set
+			{
+				if (rowIndex == 0) Row0[columnIndex] = value;
+				else if (rowIndex == 1) Row1[columnIndex] = value;
+				else if (rowIndex == 2) Row2[columnIndex] = value;
+				else if (rowIndex == 3) Row3[columnIndex] = value;
+				throw new IndexOutOfRangeException("You tried to set this matrix at: (" + rowIndex + ", " + columnIndex + ")");
+			}
+		}
+
+		#endregion
+
+		#region Instance
+
+		#region public void Invert()
+
+		public void Invert()
+		{
+			this = Matrix4x3d.Invert(this);
+		}
+
+		#endregion
+
+		#endregion
+
+		#region Static
+
+		#region CreateFromAxisAngle
+
+		/// <summary>
+		/// Build a rotation matrix from the specified axis/angle rotation.
+		/// </summary>
+		/// <param name="axis">The axis to rotate about.</param>
+		/// <param name="angle">Angle in radians to rotate counter-clockwise (looking in the direction of the given axis).</param>
+		/// <param name="result">A matrix instance.</param>
+		public static void CreateFromAxisAngle(Vector3d axis, double angle, out Matrix4x3d result)
+		{
+			axis.Normalize();
+			double axisX = axis.X, axisY = axis.Y, axisZ = axis.Z;
+
+			double cos = (double)System.Math.Cos(-angle);
+			double sin = (double)System.Math.Sin(-angle);
+			double t = 1.0f - cos;
+
+			double tXX = t * axisX * axisX,
+				tXY = t * axisX * axisY,
+				tXZ = t * axisX * axisZ,
+				tYY = t * axisY * axisY,
+				tYZ = t * axisY * axisZ,
+				tZZ = t * axisZ * axisZ;
+
+			double sinX = sin * axisX,
+				sinY = sin * axisY,
+				sinZ = sin * axisZ;
+
+			result.Row0.X = tXX + cos;
+			result.Row0.Y = tXY - sinZ;
+			result.Row0.Z = tXZ + sinY;
+			result.Row1.X = tXY + sinZ;
+			result.Row1.Y = tYY + cos;
+			result.Row1.Z = tYZ - sinX;
+			result.Row2.X = tXZ - sinY;
+			result.Row2.Y = tYZ + sinX;
+			result.Row2.Z = tZZ + cos;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+		}
+
+		/// <summary>
+		/// Build a rotation matrix from the specified axis/angle rotation.
+		/// </summary>
+		/// <param name="axis">The axis to rotate about.</param>
+		/// <param name="angle">Angle in radians to rotate counter-clockwise (looking in the direction of the given axis).</param>
+		/// <returns>A matrix instance.</returns>
+		public static Matrix4x3d CreateFromAxisAngle(Vector3d axis, double angle)
+		{
+			Matrix4x3d result;
+			CreateFromAxisAngle(axis, angle, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateFromQuaternion
+
+		/// <summary>
+		/// Builds a rotation matrix from a quaternion.
+		/// </summary>
+		/// <param name="q">The quaternion to rotate by.</param>
+		/// <param name="result">A matrix instance.</param>
+		public static void CreateFromQuaternion(ref Quaternion q, out Matrix4x3d result)
+		{
+			double x = q.X, y = q.Y, z = q.Z, w = q.W,
+				tx = 2 * x, ty = 2 * y, tz = 2 * z,
+				txx = tx * x, tyy = ty * y, tzz = tz * z,
+				txy = tx * y, txz = tx * z, tyz = ty * z,
+				twx = w * tx, twy = w * ty, twz = w * tz;
+
+			result.Row0.X = 1f - tyy - tzz;
+			result.Row0.Y = txy - twz;
+			result.Row0.Z = txz + twy;
+			result.Row1.X = txy + twz;
+			result.Row1.Y = 1f - txx - tzz;
+			result.Row1.Z = tyz - twx;
+			result.Row2.X = txz - twy;
+			result.Row2.Y = tyz + twx;
+			result.Row2.Z = 1f - txx - tyy;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+
+			/*Vector3d axis;
+			double angle;
+			q.ToAxisAngle(out axis, out angle);
+			CreateFromAxisAngle(axis, angle, out result);*/
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix from a quaternion.
+		/// </summary>
+		/// <param name="q">The quaternion to rotate by.</param>
+		/// <returns>A matrix instance.</returns>
+		public static Matrix4x3d CreateFromQuaternion(Quaternion q)
+		{
+			Matrix4x3d result;
+			CreateFromQuaternion(ref q, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateRotation[XYZ]
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the x-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4dinstance.</param>
+		public static void CreateRotationX(double angle, out Matrix4x3d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = cos;
+			result.Row1.Z = sin;
+			result.Row2.X = 0;
+			result.Row2.Y = -sin;
+			result.Row2.Z = cos;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the x-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4dinstance.</returns>
+		public static Matrix4x3d CreateRotationX(double angle)
+		{
+			Matrix4x3d result;
+			CreateRotationX(angle, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the y-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4dinstance.</param>
+		public static void CreateRotationY(double angle, out Matrix4x3d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)System.Math.Sin(angle);
+
+			result.Row0.X = cos;
+			result.Row0.Y = 0;
+			result.Row0.Z = -sin;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row2.X = sin;
+			result.Row2.Y = 0;
+			result.Row2.Z = cos;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the y-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4dinstance.</returns>
+		public static Matrix4x3d CreateRotationY(double angle)
+		{
+			Matrix4x3d result;
+			CreateRotationY(angle, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the z-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <param name="result">The resulting Matrix4dinstance.</param>
+		public static void CreateRotationZ(double angle, out Matrix4x3d result)
+		{
+			double cos = (double)System.Math.Cos(angle);
+			double sin = (double)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;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+		}
+
+		/// <summary>
+		/// Builds a rotation matrix for a rotation around the z-axis.
+		/// </summary>
+		/// <param name="angle">The counter-clockwise angle in radians.</param>
+		/// <returns>The resulting Matrix4dinstance.</returns>
+		public static Matrix4x3d CreateRotationZ(double angle)
+		{
+			Matrix4x3d result;
+			CreateRotationZ(angle, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateTranslation
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="x">X translation.</param>
+		/// <param name="y">Y translation.</param>
+		/// <param name="z">Z translation.</param>
+		/// <param name="result">The resulting Matrix4dinstance.</param>
+		public static void CreateTranslation(double x, double y, double z, out Matrix4x3d result)
+		{
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row3.X = x;
+			result.Row3.Y = y;
+			result.Row3.Z = z;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="vector">The translation vector.</param>
+		/// <param name="result">The resulting Matrix4dinstance.</param>
+		public static void CreateTranslation(ref Vector3d vector, out Matrix4x3d result)
+		{
+			result.Row0.X = 1;
+			result.Row0.Y = 0;
+			result.Row0.Z = 0;
+			result.Row1.X = 0;
+			result.Row1.Y = 1;
+			result.Row1.Z = 0;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = 1;
+			result.Row3.X = vector.X;
+			result.Row3.Y = vector.Y;
+			result.Row3.Z = vector.Z;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="x">X translation.</param>
+		/// <param name="y">Y translation.</param>
+		/// <param name="z">Z translation.</param>
+		/// <returns>The resulting Matrix4dinstance.</returns>
+		public static Matrix4x3d CreateTranslation(double x, double y, double z)
+		{
+			Matrix4x3d result;
+			CreateTranslation(x, y, z, out result);
+			return result;
+		}
+
+		/// <summary>
+		/// Creates a translation matrix.
+		/// </summary>
+		/// <param name="vector">The translation vector.</param>
+		/// <returns>The resulting Matrix4dinstance.</returns>
+		public static Matrix4x3d CreateTranslation(Vector3d vector)
+		{
+			Matrix4x3d result;
+			CreateTranslation(vector.X, vector.Y, vector.Z, out result);
+			return result;
+		}
+
+		#endregion
+
+		#region CreateScale
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="scale">Single scale factor for x,y and z axes</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix4x3d CreateScale(double scale)
+		{
+			return CreateScale(scale, scale, scale);
+		}
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="scale">Scale factors for x,y and z axes</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix4x3d CreateScale(Vector3d scale)
+		{
+			return CreateScale(scale.X, scale.Y, scale.Z);
+		}
+
+		/// <summary>
+		/// Build a scaling matrix
+		/// </summary>
+		/// <param name="x">Scale factor for x-axis</param>
+		/// <param name="y">Scale factor for y-axis</param>
+		/// <param name="z">Scale factor for z-axis</param>
+		/// <returns>A scaling matrix</returns>
+		public static Matrix4x3d CreateScale(double x, double y, double z)
+		{
+			Matrix4x3d 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;
+			result.Row2.X = 0;
+			result.Row2.Y = 0;
+			result.Row2.Z = z;
+			result.Row3.X = 0;
+			result.Row3.Y = 0;
+			result.Row3.Z = 0;
+			return result;
+		}
+
+		#endregion
+
+		#region Multiply Functions
+
+		/// <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 Matrix4d Mult(Matrix4x3d left, Matrix3x4d right)
+		{
+			Matrix4d 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 Matrix4x3d left, ref Matrix3x4d right, out Matrix4d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y, lM33 = left.Row2.Z,
+				lM41 = left.Row3.X, lM42 = left.Row3.Y, lM43 = left.Row3.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);
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21) + (lM33 * rM31);
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22) + (lM33 * rM32);
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23) + (lM33 * rM33);
+			result.Row2.W = (lM31 * rM14) + (lM32 * rM24) + (lM33 * rM34);
+			result.Row3.X = (lM41 * rM11) + (lM42 * rM21) + (lM43 * rM31);
+			result.Row3.Y = (lM41 * rM12) + (lM42 * rM22) + (lM43 * rM32);
+			result.Row3.Z = (lM41 * rM13) + (lM42 * rM23) + (lM43 * rM33);
+			result.Row3.W = (lM41 * rM14) + (lM42 * rM24) + (lM43 * rM34);
+		}
+
+		public static Matrix4x3d Mult(Matrix4x3d left, Matrix4x3d right)
+		{
+			Matrix4x3d result;
+			Mult(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Mult(ref Matrix4x3d left, ref Matrix4x3d right, out Matrix4x3d result)
+		{
+			double lM11 = left.Row0.X, lM12 = left.Row0.Y, lM13 = left.Row0.Z,
+				lM21 = left.Row1.X, lM22 = left.Row1.Y, lM23 = left.Row1.Z,
+				lM31 = left.Row2.X, lM32 = left.Row2.Y, lM33 = left.Row2.Z,
+				lM41 = left.Row3.X, lM42 = left.Row3.Y, lM43 = left.Row3.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,
+				rM41 = right.Row3.X, rM42 = right.Row3.Y, rM43 = right.Row3.Z;
+
+			result.Row0.X = (lM11 * rM11) + (lM12 * rM21) + (lM13 * rM31) + rM41;
+			result.Row0.Y = (lM11 * rM12) + (lM12 * rM22) + (lM13 * rM32) + rM42;
+			result.Row0.Z = (lM11 * rM13) + (lM12 * rM23) + (lM13 * rM33) + rM43;
+			result.Row1.X = (lM21 * rM11) + (lM22 * rM21) + (lM23 * rM31) + rM41;
+			result.Row1.Y = (lM21 * rM12) + (lM22 * rM22) + (lM23 * rM32) + rM42;
+			result.Row1.Z = (lM21 * rM13) + (lM22 * rM23) + (lM23 * rM33) + rM43;
+			result.Row2.X = (lM31 * rM11) + (lM32 * rM21) + (lM33 * rM31) + rM41;
+			result.Row2.Y = (lM31 * rM12) + (lM32 * rM22) + (lM33 * rM32) + rM42;
+			result.Row2.Z = (lM31 * rM13) + (lM32 * rM23) + (lM33 * rM33) + rM43;
+			result.Row3.X = (lM41 * rM11) + (lM42 * rM21) + (lM43 * rM31) + rM41;
+			result.Row3.Y = (lM41 * rM12) + (lM42 * rM22) + (lM43 * rM32) + rM42;
+			result.Row3.Z = (lM41 * rM13) + (lM42 * rM23) + (lM43 * rM33) + rM43;
+		}
+
+		public static Matrix4x3d Mult(Matrix4x3d left, double right)
+		{
+			Matrix4x3d result;
+			Mult(ref left, right, out result);
+			return result;
+		}
+
+		public static void Mult(ref Matrix4x3d left, double right, out Matrix4x3d result)
+		{
+			result.Row0 = left.Row0 * right;
+			result.Row1 = left.Row1 * right;
+			result.Row2 = left.Row2 * right;
+			result.Row3 = left.Row3 * right;
+		}
+
+		#endregion
+
+		#region Add Functions
+
+		public static Matrix4x3d Add(Matrix4x3d left, Matrix4x3d right)
+		{
+			Matrix4x3d result;
+			Add(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Add(ref Matrix4x3d left, ref Matrix4x3d right, out Matrix4x3d result)
+		{
+			result.Row0 = left.Row0 + right.Row0;
+			result.Row1 = left.Row1 + right.Row1;
+			result.Row2 = left.Row2 + right.Row2;
+			result.Row3 = left.Row3 + right.Row3;
+		}
+
+		#endregion
+
+		#region Subtract Functions
+
+		public static Matrix4x3d Subtract(Matrix4x3d left, Matrix4x3d right)
+		{
+			Matrix4x3d result;
+			Subtract(ref left, ref right, out result);
+			return result;
+		}
+
+		public static void Subtract(ref Matrix4x3d left, ref Matrix4x3d right, out Matrix4x3d result)
+		{
+			result.Row0 = left.Row0 - right.Row0;
+			result.Row1 = left.Row1 - right.Row1;
+			result.Row2 = left.Row2 - right.Row2;
+			result.Row3 = left.Row3 - right.Row3;
+		}
+
+		#endregion
+
+		#region Invert Functions
+
+		public static Matrix4x3d Invert(Matrix4x3d mat)
+		{
+			Matrix4x3d result;
+			Invert(ref mat, out result);
+			return result;
+		}
+
+		public static void Invert(ref Matrix4x3d mat, out Matrix4x3d result)
+		{
+			Matrix3d inverseRotation = new Matrix3d(mat.Column0.Xyz, mat.Column1.Xyz, mat.Column2.Xyz);
+			inverseRotation.Row0 /= inverseRotation.Row0.LengthSquared;
+			inverseRotation.Row1 /= inverseRotation.Row1.LengthSquared;
+			inverseRotation.Row2 /= inverseRotation.Row2.LengthSquared;
+
+			Vector3d translation = mat.Row3;
+
+			result.Row0 = inverseRotation.Row0;
+			result.Row1 = inverseRotation.Row1;
+			result.Row2 = inverseRotation.Row2;
+			result.Row3 = new Vector3d(-Vector3d.Dot(inverseRotation.Row0, translation), -Vector3d.Dot(inverseRotation.Row1, translation), -Vector3d.Dot(inverseRotation.Row2, translation));
+		}
+
+		#endregion
+
+		#region Transpose
+
+		public static Matrix3x4d Transpose(Matrix4x3d mat)
+		{
+			return new Matrix3x4d(mat.Column0, mat.Column1, mat.Column2);
+		}
+
+		public static void Transpose(ref Matrix4x3d mat, out Matrix3x4d result)
+		{
+			result.Row0 = mat.Column0;
+			result.Row1 = mat.Column1;
+			result.Row2 = mat.Column2;
+		}
+
+		#endregion
+
+		#endregion
+
+		#region Operators
+
+		public static Matrix4d operator *(Matrix4x3d left, Matrix3x4d right)
+		{
+			return Matrix4x3d.Mult(left, right);
+		}
+
+		public static Matrix4x3d operator *(Matrix4x3d left, Matrix4x3d right)
+		{
+			return Matrix4x3d.Mult(left, right);
+		}
+
+		public static Matrix4x3d operator *(Matrix4x3d left, double right)
+		{
+			return Matrix4x3d.Mult(left, right);
+		}
+
+		public static Matrix4x3d operator +(Matrix4x3d left, Matrix4x3d right)
+		{
+			return Matrix4x3d.Add(left, right);
+		}
+
+		public static Matrix4x3d operator -(Matrix4x3d left, Matrix4x3d right)
+		{
+			return Matrix4x3d.Subtract(left, right);
+		}
+
+		public static bool operator ==(Matrix4x3d left, Matrix4x3d right)
+		{
+			return left.Equals(right);
+		}
+
+		public static bool operator !=(Matrix4x3d left, Matrix4x3d right)
+		{
+			return !left.Equals(right);
+		}
+
+		#endregion
+
+		#region Overrides
+
+		#region public override string ToString()
+
+		/// <summary>
+		/// Returns a System.String that represents the current Matrix4x3d.
+		/// </summary>
+		/// <returns>The string representation of the matrix.</returns>
+		public override string ToString()
+		{
+			return string.Format("{0}\n{1}\n{2}", Row0, Row1, Row2);
+		}
+
+		#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() ^ Row2.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 tresult.</param>
+		/// <returns>True if the instances are equal; false otherwise.</returns>
+		public override bool Equals(object obj)
+		{
+			if (!(obj is Matrix4x3d))
+				return false;
+
+			return this.Equals((Matrix4x3d)obj);
+		}
+
+		#endregion
+
+		#endregion
+
+		#endregion
+
+		#region IEquatable<Matrix4x3d> Members
+
+		/// <summary>Indicates whether the current matrix is equal to another matrix.</summary>
+		/// <param name="other">An matrix to compare with this matrix.</param>
+		/// <returns>true if the current matrix is equal to the matrix parameter; otherwise, false.</returns>
+		public bool Equals(Matrix4x3d other)
+		{
+			return
+				Row0 == other.Row0 &&
+				Row1 == other.Row1 &&
+				Row2 == other.Row2 &&
+				Row3 == other.Row3;
+		}
+
+		#endregion
+	}
 }