public void TestFunctions()
{
{
Vector3 vec1 = new Vector3(2.2f, 6.3f, 12.36f);
Vector3 vec2 = new Vector3(7.9f, 6.3f, 45.3f);
float dotPrdt1 = vec1.Dot(vec2);
float dotPrdt2 = vec2.Dot(vec1);
Assert.IsTrue(dotPrdt1 == dotPrdt2, "Dot Product test fails for Vector3");
Vec3 vec1Native = new Vec3(vec1.x, vec1.y, vec1.z);
Vec3 vec2Native = new Vec3(vec2.x, vec2.y, vec2.z);
dotPrdt1 = vec1Native.Dot(vec2Native);
dotPrdt2 = vec2Native.Dot(vec1Native);
Assert.IsTrue(dotPrdt1 == dotPrdt2, "Dot Product test fails for Vec3");
}
{
Vector3 vec1 = new Vector3(2.2f, 6.3f, 2.36f);
Vector3 vec2 = new Vector3(7.9f, 6.3f, 5.3f);
Vector3 crossPrdt1 = vec1.Cross(vec2);
Vector3 crossPrdt2 = vec2.Cross(vec1);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(crossPrdt1, -crossPrdt2), "Cross(Vector3) fails for Vector3 1");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(-crossPrdt1, crossPrdt2), "Cross(Vector3) fails for Vector3 2");
}
}
public void TestLerp()
{
{
//native
Vec4 vec4p = new Vec4(1f, 1f, 0f, 0f);
vec4p.Normalize();
Vec4 vec4q = new Vec4(0f, 1f, 0f, 0f);
vec4q.Normalize();
Vec4 vec4Mid = Vec4.CreateLerp(vec4p, vec4q, 0.5f);
//managed
Vector4 vector4p = new Vector4(vec4p.x, vec4p.y, vec4p.z, vec4p.w);
Vector4 vector4q = new Vector4(vec4q.x, vec4q.y, vec4q.z, vec4q.w);
Vector4 vector4Mid = Vector4.Lerp(vector4p, vector4q, 0.5f);
Assert.IsTrue(vec4Mid == vector4Mid, " Lerp tests fails for native and managed vector4 1" + vec4Mid.PrintString() + "," + vector4Mid.ToString());
}
{
//native
Vec4 vec4p = new Vec4(1f, 0f, 0f, 0f);
Vec4 vec4q = new Vec4(0f, 1f, 0f, 0f);
Vec4 vec4Mid = Vec4.CreateLerp(vec4p, vec4q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec4Mid, new Vector4(0.5f, 0.5f, 0f, 0f)), "Lerp tests fails for native vec4 2" + vec4Mid.PrintString());
//managed
Vector4 vector4p = new Vector4(vec4p.x, vec4p.y, vec4p.z, vec4p.w);
Vector4 vector4q = new Vector4(vec4q.x, vec4q.y, vec4q.z, vec4q.w);
Vector4 vector4Mid = Vector4.Lerp(vector4p, vector4q, 0.5f);
Assert.IsTrue(vec4Mid == vector4Mid, " Lerp tests fails for native and managed vector4 4" + vec4Mid.PrintString() + "," + vector4Mid.ToString());
}
{
//native
Vec4 vec4p = new Vec4(0.5f, 0f, 0f, 0f);
Vec4 vec4q = new Vec4(0.5f, 0f, 0f, 0f);
Vec4 lerpVec = Vec4.CreateLerp(vec4p, vec4q, 0.5f);
Vec4 expectedResult = new Vec4(0.5f, 0f, 0f, 0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(lerpVec, expectedResult), "Lerp tests fail for native vec4 " + "Expected :" + expectedResult.PrintString() + ", Actual :" + lerpVec.PrintString());
//managed
Vector4 vector4p = new Vector4(0.5f, 0f, 0f, 0f);
Vector4 vector4q = new Vector4(0.5f, 0f, 0f, 0f);
Vector4 lerpVector4 = Vector4.Lerp(vector4p, vector4q, 0.5f);
Vector4 expectedResult2 = new Vector4(0.5f, 0, 0, 0);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(lerpVector4, expectedResult2), "Lerp tests fail for managed vector4 " + "Expected :" + expectedResult2.ToString() + ", Actual :" + lerpVector4.ToString());
}
{
Vector4 p = new Vector4(1.0f, 0f, 0f, 0f);
Vector4 q = new Vector4(-1f, 0f, 0f, 0f);
//middle of interpolation will be (0,0,0,0)
Vector4 expectedResult = new Vector4(0, 0, 0, 0);
Vector4 actualResult = Vector4.Lerp(p, q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(expectedResult, actualResult), "Lerp fails for managed vector4 " + "Expected :" + expectedResult + ", Actual :" + actualResult);
}
}
public void TestSlerp()
{
{
//native
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Mid = Vec2.CreateSlerp(vec2p, vec2q, 0.5f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Mid = Vector2.Slerp(vector2p, vector2q, 0.5f);
Assert.IsTrue(MathHelpers.Approximately(vec2Mid.x, vector2Mid.x, 0.000001f) && MathHelpers.Approximately(vec2Mid.y, vector2Mid.y, 0.000001f), " Slerp tests fails for native and managed vector2 1");
}
{
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Start = Vec2.CreateSlerp(vec2p, vec2q, 0.0f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Start = Vector2.Slerp(vector2p, vector2q, 0.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vector2Start), "Slerp tests fails for vector2 2a");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vec2p), "Slerp tests fails for vector2 2b " + vec2Start.PrintString() + "," + vec2p.PrintString());
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vector2Start, vector2p), "Slerp tests fails for vector2 2c");
}
{
Vec2 vec2p = new Vec2(1f, 1f);
vec2p.Normalize();
Vec2 vec2q = new Vec2(10.0f, 10.0f);
vec2q.Normalize();
Vec2 vec2Start = Vec2.CreateSlerp(vec2p, vec2q, 1.0f);
//managed
Vector2 vector2p = new Vector2(vec2p.x, vec2p.y);
vector2p = vector2p.Normalized;
Vector2 vector2q = new Vector2(vec2q.x, vec2q.y);
vector2q = vector2q.Normalized;
Vector2 vector2Start = Vector2.Slerp(vector2p, vector2q, 1.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vector2Start), "Slerp tests fails for vector2 3a");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2Start, vec2q), "Slerp tests fails for vector2 3b");
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vector2Start, vector2q), "Slerp tests fails for vector2 3c");
}
}
public void TestLerp()
{
{
//native
Vec3 vec3p = new Vec3(1f, 1f, 0f);
vec3p.normalize();
Vec3 vec3q = new Vec3(0f, 1f, 0f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateLerp(vec3p, vec3q, 0.5f);
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Lerp(vector3p, vector3q, 0.5f);
Assert.IsTrue(vec3Mid == vector3Mid, " Lerp tests fails for native and managed vector3 1" + vec3Mid.PrintString() + "," + vector3Mid.ToString());
}
{
//native
Vec3 vec3p = new Vec3(1f, 0f, 0f);
Vec3 vec3q = new Vec3(0f, 1f, 0f);
Vec3 vec3Mid = Vec3.CreateLerp(vec3p, vec3q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec3Mid, new Vector3(0.5f, 0.5f, 0)), "Lerp tests fails for native vec3 2" + vec3Mid.PrintString());
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Lerp(vector3p, vector3q, 0.5f);
Assert.IsTrue(vec3Mid == vector3Mid, " Lerp tests fails for native and managed vector3 3" + vec3Mid.PrintString() + "," + vector3Mid.ToString());
}
{
//native
Vec3 vec3p = new Vec3(0.5f, 0f, 0f);
Vec3 vec3q = new Vec3(0.5f, 0f, 0f);
Vec3 lerpVec = Vec3.CreateLerp(vec3p, vec3q, 0.5f);
Vec3 expectedResult = new Vec3(0.5f, 0f, 0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(lerpVec, expectedResult), "Lerp tests fail for native vec3 " + "Expected :" + expectedResult.PrintString() + ", Actual :" + lerpVec.PrintString());
//managed
Vector3 vector3p = new Vector3(0.5f, 0f, 0f);
Vector3 vector3q = new Vector3(0.5f, 0f, 0f);
Vector3 lerpVector3 = Vector3.Lerp(vector3p, vector3q, 0.5f);
Vector3 expectedResult2 = new Vector3(0.5f, 0, 0);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(lerpVector3, expectedResult2), "Lerp tests fail for managed vector3 " + "Expected :" + expectedResult2.ToString() + ", Actual :" + lerpVector3.ToString());
}
{
Vector3 p = new Vector3(1.0f, 0f, 0f);
Vector3 q = new Vector3(-1f, 0f, 0f);
//middle of interpolation will be (0,0,0)
Vector3 expectedResult = new Vector3(0, 0, 0);
Vector3 actualResult = Vector3.Lerp(p, q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(expectedResult, actualResult), "Lerp fails for managed vector3 " + "Expected :" + expectedResult + ", Actual :" + actualResult);
}
}
public void TestOtherProperties()
{
{
//get length
Vector3 v1 = new Vector3(1.1f, 2.2f, 3.3f);
float len = v1.Length;
float lenManual = (float)System.Math.Sqrt(v1.x * v1.x + v1.y * v1.y + v1.z * v1.z);
Assert.IsTrue(len == lenManual, "Length get test fails for Vector3");
Vec3 v2 = new Vec3(v1.x, v1.y, v1.z);
float v2Len = v2.len();
Assert.IsTrue(len == lenManual, "Length Comparison test fails for Vector3 and Vec3");
//get magnitude
float magnitude = v1.Magnitude;
Assert.IsTrue(len == magnitude, "Length and magnitude are not equal");
}
{
//LengthSquared
Vector3 v1 = new Vector3(1.2f, 0.3f, 1.5f);
float lengthSquared = v1.LengthSquared;
float lengthSquared2 = (v1.x * v1.x) + (v1.y * v1.y) + (v1.z * v1.z);
Assert.IsTrue(MathHelpers.Approximately(lengthSquared, lengthSquared2, 0.0000001f), "LengthSquared fails for Vector3");
}
{
//Length2D
Vector2 v2 = new Vector2(1.2f, 0.3f);
Vector3 v2_to_v3 = new Vector3(v2);
float v2Length = v2.Length;
float v2_to_v3Length = v2_to_v3.Length2D;
Assert.IsTrue(MathHelpers.Approximately(v2Length, v2_to_v3Length, 0.0000001f), "Length2D fails for Vector3");
float v2LengthSquared = v2.LengthSquared;
float v2_to_v3LengthSquared = v2_to_v3.Length2DSquared;
Assert.IsTrue(MathHelpers.Approximately(v2LengthSquared, v2_to_v3LengthSquared, 0.0000001f), "Length2DSquared fails for Vector3");
}
{
//Normalized
Vector3 v3 = new Vector3(0, 0, 0);
Vector3 v3Unit = v3.Normalized;
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(v3, v3Unit), "Normalized fails for Vector3");
}
{
//Volume
Vector3 v3 = new Vector3(1f, 2f, 10f);
float volume = v3.Volume;
float vol = v3.x * v3.y * v3.z;
Assert.IsTrue(volume == vol, "Volume fails for Vector3");
}
}
public void TestSlerpCollinearVectors()
{
{
Vector2 p = new Vector2(1.0f, 0f);
Vector2 q = new Vector2(-1.0f, 0f);
//middle of interpolation will be (0,0)
Vector2 yVector = new Vector2(0, 0);
Vector2 result = Vector2.SlerpUnclamped(p, q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(result, yVector), "Slerp Collinear Vector2 fails, result is :" + result.ToString());
}
}
public void TestZero()
{
Vector2 vec2 = new Vector2(0, 0);
Assert.IsTrue(vec2 == Vector2.Zero, " Zero equality fails for Vector2.Zero");
Vec2 vec2native = new Vec2(0, 0);
Assert.IsTrue(vec2native == vec2, "Zero equality fails for native and managed");
//this should not throw an error
Vector2 normalized = vec2.Normalized;
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec2, normalized), "Zero equality fails for normalized 'zero' point");
}
public void TestOperators()
{
Vector3 a = new Vector3(4.5f, 65.9f, 98.32f);
float scale = 15.6f;
{
Vector3 b = a * scale;
Vector3 d = new Vector3(a.x * scale, a.y * scale, a.z * scale);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(b, d), "Operator* (Vector3 v, float scale) test fails for Vector3");
}
{
Vector3 b = a * scale;
Vector3 d = scale * a;
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(b, d), "Operator * (float scale,Vector3 v) test fails for Vector3");
}
{
Vector3 b = a / scale;
float multiplier = 1 / scale;
Vector3 c = new Vector3(a.x * multiplier, a.y * multiplier, a.z * multiplier);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(b, c), "Operator / (Vector3 v, float scale) test fails for Vector3");
}
{
Vector3 b = new Vector3(7.9f, 5.3f, 109.3f);
Vector3 sum1 = a + b;
Vector3 sum2 = new Vector3(a.x + b.x, a.y + b.y, a.z + b.z);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(sum1, sum2), "operator +(Vector3 v0, Vector3 v1) test fails for Vector3");
}
{
Vector3 b = new Vector3(7.9f, 5.3f, 10.25f);
Vector3 difference1 = a - b;
Vector3 difference2 = new Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(difference1, difference2), "operator -(Vector3 v0, Vector3 v1) fails for Vector3");
}
{
Vector3 b = new Vector3(-a.x, -a.y, -a.z);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(-a, b), "operator -(Vector3 v) fails for Vector3");
}
{
Vector3 b = new Vector3((!a).x, (!a).y, (!a).z);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(!a, b), "operator !(Vector3 v) fails for Vector3");
}
}
public void TestMethods()
{
//we need 3 orthonormal vectors for equivalence test to pass
Vector3 right = new Vec3(1f, 0f, -1f);
right = right.Normalized;
Vector3 forward = new Vec3(1f, 1.4142136f, 1f);
forward = forward.Normalized;
Vector3 up = new Vec3(1f, -1.4142136f, 1f);
up = up.Normalized;
//native
Matrix34 nativematrix = new Matrix34(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
Quat nativeQuat = Quat.CreateQuatFromMatrix(nativematrix);
//managed
Matrix3x4 managedmatrix = new Matrix3x4(0f, 3f, 6f, 9f, 1f, 4f, 7f, 10f, 2f, 5f, 8f, 11f);
Quaternion managedQuat = Quat.CreateQuatFromMatrix(managedmatrix);
float radians = 1.57f;
//1 normalize
{
Quaternion test1a = managedQuat;
test1a.Normalize();
Quat test1b = nativeQuat;
test1b.Normalize();
Assert.IsTrue(Quat.IsEquivalent(test1a, test1b), "Normalize Equivalence test failed");
}
//2 Dot
//3 Difference
//4 CreateFromVectors
{
Matrix3x3 matrix33 = Matrix33.CreateFromVectors(right, forward, up);
Quat quat2a = Quat.CreateQuatFromMatrix(matrix33);
Vector3 right2 = new Vector3(right.x, right.y, right.z);
Vector3 forward2 = new Vector3(forward.x, forward.y, forward.z);
Vector3 up2 = new Vector3(up.x, up.y, up.z);
Quaternion quat2b = Quaternion.CreateFromVectors(right2, forward2, up2);
Assert.IsTrue(quat2a == quat2b, "CreateFromVectors equality failed");
Assert.IsTrue(Quat.IsEquivalent(quat2a, quat2b), "CreateFromVectors equivalence failed");
}
//5 SetLookOrientation
//5a
{
//compare to SetRotationVDir, up vector = (0,0,1)
//get 2 orthogonal vectors
Vector3 up5 = new Vector3(0f, 0f, 1f);
Vector3 forward5 = new Vector3(1f, 1.4142136f, 0f);
forward5 = forward5.Normalized;
Vector3 right5 = forward5.Cross(up5);
Quat nativeQuaternion2 = Quat.CreateIdentity();
nativeQuaternion2.SetRotationVDir(forward5);
Matrix33 nativeMatrix = Matrix33.CreateMatrix33(right5, forward5, up5);
Quat nativeQuaternion3 = Quat.CreateQuatFromMatrix(nativeMatrix);
Assert.IsTrue(Quat.IsEquivalent(nativeQuaternion2, nativeQuaternion3), "Native Quaternion constructor failed comparison with SetRotationVDir. Expected :" + ((Quaternion)nativeQuaternion2).ToString() + ", Actual :" + ((Quaternion)nativeQuaternion3).ToString());
}
//5b
{
// test new C# SetLookOrientation, DEV-3691
// rotate forward around x-y plane, z=0
// i) 20 values for x-y plane
// ii) 20 values for y-z plane
Vec3[] testVectors = new Vec3[40];
for (uint i = 0; i < 20; ++i)
{
radians = ((float)System.Math.PI) / 20.0f * i;
testVectors[i] = new Vec3((float)System.Math.Cos(radians), (float)System.Math.Sin(radians), 0f);
}
for (uint i = 20; i < 40; ++i)
{
radians = ((float)System.Math.PI) / 20.0f * i;
testVectors[i] = new Vec3(0f, (float)System.Math.Cos(radians), (float)System.Math.Sin(radians));
}
const float test_margin_error = 0.05f;
for (uint i = 0; i < testVectors.Length; ++i)
{
Vec3 forward5c = testVectors[i];
forward5c = forward5c.normalized();
Quat nativeQuat5c = Quat.CreateIdentity();
nativeQuat5c.SetRotationVDir(forward5c);
float dtPrdt1 = MathHelpers.Clamp(forward5c.Dot(nativeQuat5c.GetColumn1()), -1f, 1f);
Quaternion managedQuat5c = Quaternion.Identity;
Vector3 upManaged = Vector3.Up;
managedQuat5c.SetLookOrientation(forward5c, upManaged);
float dtPrdt2 = MathHelpers.Clamp(forward5c.Dot(managedQuat5c.Forward), -1f, 1f);
float diffFromNative = (float)(System.Math.Acos(dtPrdt1) * (180f / System.Math.PI));
float diffFromManaged = (float)(System.Math.Acos(dtPrdt2) * (180f / System.Math.PI));
float absoluteDiff = System.Math.Abs(diffFromManaged - diffFromNative);
Assert.IsTrue(absoluteDiff <= test_margin_error, "SetLookOrientation failed at loop index " + i + ".Absolute Difference:" + absoluteDiff + " Expected (Native) :" + diffFromNative + ", Actual (Managed) :" + diffFromManaged + ", Forward : " + NativeExtensions.PrintString(forward5c) + ", Up :" + upManaged.ToString());
}
{
//boundary case where axis are flipped when comparing native to managed
Quaternion quatManaged = Quaternion.Identity;
Vector3 upManaged = Vector3.Up;
Vector3 forwardManaged = new Vector3(-8.126793f, 3.401123f, -1.644333f);
forwardManaged = forwardManaged.Normalized;
quatManaged.SetLookOrientation(forwardManaged, upManaged);
Quat quatNative = Quat.CreateIdentity();
Vec3 forwardNative = new Vec3(-8.126793f, 3.401123f, -1.644333f);
forwardNative = forwardNative.normalized();
quatNative.SetRotationVDir(forwardNative);
bool isEqui1 = Quat.IsEquivalent(quatManaged, quatNative, 0.00999999776f);
Assert.IsTrue(isEqui1, String.Format("Native Quaternion {0} and Managed Quaternion {1} are not equivalent", ((Quaternion)quatNative).ToString(), quatManaged));
}
}
//6 SetFromTORotation(Vector3 , Vector3)
{
Vec3 fromVec = new Vec3(0.5f, 0.5f, 0.5f);
Vec3 toVec = new Vec3(0.5f, -0.5f, -0.5f);
Quat quat6a = Quat.CreateIdentity();
quat6a.SetRotationV0V1(fromVec, toVec);
Vector3 fromVec2 = new Vector3(fromVec.x, fromVec.y, fromVec.z);
Vector3 toVec2 = new Vector3(toVec.x, toVec.y, toVec.z);
Quaternion quat6b = Quaternion.Identity;
quat6b.SetFromToRotation(fromVec2, toVec2);
Assert.IsTrue(Quat.IsEquivalent(quat6a, quat6b), "SetFromToRotation failed");
}
//7 CreateRotationX(float)
{
Quat quat7a = Quat.CreateRotationX(radians);
Quaternion quat7b = Quaternion.CreateRotationX(radians);
Assert.IsTrue(Quat.IsEquivalent(quat7a, quat7b), "CreateRotationX failed");
}
//8 CreateRotationY(float)
{
Quat quat8a = Quat.CreateRotationY(radians + 0.1f);
Quaternion quat8b = Quaternion.CreateRotationY(radians + 0.1f);
Assert.IsTrue(Quat.IsEquivalent(quat8a, quat8b), "CreateRotationY failed");
}
//9 CreateRotationZ(float)
{
Quat quat9a = Quat.CreateRotationZ(radians + 0.1f);
Quaternion quat9b = Quaternion.CreateRotationZ(radians + 0.1f);
Assert.IsTrue(Quat.IsEquivalent(quat9a, quat9b), "CreateRotationZ failed");
}
//10 CreateRotationXYZ(Angles3)
{
Angles3 angles = new Vec3(radians, radians, radians);
Quat quat10a = Quat.CreateRotationXYZ(angles);
Quaternion quat10b = Quaternion.CreateRotationXYZ(angles);
Assert.IsTrue(Quat.IsEquivalent(quat10a, quat10b), "CreateRotationXYZ equivalence failed");
}
//11 Slerp(Quaternion, Quaternion, float)
{
float timeRatio = 0.5f;
Quat quat11a = Quat.CreateRotationX(radians);
Quat quat11b = Quat.CreateRotationY(radians);
Quat quat11c = Quat.CreateIdentity();
quat11c.SetSlerp(quat11a, quat11b, timeRatio);
Quaternion quat11d = Quaternion.CreateRotationX(radians);
Quaternion quat11e = Quaternion.CreateRotationY(radians);
Quaternion quat11f = Quaternion.Slerp(quat11d, quat11e, timeRatio);
Assert.IsTrue(Quat.IsEquivalent(quat11c, quat11f), "Slerp equivalence failed");
}
//12 Lerp(Quaternion, Quaternion, float)
{
float timeRatio = 0.5f;
Quat quat12a = Quat.CreateRotationX(radians);
Quat quat12b = Quat.CreateRotationY(radians);
Quat quat12c = Quat.CreateIdentity();
quat12c.SetNlerp(quat12a, quat12b, timeRatio);
Quaternion quat12d = Quaternion.CreateRotationX(radians);
Quaternion quat12e = Quaternion.CreateRotationY(radians);
Quaternion quat12f = Quaternion.Lerp(quat12d, quat12e, timeRatio);
Assert.IsTrue(Quat.IsEquivalent(quat12c, quat12f), "Lerp equivalence failed");
}
//13 Properties
{
Matrix3x3 matrix33 = Matrix33.CreateFromVectors(right, forward, up);
Quat quat13a = Quat.CreateQuatFromMatrix(matrix33);
Vector3 right2 = new Vector3(right.x, right.y, right.z);
Vector3 forward2 = new Vector3(forward.x, forward.y, forward.z);
Vector3 up2 = new Vector3(up.x, up.y, up.z);
Quaternion quat13b = Quaternion.CreateFromVectors(right2, forward2, up2);
Assert.IsTrue(quat13a == quat13b, "Quaternions equality test failed");
Assert.IsTrue(Quat.IsEquivalent(quat13a, quat13b), "Quaternions equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(right2, quat13b.Right), "Right equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(forward2, quat13b.Forward), "Forward equivalence test failed");
Assert.IsTrue(Vec3.IsEquivalent(up2, quat13b.Up), "Up equivalence test failed");
//inversion
Quat invertNative = quat13a.GetInverted();
Quaternion invertManaged = quat13b.Inverted;
Assert.IsTrue(Quat.IsEquivalent(invertNative, invertManaged), "Inversion equivalence test failed");
//normalization
Quat normalNative = quat13a.GetNormalized();
Quaternion normalManaged = quat13b.Normalized;
Assert.IsTrue(Quat.IsEquivalent(normalNative, normalManaged), "Normalization test failed");
//length
float lengthNative = quat13a.GetLength();
float lengthManaged = quat13b.Length;
Assert.IsTrue(System.Math.Abs(lengthNative - lengthManaged) <= Single.Epsilon, "Length test failed");
//IsIdentity
Quaternion managedIdentity = Quaternion.Identity;
Assert.IsTrue(managedIdentity.IsIdentity, "Managed Identity test failed");
Quat nativeIdentity = new Quat();
nativeIdentity.SetIdentity();
Assert.IsTrue(nativeIdentity.IsIdentity(), "Native Identity test failed");
Assert.IsTrue(managedIdentity == nativeIdentity, "Identity comparison failed");
// yaw pitch roll
}
}
public void TestSlerp()
{
{ // t =0.5
//native
Vec3 vec3p = new Vec3(1f, 1f, 1f);
vec3p.normalize();
Vec3 vec3q = new Vec3(0f, 1f, 1f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateSlerp(vec3p, vec3q, 0.5f);
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Slerp(vector3p, vector3q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec3Mid, vector3Mid), " Slerp tests fails for native and managed vector3 1 " + vec3Mid.PrintString() + "," + vector3Mid.ToString());
}
{
//t =0.0
//native
Vec3 vec3p = new Vec3(1f, 1f, 1f);
vec3p.normalize();
Vec3 vec3q = new Vec3(0f, 1f, 1f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateSlerp(vec3p, vec3q, 0.0f);
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Slerp(vector3p, vector3q, 0.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec3Mid, vector3Mid), " Slerp tests fails for native and managed vector3 2 " + vec3Mid.PrintString() + "," + vector3Mid.ToString());
}
{
//t =1.0
//native
Vec3 vec3p = new Vec3(1f, 1f, 1f);
vec3p.normalize();
Vec3 vec3q = new Vec3(0f, 1f, 1f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateSlerp(vec3p, vec3q, 1.0f);
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Slerp(vector3p, vector3q, 1.0f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec3Mid, vector3Mid), " Slerp tests fails for native and managed vector3 3 " + vec3Mid.PrintString() + "," + vector3Mid.ToString());
}
//same vector but different t
{
Vec3 vec3p = new Vec3(1f, 1f, 1f);
vec3p.normalize();
Vec3 vec3q = new Vec3(1f, 1f, 1f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateSlerp(vec3p, vec3q, 0.5f);
//managed
Vector3 vector3p = new Vector3(1f, 1f, 1f);
vector3p = vector3p.Normalized;
Vector3 vector3q = new Vector3(1f, 1f, 1f);
vector3q = vector3q.Normalized;
Vector3 vector3Mid = Vector3.Slerp(vector3p, vector3q, 0.5f);
//TODO
//The following will be tested again as it passes in Launcher but fails in Nunit console runner
//Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(vec3Mid, vector3Mid), " Slerp tests fails for native and managed vector3 4 " + vec3Mid.PrintString() + "," + vector3Mid.ToString());
float length = (float)System.Math.Sqrt(3);
length = 1.0f / length;
Vector3 expectedResult = new Vector3(length, length, length);
}
{
Vec3 vec3p = new Vec3(1f, 0f, 0f);
vec3p.normalize();
Vec3 vec3q = new Vec3(1f, 0f, 0f);
vec3q.normalize();
Vec3 vec3Mid = Vec3.CreateSlerp(vec3p, vec3q, 0.5f);
//managed
Vector3 vector3p = new Vector3(vec3p.x, vec3p.y, vec3p.z);
Vector3 vector3q = new Vector3(vec3q.x, vec3q.y, vec3q.z);
Vector3 vector3Mid = Vector3.Slerp(vector3p, vector3q, 0.5f);
float differenceX = System.Math.Abs(vec3Mid.x - vector3Mid.x);
float differenceY = System.Math.Abs(vec3Mid.y - vector3Mid.y);
float differenceZ = System.Math.Abs(vec3Mid.z - vector3Mid.z);
bool isSmall = differenceX < 0.0001f && differenceY < 0.0001f && differenceZ < 0.0001f;
float length = 1f;
Vector3 expectedResult = new Vector3(length, 0, 0);
}
{
Vector3 p = new Vector3(1.0f, 0f, 0f);
Vector3 q = new Vector3(-1.0f, 0f, 0f);
//middle of interpolation will be (0,0)
Vector3 expectedResult = new Vector3(0, 0, 0);
Vector3 result = Vector3.SlerpUnclamped(p, q, 0.5f);
Assert.IsTrue(NativeExtensions.TestVectorsAreEqual(result, expectedResult), "Slerp fails for managed vector3 8, expected result is :" + expectedResult.ToString() + ", actual result:" + result.ToString());
}
{
Vector3 p2 = new Vector3(0.5f, 0f, 0f);
Vector3 q2 = new Vector3(0.5f, 0f, 0f);
//middle of interpolation will be (0,0)
Vector3 expectedResult = new Vector3(1f, 0, 0); //after normalized
Vector3 actualResult = Vector3.SlerpUnclamped(p2, q2, 0.5f);
}
}