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

Vector3: fixed a minor issue with divide by factor

Browse Source 
Color: fixed some issues and implemented some missing methods
TestCenter: refactoring (moved all ConvertEquals-Methods to the new AssertHelper)
DataFactory: extended by normalized random floats
TestCenter: all Color tests are green now
This commit is contained in:
Glatzemann 2011-11-04 06:46:24 +00:00
parent 3e6d9b001e
commit 7423fd4532
13 changed files with 498 additions and 398 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ANX.Framework.TestCenter/ANX.Framework.TestCenter.csproj
View File

@ -49,6 +49,7 @@
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="AssertHelper.cs" />
<Compile Include="ContentPipeline\Helper\SharedResource.cs" />
<Compile Include="ContentPipeline\MathTypesTests.cs" />
<Compile Include="ContentPipeline\Helper\Compiler.cs" />
@ -59,7 +60,6 @@
<Compile Include="IntegrationTest.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Strukturen\BoundingBoxTest.cs" />
<Compile Include="Strukturen\BoundingFrustumTest.cs" />
<Compile Include="Strukturen\BoundingSphereTest.cs" />
<Compile Include="Strukturen\ColorTest.cs" />
<Compile Include="Strukturen\MatrixTest.cs" />

207
ANX.Framework.TestCenter/AssertHelper.cs Normal file
View File

@ -0,0 +1,207 @@
#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
#endregion // Using Statements
#region License
//
// This file is part of the ANX.Framework created by the "ANX.Framework developer group".
//
// This file is released under the Ms-PL license.
//
//
//
// Microsoft Public License (Ms-PL)
//
// This license governs use of the accompanying software. If you use the software, you accept this license.
// If you do not accept the license, do not use the software.
//
// 1.Definitions
// The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning
// here as under U.S. copyright law.
// A "contribution" is the original software, or any additions or changes to the software.
// A "contributor" is any person that distributes its contribution under this license.
// "Licensed patents" are a contributor's patent claims that read directly on its contribution.
//
// 2.Grant of Rights
// (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations
// in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to
// reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution
// or any derivative works that you create.
// (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in
// section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed
// patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution
// in the software or derivative works of the contribution in the software.
//
// 3.Conditions and Limitations
// (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
// (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your
// patent license from such contributor to the software ends automatically.
// (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution
// notices that are present in the software.
// (D) If you distribute any portion of the software in source code form, you may do so only under this license by including
// a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or
// object code form, you may only do so under a license that complies with this license.
// (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees,
// or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the
// extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a
// particular purpose and non-infringement.
#endregion // License
using XNAColor = Microsoft.Xna.Framework.Color;
using ANXColor = ANX.Framework.Color;
using XNAVector2 = Microsoft.Xna.Framework.Vector2;
using ANXVector2 = ANX.Framework.Vector2;
using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using XNAVector4 = Microsoft.Xna.Framework.Vector4;
using ANXVector4 = ANX.Framework.Vector4;
using XNABoundingBox = Microsoft.Xna.Framework.BoundingBox;
using ANXBoundingBox = ANX.Framework.BoundingBox;
using XNABoundingSphere = Microsoft.Xna.Framework.BoundingSphere;
using ANXBoundingSphere = ANX.Framework.BoundingSphere;
using XNARect = Microsoft.Xna.Framework.Rectangle;
using ANXRect = ANX.Framework.Rectangle;
namespace ANX.Framework.TestCenter
{
class AssertHelper
{
public static void ConvertEquals(byte a, byte b, String test)
{
if (a == b)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: byte a: ({1}) byte b: ({2})", test, a, b));
}
}
public static void ConvertEquals(XNAColor xna, ANXColor anx, String test)
{
if (xna.R == anx.R &&
xna.G == anx.G &&
xna.B == anx.B &&
xna.A == anx.A)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
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 (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
}
}
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()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
}
}
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 ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1},{2},{3}) anx({4},{5},{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
}
}
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 ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z) && (xna.W == anx.W))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1},{2},{3},{4}) anx({5},{6},{7},{8})", test, xna.X, xna.Y, xna.Z, xna.W, anx.X, anx.Y, anx.Z, anx.W));
}
}
public static void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
{
if (xna.Min.X == anx.Min.X &&
xna.Min.Y == anx.Min.Y &&
xna.Min.Z == anx.Min.Z &&
xna.Max.X == anx.Max.X &&
xna.Max.Y == anx.Max.Y &&
xna.Max.Z == anx.Max.Z)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
public static void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
{
if (xna.Center.X == anx.Center.X &&
xna.Center.Y == anx.Center.Y &&
xna.Center.Z == anx.Center.Z &&
xna.Radius == anx.Radius)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
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()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
}
}
}
}

8
ANX.Framework.TestCenter/DataFactory.cs
View File

@ -76,6 +76,14 @@ namespace ANX.Framework.TestCenter
return result;
}
public static float RandomNormalizedFloat
{
get
{
return 1.0f / MathHelper.Clamp(RandomFloat, 0f, float.MaxValue);
}
}
public static float RandomFloat
{
get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }

93
ANX.Framework.TestCenter/Strukturen/BoundingBoxTest.cs
View File

@ -65,79 +65,56 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingBoxTest
{
#region Helper
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] sixfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] ninefloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] tenfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twelvefloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twentytwofloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
private void ConvertEquals(XNABoundingBox xna, ANXBoundingBox anx, String test)
{
if (xna.Min.X == anx.Min.X &&
xna.Min.Y == anx.Min.Y &&
xna.Min.Z == anx.Min.Z &&
xna.Max.X == anx.Max.X &&
xna.Max.Y == anx.Max.Y &&
xna.Max.Z == anx.Max.Z)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#endregion
#region Constructors
@ -148,7 +125,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox();
ConvertEquals(xna, anx, "constructor0");
AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("sixfloat")]
@ -158,7 +135,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingBox anx = new ANXBoundingBox(new ANXVector3(xMin, yMin, zMin), new ANXVector3(xMax, yMax, zMax));
ConvertEquals(xna, anx, "constructor0");
AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
#endregion
@ -259,7 +236,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromPoints(pointsXNA);
ANXBoundingBox anx = ANXBoundingBox.CreateFromPoints(pointsANX);
ConvertEquals(xna, anx, "CreateFromPointsStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
}
[Test, TestCaseSource("ninefloat")]
@ -276,7 +253,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateFromSphere(xnaSphere);
ANXBoundingBox anx = ANXBoundingBox.CreateFromSphere(anxSphere);
ConvertEquals(xna, anx, "CreateFromSphereStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateFromSphereStatic");
}
[Test, TestCaseSource("twelvefloat")]
@ -293,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingBox xna = XNABoundingBox.CreateMerged(xnaBox1, xnaBox2);
ANXBoundingBox anx = ANXBoundingBox.CreateMerged(anxBox1, anxBox2);
ConvertEquals(xna, anx, "CreateMergedStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
}
[Test, TestCaseSource("sixfloat")]

85
ANX.Framework.TestCenter/Strukturen/BoundingSphereTest.cs
View File

@ -65,68 +65,47 @@ namespace ANX.Framework.TestCenter.Strukturen
class BoundingSphereTest
{
#region Helper
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] fourfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] eightfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] tenfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
static object[] twentyfloat =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat,
RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat,
DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
};
private void ConvertEquals(XNABoundingSphere xna, ANXBoundingSphere anx, String test)
{
if (xna.Center.X == anx.Center.X &&
xna.Center.Y == anx.Center.Y &&
xna.Center.Z == anx.Center.Z &&
xna.Radius == anx.Radius)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#endregion
#region Constructors
@ -137,7 +116,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere();
ConvertEquals(xna, anx, "constructor0");
AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("fourfloat")]
@ -147,7 +126,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXBoundingSphere anx = new ANXBoundingSphere(new ANXVector3(x, y, z), r);
ConvertEquals(xna, anx, "constructor0");
AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
#endregion
@ -245,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromBoundingBox(xnaBox);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromBoundingBox(anxBox);
ConvertEquals(xna, anx, "CreateFromBoundingBox");
AssertHelper.ConvertEquals(xna, anx, "CreateFromBoundingBox");
}
[Test, TestCaseSource("twentyfloat")]
@ -261,7 +240,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromFrustum(xnaFrustum);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromFrustum(anxFrustum);
ConvertEquals(xna, anx, "CreateFromFrustumStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateFromFrustumStatic");
}
[Test, TestCaseSource("tenfloat")]
@ -284,7 +263,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateFromPoints(pointsXNA);
ANXBoundingSphere anx = ANXBoundingSphere.CreateFromPoints(pointsANX);
ConvertEquals(xna, anx, "CreateFromPointsStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateFromPointsStatic");
}
[Test, TestCaseSource("tenfloat")]
@ -302,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNABoundingSphere xna = XNABoundingSphere.CreateMerged(xnaSphere1, xnaSphere2);
ANXBoundingSphere anx = ANXBoundingSphere.CreateMerged(anxSphere1, anxSphere2);
ConvertEquals(xna, anx, "CreateMergedStatic");
AssertHelper.ConvertEquals(xna, anx, "CreateMergedStatic");
}
[Test, TestCaseSource("tenfloat")]
@ -417,7 +396,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaSphere.Transform(xnaMatrix);
anxSphere.Transform(anxMatrix);
ConvertEquals(xnaSphere, anxSphere, "Transform");
AssertHelper.ConvertEquals(xnaSphere, anxSphere, "Transform");
}
#endregion

150
ANX.Framework.TestCenter/Strukturen/ColorTest.cs
View File

@ -56,6 +56,9 @@ using System.Text;
using XNAColor = Microsoft.Xna.Framework.Color;
using ANXColor = ANX.Framework.Color;
using XNAVector3 = Microsoft.Xna.Framework.Vector3;
using ANXVector3 = ANX.Framework.Vector3;
using NUnit.Framework;
namespace ANX.Framework.TestCenter.Strukturen
@ -63,55 +66,33 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class ColorTest
{
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble()); }
}
static object[] fourfloats =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat }
new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat },
new object[] { DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat, DataFactory.RandomNormalizedFloat }
};
static object[] eightfloats =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
static object[] ninefloats =
{
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat },
new object[] { RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat, RandomFloat }
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
private void ConvertEquals(XNAColor xna, ANXColor anx, String test)
{
if (xna.R == anx.R &&
xna.G == anx.G &&
xna.B == anx.B &&
xna.A == anx.A)
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(String.Format("{0} failed: xna({1}) anx({2})", test, xna.ToString(), anx.ToString()));
}
}
#region Constructors
[Test]
public void constructor0()
@ -119,7 +100,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor();
ANXColor anx = new ANXColor();
ConvertEquals(xna, anx, "constructor0");
AssertHelper.ConvertEquals(xna, anx, "constructor0");
}
[Test, TestCaseSource("fourfloats")]
@ -128,7 +109,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector3(r, g, b));
ANXColor anx = new ANXColor(new ANX.Framework.Vector3(r, g, b));
ConvertEquals(xna, anx, "constructor1");
AssertHelper.ConvertEquals(xna, anx, "constructor1");
}
[Test, TestCaseSource("fourfloats")]
@ -137,7 +118,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(new Microsoft.Xna.Framework.Vector4(r, g, b, a));
ANXColor anx = new ANXColor(new ANX.Framework.Vector4(r, g, b, a));
ConvertEquals(xna, anx, "constructor2");
AssertHelper.ConvertEquals(xna, anx, "constructor2");
}
[Test, TestCaseSource("fourfloats")]
@ -146,7 +127,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b);
ANXColor anx = new ANXColor(r, g, b);
ConvertEquals(xna, anx, "constructor3");
AssertHelper.ConvertEquals(xna, anx, "constructor3");
}
[Test, TestCaseSource("fourfloats")]
@ -155,7 +136,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255));
ConvertEquals(xna, anx, "constructor4");
AssertHelper.ConvertEquals(xna, anx, "constructor4");
}
[Test, TestCaseSource("fourfloats")]
@ -164,7 +145,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor(r, g, b) * a;
ANXColor anx = new ANXColor(r, g, b) * a;
ConvertEquals(xna, anx, "constructor5");
AssertHelper.ConvertEquals(xna, anx, "constructor5");
}
[Test, TestCaseSource("fourfloats")]
@ -173,7 +154,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = new XNAColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ANXColor anx = new ANXColor((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ConvertEquals(xna, anx, "constructor6");
AssertHelper.ConvertEquals(xna, anx, "constructor6");
}
#endregion
@ -233,7 +214,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied((int)(r * 255), (int)(g * 255), (int)(b * 255), (int)(a * 255));
ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic");
AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedIntStatic");
}
[Test, TestCaseSource("fourfloats")]
@ -243,7 +224,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anx = ANXColor.FromNonPremultiplied(new ANX.Framework.Vector4(r, g, b, a));
ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static");
AssertHelper.ConvertEquals(xna, anx, "FromNonPremultipliedVector4Static");
}
[Test, TestCaseSource("ninefloats")]
@ -251,6 +232,8 @@ namespace ANX.Framework.TestCenter.Strukturen
float r1, float g1, float b1, float a1,
float r2, float g2, float b2, float a2, float amount)
{
amount = MathHelper.Clamp(amount, 0, 1);
XNAColor xna1 = new XNAColor(r1, g1, b1) * a1;
XNAColor xna2 = new XNAColor(r2, g2, b2) * a2;
@ -260,7 +243,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor xna = XNAColor.Lerp(xna1, xna2, amount);
ANXColor anx = ANXColor.Lerp(anx1, anx2, amount);
ConvertEquals(xna, anx, "LerpStatic");
AssertHelper.ConvertEquals(xna, anx, "LerpStatic");
}
[Test, TestCaseSource("eightfloats")]
@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAColor.Multiply(xna, scale);
ANXColor.Multiply(anx, scale);
ConvertEquals(xna, anx, "MultiplyStatic");
AssertHelper.ConvertEquals(xna, anx, "MultiplyStatic");
}
[Test, TestCaseSource("eightfloats")]
@ -286,7 +269,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna *= scale;
anx *= scale;
ConvertEquals(xna, anx, "MultiplyOperator");
AssertHelper.ConvertEquals(xna, anx, "MultiplyOperator");
}
[Test, TestCaseSource("fourfloats")]
@ -299,14 +282,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector3 xna = xnaColor.ToVector3();
ANX.Framework.Vector3 anx = anxColor.ToVector3();
if (xna.Equals(anx))
{
Assert.Pass("ToVector3 passed");
}
else
{
Assert.Fail(String.Format("ToVector3 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
AssertHelper.ConvertEquals(xna, anx, "ToVector3");
}
[Test, TestCaseSource("fourfloats")]
@ -319,14 +295,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Microsoft.Xna.Framework.Vector4 xna = xnaColor.ToVector4();
ANX.Framework.Vector4 anx = anxColor.ToVector4();
if (xna.Equals(anx))
{
Assert.Pass("ToVector4 passed");
}
else
{
Assert.Fail(String.Format("ToVector4 failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
AssertHelper.ConvertEquals(xna, anx, "ToVector4");
}
#endregion // Methods
@ -360,17 +329,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.R;
byte anx = anxColor.R;
if (xna.Equals(anx))
{
Assert.Pass("R passed");
}
else
{
Assert.Fail(String.Format("R failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
AssertHelper.ConvertEquals(xnaColor.R, anxColor.R, "R");
}
[Test, TestCaseSource("fourfloats")]
@ -380,17 +339,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.G;
byte anx = anxColor.G;
if (xna.Equals(anx))
{
Assert.Pass("G passed");
}
else
{
Assert.Fail(String.Format("G failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
AssertHelper.ConvertEquals(xnaColor.G, anxColor.G, "G");
}
[Test, TestCaseSource("fourfloats")]
@ -400,17 +349,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.B;
byte anx = anxColor.B;
if (xna.Equals(anx))
{
Assert.Pass("B passed");
}
else
{
Assert.Fail(String.Format("B failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
AssertHelper.ConvertEquals(xnaColor.B, anxColor.B, "B");
}
[Test, TestCaseSource("fourfloats")]
@ -420,18 +359,9 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXColor anxColor = new ANXColor(r, g, b) * a;
byte xna = xnaColor.A;
byte anx = anxColor.A;
if (xna.Equals(anx))
{
Assert.Pass("A passed");
}
else
{
Assert.Fail(String.Format("A failed: xna({0}) anx({1})", xna.ToString(), anx.ToString()));
}
#endregion
AssertHelper.ConvertEquals(xnaColor.A, anxColor.A, "A");
}
#endregion
}
}

27
ANX.Framework.TestCenter/Strukturen/MatrixTest.cs
View File

@ -94,30 +94,13 @@ namespace ANX.Framework.TestCenter.Strukturen
#endregion
#region Testdata
private static Random r = new Random();
public static float RandomFloat
{
get { return (float)(r.NextDouble() * (float.MaxValue - 1) - r.NextDouble() * (float.MinValue + 1)); }
}
public static int RandomBitPlus
{
get { return r.Next(3) - 1; }
}
public static float randomValue
{
get { return r.Next(1000) * RandomBitPlus; }
}
static object[] sixteenfloats =
{
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
new object[] { MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue, MatrixTest.randomValue },
new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat , DataFactory.RandomFloat },
};
#endregion

29
ANX.Framework.TestCenter/Strukturen/RectangleTest.cs
View File

@ -63,23 +63,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class RectangleTest
{
#region Helper
public 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()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}{" + xna.Width + "}{" + xna.Height + "}) anx({" + anx.X + "}{" + anx.Y + "}{" + anx.Width + "}{" + anx.Height + "})");
}
}
#endregion
static object[] ninefloats =
{
@ -131,7 +114,7 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void Empty()
{
ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty");
AssertHelper.ConvertEquals(XNARect.Empty, ANXRect.Empty, "Empty");
}
@ -209,7 +192,7 @@ namespace ANX.Framework.TestCenter.Strukturen
{
XNARect xna = new XNARect(x1, y1, w1, h1);
ANXRect anx = new ANXRect(x1, y1, w1, h1);
ConvertEquals(xna, anx, "Constructor");
AssertHelper.ConvertEquals(xna, anx, "Constructor");
}
#endregion
@ -262,7 +245,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Inflate(x2, y2);
anx.Inflate(x2, y2);
ConvertEquals(xna, anx, "Inflate");
AssertHelper.ConvertEquals(xna, anx, "Inflate");
}
[Test, TestCaseSource("ninefloats6")]
@ -285,7 +268,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xna.Offset(x2, y2);
anx.Offset(x2, y2);
ConvertEquals(xna, anx, "Offset");
AssertHelper.ConvertEquals(xna, anx, "Offset");
}
@ -298,7 +281,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection");
AssertHelper.ConvertEquals(XNARect.Intersect(xna, xna2), ANXRect.Intersect(anx, anx2), "Intersection");
}
@ -310,7 +293,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNARect xna2 = new XNARect(x2, y2, w2, h2);
ANXRect anx2 = new ANXRect(x2, y2, w2, h2);
ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union");
AssertHelper.ConvertEquals(XNARect.Union(xna, xna2), ANXRect.Union(anx, anx2), "Union");
}

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

@ -66,35 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class Vector2Test
{
#region Helper
public void ConvertEquals(XNAVector2 xna, ANXVector2 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if (xna.X.ToString().Equals(anx.X.ToString()) && xna.Y.ToString().Equals(anx.Y.ToString()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: xna({" + xna.X + "}{" + xna.Y + "}) anx({" + anx.X + "}{" + anx.Y + "})");
}
}
public 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()))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(test + " failed: anx({" + xna.X + "}{" + xna.Y + "}) compared to anx({" + anx.X + "}{" + anx.Y + "})");
}
}
#endregion
#region Testdata
static object[] ninefloats =
@ -121,27 +92,25 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void One()
{
ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
AssertHelper.ConvertEquals(XNAVector2.One, ANXVector2.One, "One");
}
[Test]
public void UnitX()
{
ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX");
AssertHelper.ConvertEquals(XNAVector2.UnitX, ANXVector2.UnitX, "UnitX");
}
[Test]
public void UnitY()
{
ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY");
AssertHelper.ConvertEquals(XNAVector2.UnitY, ANXVector2.UnitY, "UnitY");
}
[Test]
public void Zero()
{
ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero");
AssertHelper.ConvertEquals(XNAVector2.Zero, ANXVector2.Zero, "Zero");
}
#endregion
@ -155,8 +124,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x);
ConvertEquals(xnaR, anxR, "Constructor1");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
}
[Test, TestCaseSource("ninefloats")]
@ -166,7 +134,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxR = new ANXVector2(x, y);
ConvertEquals(xnaR, anxR, "Constructor2");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
}
#endregion
@ -185,7 +153,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Add(xna1, xna2);
ANXVector2 anxR = ANXVector2.Add(anx1, anx2);
ConvertEquals(xnaR, anxR, "Add");
AssertHelper.ConvertEquals(xnaR, anxR, "Add");
}
[Test, TestCaseSource("ninefloats")]
@ -204,7 +172,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector2 anxR = ANXVector2.Barycentric(anx1, anx2, anx3, amount1, amount2);
ConvertEquals(xnaR, anxR, "Barycentric");
AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
}
[Test, TestCaseSource("ninefloats")]
@ -223,7 +191,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.CatmullRom(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "CatmullRom");
AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
}
[Test, TestCaseSource("ninefloats")]
@ -242,7 +210,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Clamp(xna1, xna2, xna3);
ANXVector2 anxR = ANXVector2.Clamp(anx1, anx2, anx3);
ConvertEquals(xnaR, anxR, "Clamp");
AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
}
[Test, TestCaseSource("ninefloats")]
@ -287,7 +255,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, divider);
ANXVector2 anxR = ANXVector2.Divide(anx1, divider);
ConvertEquals(xnaR, anxR, "DivideVectorDivider");
AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
}
[Test, TestCaseSource("ninefloats")]
@ -302,7 +270,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Divide(xna1, xna2);
ANXVector2 anxR = ANXVector2.Divide(anx1, anx2);
ConvertEquals(xnaR, anxR, "DivideVectorVector");
AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
}
[Test, TestCaseSource("ninefloats")]
@ -351,7 +319,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector2 anxR = ANXVector2.Hermite(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "Hermite");
AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
}
[Test, TestCaseSource("ninefloats")]
@ -382,7 +350,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Lerp(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.Lerp(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "Lerp");
AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
}
[Test, TestCaseSource("ninefloats")]
@ -397,7 +365,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Max(xna1, xna2);
ANXVector2 anxR = ANXVector2.Max(anx1, anx2);
ConvertEquals(xnaR, anxR, "Max");
AssertHelper.ConvertEquals(xnaR, anxR, "Max");
}
@ -413,7 +381,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Min(xna1, xna2);
ANXVector2 anxR = ANXVector2.Min(anx1, anx2);
ConvertEquals(xnaR, anxR, "Min");
AssertHelper.ConvertEquals(xnaR, anxR, "Min");
}
[Test, TestCaseSource("ninefloats")]
@ -426,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, scale);
ANXVector2 anxR = ANXVector2.Multiply(anx1, scale);
ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
}
[Test, TestCaseSource("ninefloats")]
@ -441,7 +409,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Multiply(xna1, xna2);
ANXVector2 anxR = ANXVector2.Multiply(anx1, anx2);
ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
}
[Test, TestCaseSource("ninefloats")]
@ -454,7 +422,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Negate(xna1);
ANXVector2 anxR = ANXVector2.Negate(anx1);
ConvertEquals(xnaR, anxR, "Negate");
AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
}
[Test, TestCaseSource("ninefloats")]
@ -467,7 +435,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize();
anxR.Normalize();
ConvertEquals(xnaR, anxR, "NormalizeInstanz");
AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
}
[Test, TestCaseSource("ninefloats")]
@ -480,7 +448,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Normalize(xna1);
ANXVector2 anxR = ANXVector2.Normalize(anx1);
ConvertEquals(xnaR, anxR, "NormalizeStatic");
AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
}
[Test, TestCaseSource("ninefloats")]
@ -495,7 +463,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Reflect(xna1, xna2);
ANXVector2 anxR = ANXVector2.Reflect(anx1, anx2);
ConvertEquals(xnaR, anxR, "Reflect");
AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
}
[Test, TestCaseSource("ninefloats")]
@ -510,7 +478,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.SmoothStep(xna1, xna2, amount);
ANXVector2 anxR = ANXVector2.SmoothStep(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "SmoothStep");
AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
}
[Test, TestCaseSource("ninefloats")]
@ -525,7 +493,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2 xnaR = XNAVector2.Subtract(xna1, xna2);
ANXVector2 anxR = ANXVector2.Subtract(anx1, anx2);
ConvertEquals(xnaR, anxR, "Subtract");
AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
}
[Test, TestCaseSource("ninefloats")]
@ -555,7 +523,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector2.Transform(ref xna1, ref xnaMatrix, out xnaResult);
ANXVector2.Transform(ref anx1, ref anxMatrix, out anxResult);
ConvertEquals(xnaResult, anxResult, "StaticTransform");
AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform");
}
[Test, TestCaseSource("ninefloats")]
@ -569,7 +537,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXMatrix anxMatrix = ANXMatrix.CreateRotationX(nop1) * ANXMatrix.CreateRotationY(nop2) * ANXMatrix.CreateRotationZ(nop3) * ANXMatrix.CreateTranslation(nop4, nop5, nop1);
ANXVector2 anxResult = ANXVector2.Transform(anx1, anxMatrix);
ConvertEquals(xnaResult, anxResult, "StaticTransform2");
AssertHelper.ConvertEquals(xnaResult, anxResult, "StaticTransform2");
}
[Test, TestCaseSource("ninefloats")]
@ -583,7 +551,7 @@ namespace ANX.Framework.TestCenter.Strukturen
Vector2.Transform(ref anx1, ref anxMatrix, out anxResult2);
ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly");
AssertHelper.ConvertEquals(anxResult1, anxResult2, "StaticTransform3_ANXonly");
}
/*

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

@ -66,23 +66,6 @@ namespace ANX.Framework.TestCenter.Strukturen
[TestFixture]
class Vector3Test
{
#region Helper
public void ConvertEquals(XNAVector3 xna, ANXVector3 anx, String test)
{
//comparing string to catch "not defined" and "infinity" (which seems not to be equal)
if ((xna.X == anx.X) && (xna.Y == anx.Y) && (xna.Z == anx.Z))
{
Assert.Pass(test + " passed");
}
else
{
Assert.Fail(string.Format("{0} failed: xna({1}{2}{3}) anx({4}{5}{6})", test, xna.X, xna.Y, xna.Z, anx.X, anx.Y, anx.Z));
}
}
#endregion
#region Testdata
static object[] thirteenFloats =
@ -109,67 +92,67 @@ namespace ANX.Framework.TestCenter.Strukturen
[Test]
public void One()
{
ConvertEquals(XNAVector3.One, ANXVector3.One, "One");
AssertHelper.ConvertEquals(XNAVector3.One, ANXVector3.One, "One");
}
[Test]
public void Zero()
{
ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero");
AssertHelper.ConvertEquals(XNAVector3.Zero, ANXVector3.Zero, "Zero");
}
[Test]
public void Up()
{
ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up");
AssertHelper.ConvertEquals(XNAVector3.Up, ANXVector3.Up, "Up");
}
[Test]
public void Down()
{
ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down");
AssertHelper.ConvertEquals(XNAVector3.Down, ANXVector3.Down, "Down");
}
[Test]
public void Backward()
{
ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward");
AssertHelper.ConvertEquals(XNAVector3.Backward, ANXVector3.Backward, "Backward");
}
[Test]
public void Forward()
{
ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward");
AssertHelper.ConvertEquals(XNAVector3.Forward, ANXVector3.Forward, "Forward");
}
[Test]
public void Left()
{
ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left");
AssertHelper.ConvertEquals(XNAVector3.Left, ANXVector3.Left, "Left");
}
[Test]
public void Right()
{
ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right");
AssertHelper.ConvertEquals(XNAVector3.Right, ANXVector3.Right, "Right");
}
[Test]
public void UnitX()
{
ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX");
AssertHelper.ConvertEquals(XNAVector3.UnitX, ANXVector3.UnitX, "UnitX");
}
[Test]
public void UnitY()
{
ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY");
AssertHelper.ConvertEquals(XNAVector3.UnitY, ANXVector3.UnitY, "UnitY");
}
[Test]
public void UnitZ()
{
ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ");
AssertHelper.ConvertEquals(XNAVector3.UnitZ, ANXVector3.UnitZ, "UnitZ");
}
#endregion
@ -183,7 +166,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3();
ConvertEquals(xnaR, anxR, "Constructor1");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor1");
}
[Test, TestCaseSource("thirteenFloats")]
@ -193,7 +176,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x);
ConvertEquals(xnaR, anxR, "Constructor2");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor2");
}
[Test, TestCaseSource("thirteenFloats")]
@ -205,7 +188,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector2 anxV2 = new ANXVector2(x, y);
ANXVector3 anxR = new ANXVector3(anxV2, z);
ConvertEquals(xnaR, anxR, "Constructor3");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor3");
}
[Test, TestCaseSource("thirteenFloats")]
@ -215,7 +198,7 @@ namespace ANX.Framework.TestCenter.Strukturen
ANXVector3 anxR = new ANXVector3(x, y, z);
ConvertEquals(xnaR, anxR, "Constructor4");
AssertHelper.ConvertEquals(xnaR, anxR, "Constructor4");
}
#endregion
@ -234,7 +217,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Add(xna1, xna2);
ANXVector3 anxR = ANXVector3.Add(anx1, anx2);
ConvertEquals(xnaR, anxR, "Add");
AssertHelper.ConvertEquals(xnaR, anxR, "Add");
}
@ -254,7 +237,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Barycentric(xna1, xna2, xna3, amount1, amount2);
ANXVector3 anxR = ANXVector3.Barycentric(anx1, anx2, anx3, amount1, amount2);
ConvertEquals(xnaR, anxR, "Barycentric");
AssertHelper.ConvertEquals(xnaR, anxR, "Barycentric");
}
[Test, TestCaseSource("thirteenFloats")]
@ -273,7 +256,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.CatmullRom(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.CatmullRom(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "CatmullRom");
AssertHelper.ConvertEquals(xnaR, anxR, "CatmullRom");
}
[Test, TestCaseSource("thirteenFloats")]
@ -290,7 +273,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Clamp(xna1, xna2, xna3);
ANXVector3 anxR = ANXVector3.Clamp(anx1, anx2, anx3);
ConvertEquals(xnaR, anxR, "Clamp");
AssertHelper.ConvertEquals(xnaR, anxR, "Clamp");
}
[Test, TestCaseSource("thirteenFloats")]
@ -305,7 +288,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Cross(xna1, xna2);
ANXVector3 anxR = ANXVector3.Cross(anx2, anx2);
ConvertEquals(xnaR, anxR, "Cross");
AssertHelper.ConvertEquals(xnaR, anxR, "Cross");
}
[Test, TestCaseSource("thirteenFloats")]
@ -348,7 +331,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, divider);
ANXVector3 anxR = ANXVector3.Divide(anx1, divider);
ConvertEquals(xnaR, anxR, "DivideVectorDivider");
AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorDivider");
}
[Test, TestCaseSource("thirteenFloats")]
@ -363,7 +346,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Divide(xna1, xna2);
ANXVector3 anxR = ANXVector3.Divide(anx1, anx2);
ConvertEquals(xnaR, anxR, "DivideVectorVector");
AssertHelper.ConvertEquals(xnaR, anxR, "DivideVectorVector");
}
[Test, TestCaseSource("thirteenFloats")]
@ -411,7 +394,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Hermite(xna1, xna2, xna3, xna4, amount);
ANXVector3 anxR = ANXVector3.Hermite(anx1, anx2, anx3, anx4, amount);
ConvertEquals(xnaR, anxR, "Hermite");
AssertHelper.ConvertEquals(xnaR, anxR, "Hermite");
}
[Test, TestCaseSource("thirteenFloats")]
@ -442,7 +425,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Lerp(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.Lerp(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "Lerp");
AssertHelper.ConvertEquals(xnaR, anxR, "Lerp");
}
[Test, TestCaseSource("thirteenFloats")]
@ -457,7 +440,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Max(xna1, xna2);
ANXVector3 anxR = ANXVector3.Max(anx1, anx2);
ConvertEquals(xnaR, anxR, "Max");
AssertHelper.ConvertEquals(xnaR, anxR, "Max");
}
@ -473,7 +456,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Min(xna1, xna2);
ANXVector3 anxR = ANXVector3.Min(anx1, anx2);
ConvertEquals(xnaR, anxR, "Min");
AssertHelper.ConvertEquals(xnaR, anxR, "Min");
}
[Test, TestCaseSource("thirteenFloats")]
@ -488,7 +471,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, scale);
ANXVector3 anxR = ANXVector3.Multiply(anx1, scale);
ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorFloat");
}
[Test, TestCaseSource("thirteenFloats")]
@ -503,7 +486,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Multiply(xna1, xna2);
ANXVector3 anxR = ANXVector3.Multiply(anx1, anx2);
ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
AssertHelper.ConvertEquals(xnaR, anxR, "MultiplyVectorVector");
}
[Test, TestCaseSource("thirteenFloats")]
@ -516,7 +499,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Negate(xna1);
ANXVector3 anxR = ANXVector3.Negate(anx1);
ConvertEquals(xnaR, anxR, "Negate");
AssertHelper.ConvertEquals(xnaR, anxR, "Negate");
}
[Test, TestCaseSource("thirteenFloats")]
@ -529,7 +512,7 @@ namespace ANX.Framework.TestCenter.Strukturen
xnaR.Normalize();
anxR.Normalize();
ConvertEquals(xnaR, anxR, "NormalizeInstanz");
AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeInstanz");
}
[Test, TestCaseSource("thirteenFloats")]
@ -542,7 +525,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Normalize(xna1);
ANXVector3 anxR = ANXVector3.Normalize(anx1);
ConvertEquals(xnaR, anxR, "NormalizeStatic");
AssertHelper.ConvertEquals(xnaR, anxR, "NormalizeStatic");
}
[Test, TestCaseSource("thirteenFloats")]
@ -557,7 +540,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Reflect(xna1, xna2);
ANXVector3 anxR = ANXVector3.Reflect(anx1, anx2);
ConvertEquals(xnaR, anxR, "Reflect");
AssertHelper.ConvertEquals(xnaR, anxR, "Reflect");
}
[Test, TestCaseSource("thirteenFloats")]
@ -572,7 +555,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.SmoothStep(xna1, xna2, amount);
ANXVector3 anxR = ANXVector3.SmoothStep(anx1, anx2, amount);
ConvertEquals(xnaR, anxR, "SmoothStep");
AssertHelper.ConvertEquals(xnaR, anxR, "SmoothStep");
}
[Test, TestCaseSource("thirteenFloats")]
@ -587,7 +570,7 @@ namespace ANX.Framework.TestCenter.Strukturen
XNAVector3 xnaR = XNAVector3.Subtract(xna1, xna2);
ANXVector3 anxR = ANXVector3.Subtract(anx1, anx2);
ConvertEquals(xnaR, anxR, "Subtract");
AssertHelper.ConvertEquals(xnaR, anxR, "Subtract");
}
[Test, TestCaseSource("thirteenFloats")]

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

@ -87,14 +87,17 @@ namespace ANX.Framework.TestCenter.Strukturen
#region Testdata
static object[] fourFloats =
{
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat },
new object[] { DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat, DataFactory.RandomFloat }
};
static object[] seventeenFloats =
{
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat ,Vector2Test.RandomFloat},
// new object[] {Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat,Vector2Test.RandomFloat },
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},
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},
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},
@ -158,8 +161,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor1");
}
[Test, TestCaseSource("seventeenFloats")]
public void constructor2(float x, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9, float nop10, float nop11, float nop12)
[Test, TestCaseSource("fourFloats")]
public void constructor2(float x, float nop1, float nop2, float nop3)
{
XNAVector4 xnaR = new XNAVector4(x);
@ -168,8 +171,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor2");
}
[Test, TestCaseSource("seventeenFloats")]
public void constructor3(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
[Test, TestCaseSource("fourFloats")]
public void constructor3(float x, float y, float z, float w)
{
XNAVector3 xnaV3 = new XNAVector3(x, y, z);
XNAVector4 xnaR = new XNAVector4(xnaV3, w);
@ -180,8 +183,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor3");
}
[Test, TestCaseSource("seventeenFloats")]
public void constructor4(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
[Test, TestCaseSource("fourFloats")]
public void constructor4(float x, float y, float z, float w)
{
XNAVector2 xnaV2 = new XNAVector2(x, y);
XNAVector4 xnaR = new XNAVector4(xnaV2, z, w);
@ -192,8 +195,8 @@ namespace ANX.Framework.TestCenter.Strukturen
ConvertEquals(xnaR, anxR, "Constructor4");
}
[Test, TestCaseSource("seventeenFloats")]
public void constructor5(float x, float y, float z, float w, float nop1, float nop2, float nop3, float nop4, float nop5, float nop6, float nop7, float nop8, float nop9)
[Test, TestCaseSource("fourFloats")]
public void constructor5(float x, float y, float z, float w)
{
XNAVector4 xnaR = new XNAVector4(x, y, z, w);

91
ANX.Framework/Color.cs
View File

@ -865,12 +865,32 @@ namespace ANX.Framework
public static Color FromNonPremultiplied(int r, int g, int b, int a)
{
throw new NotImplementedException();
Color color;
r = r * a;
g = g * a;
b = b * a;
if (((((r | g) | b) | a) & -256) != 0)
{
r = r < 0 ? 0 : (r > 255 ? 255 : r);
g = g < 0 ? 0 : (g > 255 ? 255 : g);
b = b < 0 ? 0 : (b > 255 ? 255 : b);
a = a < 0 ? 0 : (a > 255 ? 255 : a);
}
color.packedValue = (uint)(((r | g << 8) | b << 16) | a << 24);
return color;
}
public static Color FromNonPremultiplied(Vector4 vector)
{
throw new NotImplementedException();
Color color;
color.packedValue = ColorPack(vector.X * vector.W, vector.Y * vector.W, vector.Z * vector.W, vector.W);
return color;
}
public override int GetHashCode()
@ -880,12 +900,54 @@ namespace ANX.Framework
public static Color Lerp(Color value1, Color value2, float amount)
{
throw new NotImplementedException();
Color color;
byte r1 = (byte)value1.packedValue;
byte g1 = (byte)(value1.packedValue >> 8);
byte b1 = (byte)(value1.packedValue >> 16);
byte a1 = (byte)(value1.packedValue >> 24);
byte r2 = (byte)value2.packedValue;
byte g2 = (byte)(value2.packedValue >> 8);
byte b2 = (byte)(value2.packedValue >> 16);
byte a2 = (byte)(value2.packedValue >> 24);
int factor = (int)PackUNormal(65536f, amount);
int r3 = r1 + (((r2 - r1) * factor) >> 16);
int g3 = g1 + (((g2 - g1) * factor) >> 16);
int b3 = b1 + (((b2 - b1) * factor) >> 16);
int a3 = a1 + (((a2 - a1) * factor) >> 16);
color.packedValue = (uint)(((r3 | (g3 << 8)) | (b3 << 16)) | (a3 << 24));
return color;
}
public static Color Multiply(Color value, float scale)
{
throw new NotImplementedException();
Color color;
uint r = (byte)value.packedValue;
uint g = (byte)(value.packedValue >> 8);
uint b = (byte)(value.packedValue >> 16);
uint a = (byte)(value.packedValue >> 24);
uint uintScale = (uint)MathHelper.Clamp(scale * 65536f, 0, 0xffffff);
r = (r * uintScale) >> 16;
g = (g * uintScale) >> 16;
b = (b * uintScale) >> 16;
a = (a * uintScale) >> 16;
r = r > 255 ? 255 : r;
g = g > 255 ? 255 : g;
b = b > 255 ? 255 : b;
a = a > 255 ? 255 : a;
color.packedValue = ((r | (g << 8)) | (b << 0x10)) | (a << 0x18);
return color;
}
public static Color operator *(Color a, float scale)
@ -900,12 +962,29 @@ namespace ANX.Framework
public Vector3 ToVector3()
{
return new Vector3(R, G, B);
Vector3 result;
result.X = (packedValue & 255);
result.Y = (packedValue >> 8 & 255);
result.Z = (packedValue >> 16 & 255);
result /= 0xff;
return result;
}
public Vector4 ToVector4()
{
return new Vector4(R, G, B, A);
Vector4 result;
result.X = (packedValue & 255);
result.Y = (packedValue >> 8 & 255);
result.Z = (packedValue >> 16 & 255);
result.W = (packedValue >> 24 & 255);
result /= 0xff;
return result;
}
public void PackFromVector4(Vector4 vector)

2
ANX.Framework/Vector3.cs
View File

@ -264,7 +264,7 @@ namespace ANX.Framework
public static void Divide(ref Vector3 value1, float value2, out Vector3 result)
{
float divFactor = 1 / value2;
float divFactor = 1f / value2;
Multiply(ref value1, divFactor, out result);
}