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 MDLAnimatedQuaternionArrayTest()
{
// Quaternion
var quaternionArr = new MDLAnimatedQuaternionArray((nuint)TestMatrices.QuaternionArray.Length);
quaternionArr.SetValues(TestMatrices.QuaternionArray, 5);
var retnQuaternionArr = quaternionArr.GetQuaternionValues();
for (int i = 0; i < retnQuaternionArr.Length; i++)
{
Asserts.AreEqual(TestMatrices.QuaternionArray [i], retnQuaternionArr [i], $"retnQuaternionArr iter: {i}");
}
var retnQuaternionArr2 = quaternionArr.GetQuaternionValues(5);
for (int i = 0; i < retnQuaternionArr.Length; i++)
{
Asserts.AreEqual(retnQuaternionArr [i], retnQuaternionArr2 [i], $"retnQuaternionArr2 iter: {i}");
}
var onesQuaternionArr = TestMatrices.CreateOnesArray <Quaternion> ((int)quaternionArr.ElementCount);
var timesQuaternionArr = new [] { 5d };
quaternionArr.Reset(onesQuaternionArr, timesQuaternionArr);
var quaternionValues = quaternionArr.GetQuaternionValues(5);
for (int i = 0; i < onesQuaternionArr.Length; i++)
{
Asserts.AreEqual(onesQuaternionArr [i], quaternionValues [i], $"onesQuaternionArr iter: {i}");
}
quaternionArr.Reset(Array.Empty <Quaternion> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)quaternionArr.TimeSampleCount, "quaternionArr.TimeSampleCount");
Assert.AreEqual(Array.Empty <Quaternion> (), quaternionArr.GetQuaternionValues(), "quaternionArr Empty");
// Quaterniond
var quaterniondArr = new MDLAnimatedQuaternionArray((nuint)TestMatrices.QuaterniondArray.Length);
quaterniondArr.SetValues(TestMatrices.QuaterniondArray, 5);
var retQuaterniondArr = quaterniondArr.GetQuaterniondValues();
for (int i = 0; i < retQuaterniondArr.Length; i++)
{
Asserts.AreEqual(TestMatrices.QuaterniondArray [i], retQuaterniondArr [i], $"retQuaterniondArr iter: {i}");
}
var retQuaterniondArr2 = quaterniondArr.GetQuaterniondValues(5);
for (int i = 0; i < retQuaterniondArr.Length; i++)
{
Asserts.AreEqual(retQuaterniondArr [i], retQuaterniondArr2 [i], $"retQuaternionArr2 iter: {i}");
}
var onesQuaterniondArr = TestMatrices.CreateOnesArray <Quaterniond> ((int)quaterniondArr.ElementCount);
var timesQuaterniondArr = new [] { 5d };
quaterniondArr.Reset(onesQuaterniondArr, timesQuaterniondArr);
var quaterniondValues = quaterniondArr.GetQuaterniondValues(5);
for (int i = 0; i < onesQuaterniondArr.Length; i++)
{
Asserts.AreEqual(onesQuaterniondArr [i], quaterniondValues [i], $"onesQuaterniondArr iter: {i}");
}
quaterniondArr.Reset(Array.Empty <Quaterniond> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)quaterniondArr.TimeSampleCount, "quaterniondArr.TimeSampleCount");
Assert.AreEqual(Array.Empty <Quaterniond> (), quaterniondArr.GetQuaterniondValues(), "quaterniondArr Empty");
}
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 MDLAnimatedVector3ArrayTest()
{
// NVector3
var nVector3Arr = new MDLAnimatedVector3Array((nuint)TestMatrices.NVector3Array.Length);
nVector3Arr.SetValues(TestMatrices.NVector3Array, 5);
var retnVector3Arr = nVector3Arr.GetNVector3Values();
for (int i = 0; i < retnVector3Arr.Length; i++)
{
Asserts.AreEqual(TestMatrices.NVector3Array [i], retnVector3Arr [i], $"retnVector3Arr iter: {i}");
}
var retnVector3Arr2 = nVector3Arr.GetNVector3Values(5);
for (int i = 0; i < retnVector3Arr.Length; i++)
{
Asserts.AreEqual(retnVector3Arr [i], retnVector3Arr2 [i], $"retnVector3Arr2 iter: {i}");
}
var onesnVector3Arr = TestMatrices.CreateOnesArray <NVector3> ((int)nVector3Arr.ElementCount);
var timesnVector3Arr = new [] { 5d };
nVector3Arr.Reset(onesnVector3Arr, timesnVector3Arr);
var nVector3Values = nVector3Arr.GetNVector3Values(5);
for (int i = 0; i < onesnVector3Arr.Length; i++)
{
Asserts.AreEqual(onesnVector3Arr [i], nVector3Values [i], $"onesnVector3Arr iter: {i}");
}
nVector3Arr.Reset(Array.Empty <NVector3> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)nVector3Arr.TimeSampleCount, "nVector3Arr.TimeSampleCount");
Assert.AreEqual(Array.Empty <NVector3> (), nVector3Arr.GetNVector3Values(), "nVector3Arr Empty");
// NVector3d
var nVector3dArr = new MDLAnimatedVector3Array((nuint)TestMatrices.NVector3dArray.Length);
nVector3dArr.SetValues(TestMatrices.NVector3dArray, 5);
var retnVector3dArr = nVector3dArr.GetNVector3dValues();
for (int i = 0; i < retnVector3dArr.Length; i++)
{
Asserts.AreEqual(TestMatrices.NVector3dArray [i], retnVector3dArr [i], $"retnVector3dArr iter: {i}");
}
var retnVector3dArr2 = nVector3dArr.GetNVector3dValues(5);
for (int i = 0; i < retnVector3dArr.Length; i++)
{
Asserts.AreEqual(retnVector3dArr [i], retnVector3dArr2 [i], $"retnVector3dArr2 iter: {i}");
}
var onesnVector3dArr = TestMatrices.CreateOnesArray <NVector3d> ((int)nVector3dArr.ElementCount);
var timesnVector3dArr = new [] { 5d };
nVector3dArr.Reset(onesnVector3dArr, timesnVector3dArr);
var nVector3dValues = nVector3dArr.GetNVector3dValues(5);
for (int i = 0; i < onesnVector3dArr.Length; i++)
{
Asserts.AreEqual(onesnVector3dArr [i], nVector3dValues [i], $"onesnVector3dArr iter: {i}");
}
nVector3dArr.Reset(Array.Empty <NVector3d> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)nVector3dArr.TimeSampleCount, "nVector3dArr.TimeSampleCount");
Assert.AreEqual(Array.Empty <NVector3d> (), nVector3dArr.GetNVector3dValues(), "nVector3dArr Empty");
}
public void MDLAnimatedScalarArrayTest()
{
// Floats
var floatArr = new MDLAnimatedScalarArray((nuint)TestMatrices.FloatArray.Length);
floatArr.SetValues(TestMatrices.FloatArray, 5);
var retFloatArr = floatArr.GetFloatValues();
for (int i = 0; i < retFloatArr.Length; i++)
{
Asserts.AreEqual(TestMatrices.FloatArray [i], retFloatArr [i], $"retFloatArr iter: {i}");
}
var retFloatArr2 = floatArr.GetFloatValues(5);
for (int i = 0; i < retFloatArr.Length; i++)
{
Asserts.AreEqual(retFloatArr [i], retFloatArr2 [i], $"retFloatArr2 iter: {i}");
}
var onesFloatArr = TestMatrices.CreateOnesArray <float> ((int)floatArr.ElementCount);
var timesFloatArr = new [] { 5d };
floatArr.Reset(onesFloatArr, timesFloatArr);
var floatValues = floatArr.GetFloatValues(5);
for (int i = 0; i < onesFloatArr.Length; i++)
{
Asserts.AreEqual(onesFloatArr [i], floatValues [i], $"onesFloatArr iter: {i}");
}
floatArr.Reset(Array.Empty <float> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)floatArr.TimeSampleCount, "floatArr.TimeSampleCount");
Assert.AreEqual(Array.Empty <float> (), floatArr.GetFloatValues(), "floatArr Empty");
// Doubles
var doubleArr = new MDLAnimatedScalarArray((nuint)TestMatrices.DoubleArray.Length);
doubleArr.SetValues(TestMatrices.DoubleArray, 5);
var retDoubleArr = doubleArr.GetDoubleValues();
for (int i = 0; i < retDoubleArr.Length; i++)
{
Asserts.AreEqual(TestMatrices.DoubleArray [i], retDoubleArr [i], $"retDoubleArr iter: {i}");
}
var retDoubleArr2 = doubleArr.GetDoubleValues(5);
for (int i = 0; i < retDoubleArr.Length; i++)
{
Asserts.AreEqual(retDoubleArr [i], retDoubleArr2 [i], $"retDoubleArr2 iter: {i}");
}
var onesDoubleArr = TestMatrices.CreateOnesArray <double> ((int)doubleArr.ElementCount);
var timesDoubleArr = new [] { 5d };
doubleArr.Reset(onesDoubleArr, timesDoubleArr);
var doubleValues = doubleArr.GetDoubleValues(5);
for (int i = 0; i < onesDoubleArr.Length; i++)
{
Asserts.AreEqual(onesDoubleArr [i], doubleValues [i], $"onesDoubleArr iter: {i}");
}
doubleArr.Reset(Array.Empty <double> (), Array.Empty <double> ());
Assert.AreEqual(0, (int)doubleArr.TimeSampleCount, "doubleArr.TimeSampleCount");
Assert.AreEqual(Array.Empty <double> (), doubleArr.GetFloatValues(), "doubleArr 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");
}
