MatrixTests ClassDelta Engine Documentation
View code on GitHub
Inheritance Hierarchy
System Object
  DeltaEngine.Tests.Datatypes MatrixTests

Namespace: DeltaEngine.Tests.Datatypes
Assembly: DeltaEngine.Tests (in DeltaEngine.Tests.dll) Version: 1.1.1.0 (1.1.1)
Syntax
Copy to ClipboardPrint
public class MatrixTests

The MatrixTests type exposes the following members.

Constructors
  NameDescription
Public methodMatrixTests
Initializes a new instance of the MatrixTests class
Top
Methods
  NameDescription
Public methodAccessViolation
View code on GitHub
Public methodAreEqual
View code on GitHub
Public methodCalculateHashCode
View code on GitHub
Public methodChangeTranslationVector
View code on GitHub
Public methodCheckForwardVector
View code on GitHub
Public methodCheckRightVector
View code on GitHub
Public methodCheckTranslationVector
View code on GitHub
Public methodCheckUpVector
View code on GitHub
Public methodCreateFromAxisAngle
View code on GitHub
Public methodCreateFromString
View code on GitHub
Public methodCreateFrustrum
View code on GitHub
Public methodCreateLookAt
View code on GitHub
Public methodCreateLookAtFiveMetersDistance
View code on GitHub
Public methodCreateOrtographicProjectionMatrix
View code on GitHub
Public methodCreateOrtographicProjectionMatrixwithNearAndFarPlanes
View code on GitHub
Public methodCreateScale
View code on GitHub
Public methodCreateScaleFromThreeScalar
View code on GitHub
Public methodCreateWith16Floats
View code on GitHub
Public methodCreateWithFloatArray
View code on GitHub
Public methodFromQuaternion
View code on GitHub
Public methodGetDeterminant
View code on GitHub
Public methodIdentityHasDeterminantOne
View code on GitHub
Public methodInvert
View code on GitHub
Public methodInvertingTwiceReturnsTheOriginal
View code on GitHub
Public methodInvertTranspose
View code on GitHub
Public methodIsNotNearlyEqual
View code on GitHub
Public methodLoadFromString
View code on GitHub
Public methodMatrixTimesIdentityIsUnchanged
View code on GitHub
Public methodMatrixZero
View code on GitHub
Public methodMultiplyMatrix
View code on GitHub
Public methodMultiplyVector
View code on GitHub
Public methodRotateMatrix
View code on GitHub
Public methodsetForwardVector
View code on GitHub
Public methodSetRightVector
View code on GitHub
Public methodSetUp
View code on GitHub
Public methodSetUpVector
View code on GitHub
Public methodSizeOfMatrix
View code on GitHub
Public methodTransformPosition
View code on GitHub
Public methodTranslateMatrix
View code on GitHub
Public methodTranspose
View code on GitHub
Public methodTransposingTwiceReturnsTheOriginal
View code on GitHub
Public methodUnproject
View code on GitHub
Public methodWriteMatrix
View code on GitHub
Top
Examples
Copy to ClipboardPrint
[Test]
public void MatrixZero()
{
    matrix = new Matrix();
    for (int i = 0; i < 16; i++)
        Assert.AreEqual(0, matrix[i]);
}
Copy to ClipboardPrint
[Test]
public void CreateWith16Floats()
{
    AssertValues0To15();
}
Copy to ClipboardPrint
[Test]
public void CreateFromString()
{
    var textMatrix = new Matrix("0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15");
    for (int i = 0; i < 16; i++)
        Assert.AreEqual(textMatrix[i], matrix[i]);
}
Copy to ClipboardPrint
[Test]
public void CheckRightVector()
{
    Assert.AreEqual(new Vector3D(0, 1, 2), matrix.Right);
}
Copy to ClipboardPrint
[Test]
public void CheckUpVector()
{
    Assert.AreEqual(new Vector3D(4, 5, 6), matrix.Up);
}
Copy to ClipboardPrint
[Test]
public void CheckForwardVector()
{
    Assert.AreEqual(new Vector3D(8, 9, 10), matrix.Forward);
}
Copy to ClipboardPrint
[Test]
public void SetRightVector()
{
    matrix.Right = new Vector3D(1, 10, 20);
    Assert.AreEqual(new Vector3D(1, 10, 20), matrix.Right);
}
Copy to ClipboardPrint
[Test]
public void SetUpVector()
{
    matrix.Up = new Vector3D(3, 20, 30);
    Assert.AreEqual(new Vector3D(3, 20, 30), matrix.Up);
}
Copy to ClipboardPrint
[Test]
public void setForwardVector()
{
    matrix.Forward = new Vector3D(9, 26, 44);
    Assert.AreEqual(new Vector3D(9, 26, 44), matrix.Forward);
}
Copy to ClipboardPrint
[Test]
public void CheckTranslationVector()
{
    Assert.AreEqual(new Vector3D(12, 13, 14), matrix.Translation);
}
Copy to ClipboardPrint
[Test]
public void ChangeTranslationVector()
{
    var vector = new Vector3D(-1, -2, -3);
    matrix.Translation = vector;
    Assert.AreEqual(vector, matrix.Translation);
}
Copy to ClipboardPrint
[Test]
public void CreateWithFloatArray()
{
    matrix = new Matrix(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 });
Copy to ClipboardPrint
[Test]
public void CreateScale()
{
    matrix = Matrix.CreateScale(Vector3D.One*2);
    var expected = new Matrix(2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1);
    Assert.AreEqual(expected, matrix);
}
Copy to ClipboardPrint
[Test]
public void CreateScaleFromThreeScalar()
{
    matrix = Matrix.CreateScale(3, 4, 7);
    var expected = new Matrix(3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 7, 0, 0, 0, 0, 1);
    Assert.AreEqual(expected, matrix);
}
Copy to ClipboardPrint
[Test]
public void SizeOfMatrix()
{
    Assert.AreEqual(64, Matrix.SizeInBytes);
}
Copy to ClipboardPrint
[Test]
public void RotateMatrix()
{
    var matrix1 = new Matrix(1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1);
    var matrix2 = new Matrix(0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1);
    var matrix3 = new Matrix(0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
    var matrix4 = matrix1 * (matrix2 * matrix3);
    Assert.IsTrue(matrix1.IsNearlyEqual(Matrix.CreateRotationZYX(90, 0, 0)));
    Assert.IsTrue(matrix2.IsNearlyEqual(Matrix.CreateRotationZYX(0, 90, 0)));
    Assert.IsTrue(matrix3.IsNearlyEqual(Matrix.CreateRotationZYX(0, 0, 90)));
    Assert.IsTrue(matrix4.IsNearlyEqual(Matrix.CreateRotationZYX(90, 90, 90)));
}
Copy to ClipboardPrint
[Test]
public void FromQuaternion()
{
    var quaternion = Quaternion.FromAxisAngle(Vector3D.UnitY, 60.0f);
    matrix = Matrix.CreateRotationY(60.0f);
    Assert.AreEqual(matrix, Matrix.FromQuaternion(quaternion));
}
Copy to ClipboardPrint
[Test]
public void TranslateMatrix()
{
    var matrix1 = Matrix.CreateTranslation(1, 2, 3);
    var matrix2 = Matrix.CreateTranslation(1, 0, 0);
    Assert.AreEqual(new Vector3D(1, 2, 3), matrix1.Translation);
    Assert.AreEqual(Vector3D.UnitX, matrix2.Translation);
}
Copy to ClipboardPrint
[Test]
public void Transpose()
{
    var expected = new Matrix(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15);
    Assert.AreEqual(expected, Matrix.Transpose(matrix));
}
Copy to ClipboardPrint
[Test]
public void TransposingTwiceReturnsTheOriginal()
{
    Assert.AreEqual(matrix, Matrix.Transpose(Matrix.Transpose(matrix)));
}
Copy to ClipboardPrint
[Test]
public void Invert()
{
    var expected1 = new Matrix(1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1);
    var expected2 = new Matrix(0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1);
    var expected3 = new Matrix(0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
    Assert.IsTrue(Matrix.Invert(Matrix.CreateRotationX(90.0f)).IsNearlyEqual(expected1));
    Assert.IsTrue(Matrix.Invert(Matrix.CreateRotationY(90.0f)).IsNearlyEqual(expected2));
    Assert.IsTrue(Matrix.Invert(Matrix.CreateRotationZ(90.0f)).IsNearlyEqual(expected3));
}
Copy to ClipboardPrint
[Test]
public void InvertTranspose()
{
    var source = new Matrix(-4, 0, 0, 0, -1, 2, 0, 0, -4, 4, 4, 0, -1, -9, -1, 1);
    var expected1 = new Matrix(-0.25f, -0.125f, -0.125f, -1.5f, 0, 0.5f, -0.5f, 4, 0, 0, 0.25f,
        0.25f, 0, 0, 0, 1);
    Assert.IsTrue(Matrix.InverseTranspose(source).IsNearlyEqual(expected1));
}
Copy to ClipboardPrint
[Test]
public void InvertingTwiceReturnsTheOriginal()
{
    matrix = Matrix.CreateRotationY(60.0f);
    Assert.IsTrue(Matrix.Invert(Matrix.Invert(matrix)).IsNearlyEqual(matrix));
}
Copy to ClipboardPrint
[Test]
public void Unproject()
{
    matrix = Matrix.CreatePerspective(60.0f, 1.0f, 0.5f, 10.0f);
    var position = Matrix.TransformHomogeneousCoordinate(Vector3D.One, matrix);
    var invMatrix = Matrix.Invert(matrix);
    Assert.IsTrue(
        Matrix.TransformHomogeneousCoordinate(position, invMatrix).IsNearlyEqual(Vector3D.One));
}
Copy to ClipboardPrint
[Test]
public void CreateOrtographicProjectionMatrix()
{
    var size = new Size(10, 5);
    matrix = Matrix.CreateOrthoProjection(size);
    var expected = new Matrix(0.2f, 0.0f, 0.0f, 0.0f, 0.0f, -0.4f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f,
        0.0f, -1.0f, 1.0f, 0.0f, 1.0f);
    Assert.AreEqual(expected, matrix);
}
Copy to ClipboardPrint
[Test]
public void CreateOrtographicProjectionMatrixwithNearAndFarPlanes()
{
    var size = new Size(10, 5);
    matrix = Matrix.CreateOrthoProjection(size, 0.1f, 10.0f);
    var expected = new Matrix(0.2f, 0.0f, 0.0f, 0.0f, 0.0f, 0.4f, 0.0f, 0.0f, 0.0f, 0.0f, -0.202f,
        0.0f, 0.0f, 0.0f, -1.0202f, 1.0f);
    Assert.IsTrue(expected.IsNearlyEqual(matrix));
}
Copy to ClipboardPrint
[Test]
public void CreateLookAt()
{
    var createdLookAt = Matrix.CreateLookAt(Vector3D.UnitZ, Vector3D.UnitX, Vector3D.UnitY);
    var expected = new Matrix(0.7071f, 0.0f, -0.7071f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
        0.7071f, -0.0f, 0.7071f, 0.0f, -0.7071f, 0.0f, -0.7071f, 1.0f);
    Assert.IsTrue(createdLookAt.IsNearlyEqual(expected));
}
Copy to ClipboardPrint
[Test]
public void CreateLookAtFiveMetersDistance()
{
    var createdLookAt = Matrix.CreateLookAt(new Vector3D(0.0f, 0.0f, 5.0f), Vector3D.Zero,
        Vector3D.UnitY);
    var expected = new Matrix(
        1.0f, 0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 0.0f, 0.0f,
        0.0f, 0.0f, 1.0f, 0.0f, 
        0.0f, 0.0f, -5.0f, 1.0f);
    Assert.IsTrue(createdLookAt.IsNearlyEqual(expected));
}
Copy to ClipboardPrint
[Test]
public void AccessViolation()
{
    float num = matrix[15];
    Assert.AreEqual(15, num);
    Assert.Throws<IndexOutOfRangeException>(delegate { num = matrix[17]; });
Copy to ClipboardPrint
[Test]
public void IdentityHasDeterminantOne()
{
    Assert.AreEqual(1, Matrix.Identity.GetDeterminant());
}
Copy to ClipboardPrint
[Test]
public void GetDeterminant()
{
    matrix = new Matrix(1, 0, 0, 0, 0, 1, 2, 1, 0, 2, 1, 3, 0, 2, 1, 1);
    Assert.AreEqual(6, matrix.GetDeterminant());
}
Copy to ClipboardPrint
[Test]
public void AreEqual()
{
    var matrix2 = new Matrix(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
    Assert.IsTrue(matrix == matrix2);
    Assert.IsTrue(matrix.Equals(matrix2));
    matrix2[5] = 20;
    Assert.IsTrue(matrix != matrix2);
    object pointAsObject = Vector2D.One;
    Assert.IsFalse(matrix.Equals(pointAsObject));
}
Copy to ClipboardPrint
[Test]
public void MultiplyVector()
{
    var vector = new Vector3D(-1, -2, -3);
    Assert.AreEqual(new Vector3D(-20, -25, -30), matrix * vector);
}
Copy to ClipboardPrint
[Test]
public void MatrixTimesIdentityIsUnchanged()
{
    Assert.AreEqual(matrix, matrix * Matrix.Identity);
    Assert.AreEqual(matrix, Matrix.Identity * matrix);
}
Copy to ClipboardPrint
[Test]
public void MultiplyMatrix()
{
    var matrix2 = new Matrix(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15,
        -16);
    var result = new Matrix(-62, -68, -74, -80, -174, -196, -218, -240, -286, -324, -362, -400,
        -398, -452, -506, -560);
    Assert.AreEqual(result, matrix * matrix2);
}
Copy to ClipboardPrint
[Test]
public void IsNotNearlyEqual()
{
    matrix = new Matrix(1, 0, 3, 0, 0, 2, 0, 4, 0, 3, 2, 0, 1, 0, 0, 2);
    Assert.IsFalse(matrix.IsNearlyEqual(Matrix.Identity));
}
Copy to ClipboardPrint
[Test]
public void WriteMatrix()
{
    const string MatrixString = "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15";
    Assert.AreEqual(MatrixString, matrix.ToString());
}
Copy to ClipboardPrint
[Test]
public void LoadFromString()
{
    const string MatrixString = "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15";
    var loadedMatrix = new Matrix(MatrixString);
    for (int i = 0; i < 16; i++)
        Assert.AreEqual(i, loadedMatrix.GetValues[i]);
}
Copy to ClipboardPrint
[Test]
public void CalculateHashCode()
{
    Assert.AreEqual(1069547520, matrix.GetHashCode());
    Assert.AreEqual(0, new Matrix().GetHashCode());
}
Copy to ClipboardPrint
[Test]
public void TransformPosition()
{
    var position = new Vector3D(3, 5, 2);
    var translation = Matrix.CreateTranslation(2, 0, 5);
    var rotation = Matrix.CreateRotationZYX(0, 90, 0);
    var scale = Matrix.CreateScale(3, 3, 3);
    var transformation = scale * rotation * translation;
    var result = translation * (rotation * (scale * position));
    Assert.IsTrue((transformation * position).IsNearlyEqual(result));
}
Copy to ClipboardPrint
[Test]
public void CreateFromAxisAngle()
{
    var invTwoSqr = MathExtensions.InvSqrt(2);
    var matrix2 = new Matrix(invTwoSqr, 0, -invTwoSqr, 0, 0, 1, 0, 0, invTwoSqr, 0, invTwoSqr, 
        0, 0, 0, 0, 1);
    var axis = new Vector3D(0, 1, 0);
    const float Angle = 45.0f;
    Assert.AreEqual(Matrix.Identity, Matrix.FromAxisAngle(axis, 0.0f));
    Assert.AreEqual(matrix2, Matrix.FromAxisAngle(axis, Angle));
}
Copy to ClipboardPrint
[Test]
public void CreateFrustrum()
{
    var matrixSimetric = new Matrix(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 1);
    Assert.AreEqual(matrixSimetric, Matrix.Frustum(-1, 1, -1, 1, 0, 100.0f));            
}
See Also
DeltaEngine.Tests.Datatypes Namespace