adding tests

Author: Olivier Dionne

src/Tests/Tests/Shared/TestAffineTransform.cs

@@ -0,0 +1,72 @@
+using NUnit.Framework;
+using static Unity.Mathematics.math;
+using Burst.Compiler.IL.Tests;
+
+namespace Unity.Mathematics.Tests
+{
+    [TestFixture]
+    class TestAffineTransform
+    {
+        [TestCompiler]
+        public static void affine_transform_inverse()
+        {
+            const float tolerance = 1e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(math.float4(1, 2, 3, 4)), float3(2, 3, 4));
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_zero_rs_returns_zero()
+        {
+            const float tolerance = 1e-30f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3.zero);
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.zero, invTx, tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_pico_scale()
+        {
+            // slightly larger tolerance (vs 1e-6f) for PS4
+            const float tolerance = 2e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(1e-12f, 1e-12f, 1e-12f));
+            var invTx = inverse(tx);
+
+            TestUtils.AreEqual(float4x4.identity, float4x4(mul(tx, invTx)), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_inverse_singular()
+        {
+            // it needs a bit larger tolerance for singular
+            // since it uses the svd iterative solver
+            const float tolerance = 1e-1f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(0, 3, 4));
+            var invTx = inverse(tx);
+
+            // pseudo inverse penrose #1 test
+            var testTx = mul(mul(tx, invTx), tx);
+            TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
+        }
+
+        [TestCompiler]
+        public static void affine_transform_decompose()
+        {
+            const float tolerance = 1e-6f;
+
+            var tx = AffineTransform(float3(5, 6, 7), normalize(float4(1, 2, 3, 4)), float3(2, 3, 4));
+            decompose(tx, out var t, out var r, out var s);
+
+            // Recompose matrix
+            var testTx = AffineTransform(t, r, s);
+            TestUtils.AreEqual(float4x4(tx), float4x4(testTx), tolerance);
+        }
+    }
+}

src/Tests/Tests/Shared/TestAffineTransform.cs.meta

@@ -111,25 +111,25 @@ public string ToString(string format, IFormatProvider formatProvider)
     public static partial class math
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return AffineTransform(translation, rotation); }
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation) { return new AffineTransform(translation, rotation); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return AffineTransform(translation, rotation, scale); }
+        public static AffineTransform AffineTransform(float3 translation, quaternion rotation, float3 scale) { return new AffineTransform(translation, rotation, scale); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return AffineTransform(translation, rs); }
+        public static AffineTransform AffineTransform(float3 translation, float3x3 rs) { return new AffineTransform(translation, rs); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float4x4 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float4x4 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x4 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x4 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(float3x3 m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(float3x3 m) { return new AffineTransform(m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static AffineTransform AffineTransform(RigidTransform m) { return AffineTransform(m); }
+        public static AffineTransform AffineTransform(RigidTransform m) { return new AffineTransform (m); }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float4x4 float4x4(AffineTransform transform) { return float4x4(float4(transform.rs.c0, 0f), float4(transform.rs.c1, 0f), float4(transform.rs.c2, 0f), float4(transform.t, 1f)); }