public void MDLAnimatedQuaternionTest()
{
// Quaternion
TestRuntime.AssertXcodeVersion(11, 0);
using (var animatedQuat = new MDLAnimatedQuaternion()) {
var quat = new Quaternion(1.1f, 2.2f, 3.3f, 4.4f);
animatedQuat.SetQuaternion(quat, 0);
var returnedQuat = animatedQuat.GetFloatQuaternion(0);
Asserts.AreEqual(quat, returnedQuat, "A");
animatedQuat.Reset(TestMatrices.QuaternionArray, TestMatrices.GetTimesArray(TestMatrices.QuaternionArray.Length));
var arr = animatedQuat.GetQuaternionValues(20);
Asserts.AreEqual(TestMatrices.QuaternionArray, arr, "C1");
}
using (var animatedQuat = new MDLAnimatedQuaternion()) {
var quatd = new Quaterniond(10.1, 20.2, 30.3, 40.4);
animatedQuat.SetQuaternion(quatd, 0);
Asserts.AreEqual(quatd, animatedQuat.GetDoubleQuaternion(0), 0.0001, "B");
animatedQuat.Reset(TestMatrices.QuaterniondArray, TestMatrices.GetTimesArray(TestMatrices.QuaterniondArray.Length));
var arrd = animatedQuat.GetQuaterniondValues(20);
Asserts.AreEqual(TestMatrices.QuaterniondArray, arrd, "C2");
}
}
public void MDLAnimatedScalarTest()
{
// float
var floatScalar = new MDLAnimatedScalar();
for (int i = 0; i < TestMatrices.FloatArray.Length; i++)
{
floatScalar.SetValue(TestMatrices.FloatArray [i], i);
}
for (int i = 0; i < TestMatrices.FloatArray.Length; i++)
{
Asserts.AreEqual(TestMatrices.FloatArray [i], floatScalar.GetFloat(i), $"floatScalar iter: {i}");
}
var allFloatValues = floatScalar.GetFloatValues();
for (int i = 0; i < allFloatValues.Length; i++)
{
Asserts.AreEqual(TestMatrices.FloatArray [i], allFloatValues [i], $"allFloatValues iter: {i}");
}
var onesFloatArr = TestMatrices.CreateOnesArray <float> ((int)floatScalar.TimeSampleCount);
var timesfArr = TestMatrices.GetTimesArray(onesFloatArr.Length);
floatScalar.Reset(onesFloatArr, timesfArr);
for (int i = 0; i < onesFloatArr.Length; i++)
{
Asserts.AreEqual(onesFloatArr [i], floatScalar.GetFloat(i), $"onesFloatArr iter: {i}");
}
floatScalar.Reset(Array.Empty <float> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)floatScalar.TimeSampleCount, "floatScalar.TimeSampleCount");
Assert.AreEqual(Array.Empty <float> (), floatScalar.GetFloatValues(), "floatScalar Empty");
// double
var doubleScalar = new MDLAnimatedScalar();
for (int i = 0; i < TestMatrices.DoubleArray.Length; i++)
{
doubleScalar.SetValue(TestMatrices.DoubleArray [i], i);
}
for (int i = 0; i < TestMatrices.FloatArray.Length; i++)
{
Asserts.AreEqual(TestMatrices.DoubleArray [i], doubleScalar.GetDouble(i), $"doubleScalar iter: {i}");
}
var allDoubleValues = doubleScalar.GetDoubleValues();
for (int i = 0; i < allDoubleValues.Length; i++)
{
Asserts.AreEqual(TestMatrices.DoubleArray [i], allDoubleValues [i], $"allDoubleValues iter: {i}");
}
var onesDoubleArr = TestMatrices.CreateOnesArray <double> ((int)doubleScalar.TimeSampleCount);
var timesdArr = TestMatrices.GetTimesArray(onesDoubleArr.Length);
doubleScalar.Reset(onesDoubleArr, timesdArr);
for (int i = 0; i < onesDoubleArr.Length; i++)
{
Asserts.AreEqual(onesDoubleArr [i], doubleScalar.GetFloat(i), $"onesDoubleArr iter: {i}");
}
doubleScalar.Reset(Array.Empty <double> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)doubleScalar.TimeSampleCount, "doubleScalar.TimeSampleCount");
Assert.AreEqual(Array.Empty <double> (), doubleScalar.GetDoubleValues(), "doubleScalar Empty");
}
public void MDLAnimatedMatrix4x4Test()
{
// NMatrix4
var nMatrix4Values = new MDLAnimatedMatrix4x4();
for (int i = 0; i < TestMatrices.NMatrix4Array.Length; i++)
{
nMatrix4Values.SetValue(TestMatrices.NMatrix4Array [i], i);
}
for (int i = 0; i < TestMatrices.NMatrix4Array.Length; i++)
{
Asserts.AreEqual(TestMatrices.NMatrix4Array [i], nMatrix4Values.GetNMatrix4Value(i), $"nMatrix4Values iter: {i}");
}
var allNMatrix4Values = nMatrix4Values.GetNMatrix4Values();
for (int i = 0; i < allNMatrix4Values.Length; i++)
{
Asserts.AreEqual(TestMatrices.NMatrix4Array [i], allNMatrix4Values [i], $"allNMatrix4Values iter: {i}");
}
var onesNMatrix4Arr = TestMatrices.CreateOnesArray <NMatrix4> ((int)nMatrix4Values.TimeSampleCount);
var timesNMatrix4Arr = TestMatrices.GetTimesArray(onesNMatrix4Arr.Length);
nMatrix4Values.Reset(onesNMatrix4Arr, timesNMatrix4Arr);
for (int i = 0; i < onesNMatrix4Arr.Length; i++)
{
Asserts.AreEqual(onesNMatrix4Arr [i], nMatrix4Values.GetNMatrix4Value(i), $"onesNMatrix4Arr iter: {i}");
}
nMatrix4Values.Reset(Array.Empty <NMatrix4> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)nMatrix4Values.TimeSampleCount, "nMatrix4Values.TimeSampleCount");
Assert.AreEqual(Array.Empty <NMatrix4> (), nMatrix4Values.GetNMatrix4Values(), "nMatrix4Values Empty");
// NMatrix4d
var nMatrix4dValues = new MDLAnimatedMatrix4x4();
for (int i = 0; i < TestMatrices.NMatrix4dArray.Length; i++)
{
nMatrix4dValues.SetValue(TestMatrices.NMatrix4dArray [i], i);
}
for (int i = 0; i < TestMatrices.NMatrix4dArray.Length; i++)
{
Asserts.AreEqual(TestMatrices.NMatrix4dArray [i], nMatrix4dValues.GetNMatrix4dValue(i), $"nMatrix4dValues iter: {i}");
}
var allNMatrix4dValues = nMatrix4dValues.GetNMatrix4dValues();
for (int i = 0; i < allNMatrix4dValues.Length; i++)
{
Asserts.AreEqual(TestMatrices.NMatrix4dArray [i], allNMatrix4dValues [i], $"allNMatrix4dValues iter: {i}");
}
var onesNMatrix4dArr = TestMatrices.CreateOnesArray <NMatrix4d> ((int)nMatrix4dValues.TimeSampleCount);
var timesNMatrix4dArr = TestMatrices.GetTimesArray(onesNMatrix4dArr.Length);
nMatrix4dValues.Reset(onesNMatrix4dArr, timesNMatrix4dArr);
for (int i = 0; i < onesNMatrix4dArr.Length; i++)
{
Asserts.AreEqual(onesNMatrix4dArr [i], nMatrix4dValues.GetNMatrix4dValue(i), $"onesNMatrix4dArr iter: {i}");
}
nMatrix4dValues.Reset(Array.Empty <NMatrix4d> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)nMatrix4dValues.TimeSampleCount, "nMatrix4dValues.TimeSampleCount");
Assert.AreEqual(Array.Empty <NMatrix4d> (), nMatrix4dValues.GetNMatrix4dValues(), "nMatrix4dValues Empty");
}
public void MDLAnimatedVector4Test()
{
// Vector4
var vector4Values = new MDLAnimatedVector4();
for (int i = 0; i < TestMatrices.Vector4Array.Length; i++)
{
vector4Values.SetValue(TestMatrices.Vector4Array [i], i);
}
for (int i = 0; i < TestMatrices.Vector4Array.Length; i++)
{
Asserts.AreEqual(TestMatrices.Vector4Array [i], vector4Values.GetVector4Value(i), $"vector4Values iter: {i}");
}
var allVector4Values = vector4Values.GetVector4Values();
for (int i = 0; i < allVector4Values.Length; i++)
{
Asserts.AreEqual(TestMatrices.Vector4Array [i], allVector4Values [i], $"allVector4Values iter: {i}");
}
var onesVector4Arr = TestMatrices.CreateOnesArray <Vector4> ((int)vector4Values.TimeSampleCount);
var timesVector4Arr = TestMatrices.GetTimesArray(onesVector4Arr.Length);
vector4Values.Reset(onesVector4Arr, timesVector4Arr);
for (int i = 0; i < onesVector4Arr.Length; i++)
{
Asserts.AreEqual(onesVector4Arr [i], vector4Values.GetVector4Value(i), $"onesVector4Arr iter: {i}");
}
vector4Values.Reset(Array.Empty <Vector4> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)vector4Values.TimeSampleCount, "vector4Values.TimeSampleCount");
Assert.AreEqual(Array.Empty <Vector4> (), vector4Values.GetVector4Values(), "vector4Values Empty");
// Vector4d
var vector4dValues = new MDLAnimatedVector4();
for (int i = 0; i < TestMatrices.Vector4dArray.Length; i++)
{
vector4dValues.SetValue(TestMatrices.Vector4dArray [i], i);
}
for (int i = 0; i < TestMatrices.Vector4dArray.Length; i++)
{
Asserts.AreEqual(TestMatrices.Vector4dArray [i], vector4dValues.GetVector4dValue(i), $"vector4dValues iter: {i}");
}
var allVector4dValues = vector4dValues.GetVector4dValues();
for (int i = 0; i < allVector4dValues.Length; i++)
{
Asserts.AreEqual(TestMatrices.Vector4dArray [i], allVector4dValues [i], $"allVector4dValues iter: {i}");
}
var onesVector4dArr = TestMatrices.CreateOnesArray <Vector4d> ((int)vector4dValues.TimeSampleCount);
var timesVector4dArr = TestMatrices.GetTimesArray(onesVector4dArr.Length);
vector4dValues.Reset(onesVector4dArr, timesVector4dArr);
for (int i = 0; i < onesVector4dArr.Length; i++)
{
Asserts.AreEqual(onesVector4dArr [i], vector4dValues.GetVector4dValue(i), $"onesVector4dArr iter: {i}");
}
vector4dValues.Reset(Array.Empty <Vector4d> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)vector4dValues.TimeSampleCount, "vector4dValues.TimeSampleCount");
Assert.AreEqual(Array.Empty <Vector4d> (), vector4dValues.GetVector4dValues(), "vector4dValues Empty");
}
