backup/anx.framework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity

Unit-Tests for Vector datatypes now fully implemented.

Browse Source
This commit is contained in:
SND\xToast_cp 2011-11-17 18:22:51 +00:00
parent a71dc9ae0f
commit f08e84341f
7 changed files with 627 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

100
ANX.Framework.TestCenter/AssertHelper.cs
View File

@ -459,10 +459,8 @@ namespace ANX.Framework.TestCenter
public static void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) ||
(CompareFloats(xna.X, anx.X, epsilon) &&
CompareFloats(xna.Y, anx.Y, epsilon)))
if (CompareFloats(xna.X, anx.X, epsilon) &&
CompareFloats(xna.Y, anx.Y, epsilon))
{
Assert.Pass(test + " passed");
}
@ -474,8 +472,8 @@ namespace ANX.Framework.TestCenter
public static void ConvertEquals(ANXVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(anx.X.ToString()) && anx.Y.ToString().Equals(anx.Y.ToString()))
if (CompareFloats(xna.X, anx.X, epsilon) &&
CompareFloats(xna.Y, anx.Y, epsilon))
{
Assert.Pass(test + " passed");
}
@ -485,13 +483,34 @@ namespace ANX.Framework.TestCenter
}
}
public static void ConvertEquals(XNAVector2[] xna, ANXVector2[] anx, String test)
{
bool result = true;
for (int i = 0; i < xna.Length; i++)
{
result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
CompareFloats(xna[i].Y, anx[i].Y, epsilon);
if (!result)
break;
}
if (result)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) && anx.Z.ToString().Equals(xna.Z.ToString()) ||
(CompareFloats(xna.X, anx.X, epsilon) &&
if (CompareFloats(xna.X, anx.X, epsilon) &&
CompareFloats(xna.Y, anx.Y, epsilon) &&
CompareFloats(xna.Z, anx.Z, epsilon)))
CompareFloats(xna.Z, anx.Z, epsilon))
{
Assert.Pass(test + " passed");
}
@ -501,14 +520,36 @@ namespace ANX.Framework.TestCenter
}
}
public static void ConvertEquals(XNAVector3[] xna, ANXVector3[] anx, String test)
{
bool result = true;
for (int i = 0; i < xna.Length; i++)
{
result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
CompareFloats(xna[i].Y, anx[i].Y, epsilon) &&
CompareFloats(xna[i].Z, anx[i].Z, epsilon);
if (!result)
break;
}
if (result)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNAVector4 xna, ANXVector4 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (anx.X.ToString().Equals(xna.X.ToString()) && anx.Y.ToString().Equals(xna.Y.ToString()) && anx.Z.ToString().Equals(xna.Z.ToString()) && anx.W.ToString().Equals(xna.W.ToString()) ||
(CompareFloats(xna.X, anx.X, epsilon) &&
if (CompareFloats(xna.X, anx.X, epsilon) &&
CompareFloats(xna.Y, anx.Y, epsilon) &&
CompareFloats(xna.Z, anx.Z, epsilon) &&
CompareFloats(xna.W, anx.W, epsilon)))
CompareFloats(xna.W, anx.W, epsilon))
{
Assert.Pass(test + " passed");
}
@ -518,6 +559,31 @@ namespace ANX.Framework.TestCenter
}
}
public static void ConvertEquals(XNAVector4[] xna, ANXVector4[] anx, String test)
{
bool result = true;
for (int i = 0; i < xna.Length; i++)
{
result = CompareFloats(xna[i].X, anx[i].X, epsilon) &&
CompareFloats(xna[i].Y, anx[i].Y, epsilon) &&
CompareFloats(xna[i].Z, anx[i].Z, epsilon) &&
CompareFloats(xna[i].Z, anx[i].W, epsilon);
if (!result)
break;
}
if (result)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
{
if (xna.Min.X == anx.Min.X &&
@ -552,8 +618,10 @@ namespace ANX.Framework.TestCenter
public static void ConvertEquals(XNARect xna, ANXRect anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.ToString().Equals(anx.ToString()))
if (xna.X == anx.X &&
xna.Y == anx.Y &&
xna.Width == anx.Width &&
xna.Height == anx.Height)
{
Assert.Pass(test + " passed");
}

190
ANX.Framework.TestCenter/Strukturen/Vector2Test.cs
View File

@ -12,6 +12,9 @@ using ANXVector2 = ANX.Framework.Vector2;
using XNAMatrix = Microsoft.Xna.Framework.Matrix;
using ANXMatrix = ANX.Framework.Matrix;
using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
using ANXQuaternion = ANX.Framework.Quaternion;
#endregion // Using Statements
#region License
@ -83,6 +86,15 @@ namespace ANX.Framework.TestCenter.Strukturen
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue }
};
static object[] twentytwoFloats =
{
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
};
#endregion
#region Test
@ -710,6 +722,184 @@ namespace ANX.Framework.TestCenter.Strukturen
AssertHelper.ConvertEquals(xnaR, anxR, "DivideOperatorVector2");
}
#endregion
#region Transformations
[Test, TestCaseSource("twentytwoFloats")]
public void TransformStaticMatrix(
float x, float y, float z,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44,
float nop0, float nop1, float nop2)
{
XNAVector2 xnaVector = new XNAVector2(x, y);
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2 anxVector = new ANXVector2(x, y);
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2 xna = XNAVector2.Transform(xnaVector, xnaMatrix);
ANXVector2 anx = ANXVector2.Transform(anxVector, anxMatrix);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformStaticQuaternion(
float x, float y, float z,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14)
{
XNAVector2 xnaVector = new XNAVector2(x, y);
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector2 anxVector = new ANXVector2(x, y);
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector2 xna = XNAVector2.Transform(xnaVector, xnaQuaternion);
ANXVector2 anx = ANXVector2.Transform(anxVector, anxQuaternion);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticMatrixToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, ref xnaMatrix, xna);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, ref anxMatrix, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticQuaternionToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, ref xnaQuaternion, xna);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, ref anxQuaternion, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticMatrixToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticQuaternionToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStatic(
float x, float y, float z,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44,
float nop0, float nop1, float nop2)
{
XNAVector2 xnaVector = new XNAVector2(x, y);
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2 anxVector = new ANXVector2(x, y);
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2 xna = XNAVector2.TransformNormal(xnaVector, xnaMatrix);
ANXVector2 anx = ANXVector2.TransformNormal(anxVector, anxMatrix);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStatic");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStaticToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, ref xnaMatrix, xna);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, ref anxMatrix, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStaticToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector2[] xnaVector = new XNAVector2[] { new XNAVector2(x1, y1), new XNAVector2(x2, y2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector2[] anxVector = new ANXVector2[] { new ANXVector2(x1, y1), new ANXVector2(x2, y2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector2[] xna = new XNAVector2[2];
XNAVector2.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
ANXVector2[] anx = new ANXVector2[2];
ANXVector2.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestinationWithIndex");
}
#endregion
#endregion

191
ANX.Framework.TestCenter/Strukturen/Vector3Test.cs
View File

@ -9,6 +9,10 @@ using XNAVector2 = Microsoft.Xna.Framework.Vector2;
using ANXVector2 = ANX.Framework.Vector2;
using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using XNAMatrix = Microsoft.Xna.Framework.Matrix;
using ANXMatrix = ANX.Framework.Matrix;
using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
using ANXQuaternion = ANX.Framework.Quaternion;
using NUnit.Framework;
@ -83,6 +87,15 @@ namespace ANX.Framework.TestCenter.Strukturen
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}
};
static object[] twentytwoFloats =
{
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
};
#endregion
#region Tests
@ -705,6 +718,184 @@ namespace ANX.Framework.TestCenter.Strukturen
AssertHelper.ConvertEquals(xnaR, anxR, "DivideOperatorVector3");
}
#endregion
#region Transformations
[Test, TestCaseSource("twentytwoFloats")]
public void TransformStaticMatrix(
float x, float y, float z,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44,
float nop0, float nop1, float nop2)
{
XNAVector3 xnaVector = new XNAVector3(x, y, z);
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3 anxVector = new ANXVector3(x, y, z);
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3 xna = XNAVector3.Transform(xnaVector, xnaMatrix);
ANXVector3 anx = ANXVector3.Transform(anxVector, anxMatrix);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformStaticQuaternion(
float x, float y, float z,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14)
{
XNAVector3 xnaVector = new XNAVector3(x, y, z);
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector3 anxVector = new ANXVector3(x, y, z);
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector3 xna = XNAVector3.Transform(xnaVector, xnaQuaternion);
ANXVector3 anx = ANXVector3.Transform(anxVector, anxQuaternion);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticMatrixToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, ref xnaMatrix, xna);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, ref anxMatrix, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticQuaternionToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, ref xnaQuaternion, xna);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, ref anxQuaternion, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticMatrixToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
}
[Test, TestCaseSource("twentytwoFloats")]
public static void TransformStaticQuaternionToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStatic(
float x, float y, float z,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44,
float nop0, float nop1, float nop2)
{
XNAVector3 xnaVector = new XNAVector3(x, y, z);
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3 anxVector = new ANXVector3(x, y, z);
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3 xna = XNAVector3.TransformNormal(xnaVector, xnaMatrix);
ANXVector3 anx = ANXVector3.TransformNormal(anxVector, anxMatrix);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStatic");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStaticToDestination(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, ref xnaMatrix, xna);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, ref anxMatrix, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestination");
}
[Test, TestCaseSource("twentytwoFloats")]
public void TransformNormalStaticToDestinationWithIndex(
float x1, float y1, float z1,
float x2, float y2, float z2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector3[] xnaVector = new XNAVector3[] { new XNAVector3(x1, y1, z1), new XNAVector3(x2, y2, z2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector3[] anxVector = new ANXVector3[] { new ANXVector3(x1, y1, z1), new ANXVector3(x2, y2, z2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector3[] xna = new XNAVector3[2];
XNAVector3.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
ANXVector3[] anx = new ANXVector3[2];
ANXVector3.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformNormalStaticToDestinationWithIndex");
}
#endregion
#endregion

132
ANX.Framework.TestCenter/Strukturen/Vector4Test.cs
View File

@ -11,6 +11,10 @@ using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using XNAVector4 = Microsoft.Xna.Framework.Vector4;
using ANXVector4 = ANX.Framework.Vector4;
using XNAMatrix = Microsoft.Xna.Framework.Matrix;
using ANXMatrix = ANX.Framework.Matrix;
using XNAQuaternion = Microsoft.Xna.Framework.Quaternion;
using ANXQuaternion = ANX.Framework.Quaternion;
using NUnit.Framework;
@ -88,6 +92,14 @@ namespace ANX.Framework.TestCenter.Strukturen
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue}
};
static object[] twentyfourFloats =
{
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
new object[] {DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue,DataFactory.RandomValue},
};
#endregion
#region Tests
@ -664,6 +676,126 @@ namespace ANX.Framework.TestCenter.Strukturen
}
#endregion
#region Transformations
[Test, TestCaseSource("twentyfourFloats")]
public void TransformStaticMatrix(
float x, float y, float z, float w,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44,
float nop0, float nop1, float nop2, float nop3)
{
XNAVector4 xnaVector = new XNAVector4(x, y, z, w);
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector4 anxVector = new ANXVector4(x, y, z, w);
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector4 xna = XNAVector4.Transform(xnaVector, xnaMatrix);
ANXVector4 anx = ANXVector4.Transform(anxVector, anxMatrix);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrix");
}
[Test, TestCaseSource("twentyfourFloats")]
public void TransformStaticQuaternion(
float x, float y, float z, float w,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12, float nop13, float nop14, float nop15)
{
XNAVector4 xnaVector = new XNAVector4(x, y, z, w);
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector4 anxVector = new ANXVector4(x, y, z, w);
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector4 xna = XNAVector4.Transform(xnaVector, xnaQuaternion);
ANXVector4 anx = ANXVector4.Transform(anxVector, anxQuaternion);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternion");
}
[Test, TestCaseSource("twentyfourFloats")]
public static void TransformStaticMatrixToDestination(
float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector4[] xna = new XNAVector4[2];
XNAVector4.Transform(xnaVector, ref xnaMatrix, xna);
ANXVector4[] anx = new ANXVector4[2];
ANXVector4.Transform(anxVector, ref anxMatrix, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestination");
}
[Test, TestCaseSource("twentyfourFloats")]
public static void TransformStaticQuaternionToDestination(
float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector4[] xna = new XNAVector4[2];
XNAVector4.Transform(xnaVector, ref xnaQuaternion, xna);
ANXVector4[] anx = new ANXVector4[2];
ANXVector4.Transform(anxVector, ref anxQuaternion, anx);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestination");
}
[Test, TestCaseSource("twentyfourFloats")]
public static void TransformStaticMatrixToDestinationWithIndex(
float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2,
float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)
{
XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
XNAMatrix xnaMatrix = new XNAMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
ANXMatrix anxMatrix = new ANXMatrix(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
XNAVector4[] xna = new XNAVector4[2];
XNAVector4.Transform(xnaVector, 1, ref xnaMatrix, xna, 1, 1);
ANXVector4[] anx = new ANXVector4[2];
ANXVector4.Transform(anxVector, 1, ref anxMatrix, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticMatrixToDestinationWithIndex");
}
[Test, TestCaseSource("twentyfourFloats")]
public static void TransformStaticQuaternionToDestinationWithIndex(
float x1, float y1, float z1, float w1,
float x2, float y2, float z2, float w2,
float xQ, float yQ, float zQ, float wQ,
float nop0, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11)
{
XNAVector4[] xnaVector = new XNAVector4[] { new XNAVector4(x1, y1, z1, w1), new XNAVector4(x2, y2, z2, w2) };
XNAQuaternion xnaQuaternion = new XNAQuaternion(xQ, yQ, zQ, wQ);
ANXVector4[] anxVector = new ANXVector4[] { new ANXVector4(x1, y1, z1, w1), new ANXVector4(x2, y2, z2, w2) };
ANXQuaternion anxQuaternion = new ANXQuaternion(xQ, yQ, zQ, wQ);
XNAVector4[] xna = new XNAVector4[2];
XNAVector4.Transform(xnaVector, 1, ref xnaQuaternion, xna, 1, 1);
ANXVector4[] anx = new ANXVector4[2];
ANXVector4.Transform(anxVector, 1, ref anxQuaternion, anx, 1, 1);
AssertHelper.ConvertEquals(xna, anx, "TransformStaticQuaternionToDestinationWithIndex");
}
#endregion
#endregion
//TODO: transform operations

11
ANX.Framework/Matrix.cs
View File

@ -1191,7 +1191,16 @@ namespace ANX.Framework
public bool Decompose(out Vector3 scale, out Quaternion rotation, out Vector3 translation)
{
throw new NotImplementedException();
scale = new Vector3(this.M11, this.M22, this.M33);
Quaternion.CreateFromRotationMatrix(ref this, out rotation);
translation = new Vector3(this.M41, this.M42, this.M43);
if (scale != Vector3.Zero &&
rotation != Quaternion.Identity &&
translation != Vector3.Zero)
return true;
else
return false;
}
public float Determinant()

15
ANX.Framework/Quaternion.cs
View File

@ -261,14 +261,18 @@ namespace ANX.Framework
public static void Divide(ref Quaternion quaternion1, ref float divider, out Quaternion result)
{
result = Quaternion.Multiply(quaternion1, 1.0f / divider);
divider = 1f / divider;
result.X = quaternion1.X * divider;
result.Y = quaternion1.Y * divider;
result.Z = quaternion1.Z * divider;
result.W = quaternion1.W * divider;
}
public static float Dot(Quaternion quaternion1, Quaternion quaternion2)
{
return (quaternion1.X * quaternion2.X +
quaternion1.Y * quaternion2.Y +
quaternion1.Z * quaternion2.Z +
quaternion1.W * quaternion2.W);
float result;
Quaternion.Dot(ref quaternion1, ref quaternion2, out result);
return result;
}
public static void Dot(ref Quaternion quaternion1, ref Quaternion quaternion2, out float result)
@ -367,7 +371,6 @@ namespace ANX.Framework
result.Y = quaternion1.Y * scaleFactor;
result.Z = quaternion1.Z * scaleFactor;
result.W = quaternion1.W * scaleFactor;
}
public static Quaternion Negate(Quaternion quaternion)

14
ANX.Framework/Vector2.cs
View File

@ -428,8 +428,9 @@ namespace ANX.Framework
public static Vector2 Transform(Vector2 position, Matrix matrix)
{
return new Vector2(((position.X * matrix.M11) + (position.Y * matrix.M21)) + matrix.M41,
((position.X * matrix.M12) + (position.Y * matrix.M22)) + matrix.M42);
Vector2 result;
Transform(ref position, ref matrix, out result);
return result;
}
public static void Transform(ref Vector2 position, ref Matrix matrix, out Vector2 result)
@ -440,24 +441,31 @@ namespace ANX.Framework
public static Vector2 Transform(Vector2 value, Quaternion rotation)
{
throw new NotImplementedException();
Vector2 result;
Transform(ref value, ref rotation, out result);
return result;
}
public static void Transform(ref Vector2 value, ref Quaternion rotation, out Vector2 result)
{
throw new NotImplementedException();
}
public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Matrix matrix, Vector2[] destinationArray, int destinationIndex, int length)
{
throw new NotImplementedException();
}
public static void Transform(Vector2[] sourceArray, int sourceIndex, ref Quaternion rotation, Vector2[] destinationArray, int destinationIndex, int length)
{
throw new NotImplementedException();
}
public static void Transform(Vector2[] sourceArray, ref Matrix matrix, Vector2[] destinationArray)
{
throw new NotImplementedException();
}
public static void Transform(Vector2[] sourceArray, ref Quaternion rotation, Vector2[] destinationArray)
{
throw new NotImplementedException();