solstice-anim

commit c6fbf1e852c658090891783c4994433d5817e909
parent 3317ccbcce83638088ec3fae64ab79d22154cb9f
Author: Christophe Coustet <christophe.coustet@meso-star.com>
Date:   Tue, 25 Oct 2016 14:42:51 +0200

Ease convergence constraint on the pointing algorithm.

Diffstat:
M
src/sanim_node.c
 | 
4
++--
M
src/test_sanim_node_pivot.c
 | 
62
+++++++++++++++++++++++++++++++-------------------------------
M
src/test_sanim_node_transform.c
 | 
16
++++++++--------

3 files changed, 41 insertions(+), 41 deletions(-)
diff --git a/src/sanim_node.c b/src/sanim_node.c
@@ -366,7 +366,7 @@ pivot_solve_single_axis_line
     }
     
     delta = previous_angle - angle;
-    if (fabs(delta) < 1e-10 || ++cpt > 100)
+    if (fabs(delta) < 1e-7 || ++cpt > 10)
       break;
 
     if (d2) {
@@ -585,7 +585,7 @@ pivot_solve_two_axis_point
       previous_angleZ += (angleZ > 0) ? 2 * PI : -2 * PI;
     }
     delta = MMAX(fabs(previous_angleX - angleX), fabs(previous_angleZ - angleZ));
-    if (delta < 1e-10 || ++cpt > 100)
+    if (delta < 1e-7 || ++cpt > 10)
       break;
 
     if (d2) {
diff --git a/src/test_sanim_node_pivot.c b/src/test_sanim_node_pivot.c
@@ -78,8 +78,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -sqrt(2), 3, 2), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -sqrt(2), 3, 2), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -133,8 +133,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(pivot.data.pivot1.ref_normal, n, 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(n, -1, 3, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(pivot.data.pivot1.ref_normal, n, 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(n, -1, 3, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -165,7 +165,7 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -194,7 +194,7 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -225,7 +225,7 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -254,8 +254,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, pivot.data.pivot1.ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -1, 0, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 1), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -1, 0, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 1), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -291,15 +291,15 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   d3(in_dir, 0, 1, 0);
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, 0, -1, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 0, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, 0, -1, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 0, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -329,15 +329,15 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   d3(in_dir, 0, 1, 0);
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, 0, -1, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 0, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, 0, -1, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 0, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -366,15 +366,15 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   d3(in_dir, -1, 0, 0);
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, 3 * sqrt(2) / 2, 2 + sqrt(2) / 2, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, 3 * sqrt(2) / 2, 2 + sqrt(2) / 2, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -405,8 +405,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, sqrt(2), 2, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, sqrt(2), 2, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -435,8 +435,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1 + sqrt(2), 3, 3), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, sqrt(2) / 2, sqrt(2) / 2, 0), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1 + sqrt(2), 3, 3), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -465,8 +465,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, -sqrt(2) / 2, 0, +sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, -1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -495,8 +495,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   CHECK(my_type_release(&t1), RES_OK);
   CHECK(my_type_release(&t2), RES_OK);
@@ -525,8 +525,8 @@ main(int argc, char** argv)
   CHECK(sanim_node_solve_pivot(&t2.node, in_dir), RES_OK);
   CHECK(my_type_get_transform(&t3, transform), RES_OK);
   d33_muld3(n, transform, y_ref_normal);
-  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-10), 1);
+  CHECK(d3_eq_eps(n, d3(tmp, 0, sqrt(2) / 2, sqrt(2) / 2), 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, d3(tmp, 1, 3, 2 + sqrt(2)), 1e-7), 1);
 
   /* release memory */
   CHECK(my_type_release(&t1), RES_OK);
diff --git a/src/test_sanim_node_transform.c b/src/test_sanim_node_transform.c
@@ -68,8 +68,8 @@ main(int argc, char** argv)
   CHECK(my_type_set_translation(&t2, transl), RES_OK);
 
   CHECK(my_type_get_transform(&t2, transform), RES_OK);
-  CHECK(d33_is_identity_eps(transform, 1e-10), 1);
-  CHECK(d3_is_zero_eps(transform + 9, 1e-10), 1);
+  CHECK(d33_is_identity_eps(transform, 1e-7), 1);
+  CHECK(d3_is_zero_eps(transform + 9, 1e-7), 1);
 
   /* check translation & 1 rotation in a single node VS in 2 chained nodes */
   d3(rot, 0.17, 0, 0);
@@ -88,8 +88,8 @@ main(int argc, char** argv)
   CHECK(my_type_set_translation(&t2, transl), RES_OK);
   CHECK(my_type_set_rotations(&t2, rot), RES_OK);
   CHECK(my_type_get_transform(&t2, transform_), RES_OK);
-  CHECK(d33_eq_eps(transform, transform_, 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-10), 1);
+  CHECK(d33_eq_eps(transform, transform_, 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-7), 1);
 
   /* check translation & 2 rotations in a single node VS in 2 chained nodes */
   d3(rot, 0.17, -0.52, 0);
@@ -108,8 +108,8 @@ main(int argc, char** argv)
   CHECK(my_type_set_translation(&t3, transl), RES_OK);
   CHECK(my_type_set_rotations(&t3, rot), RES_OK);
   CHECK(my_type_get_transform(&t3, transform_), RES_OK);
-  CHECK(d33_eq_eps(transform, transform_, 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-10), 1);
+  CHECK(d33_eq_eps(transform, transform_, 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-7), 1);
 
   /* check 1 node with 3 rotations VS 3 chained nodes with 1 rotation each */
   d3(rot, 0.17, -0.52, 0.31);
@@ -128,8 +128,8 @@ main(int argc, char** argv)
   CHECK(my_type_set_translation(&t3, transl), RES_OK);
   CHECK(my_type_set_rotations(&t3, rot), RES_OK);
   CHECK(my_type_get_transform(&t3, transform_), RES_OK);
-  CHECK(d33_eq_eps(transform, transform_, 1e-10), 1);
-  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-10), 1);
+  CHECK(d33_eq_eps(transform, transform_, 1e-7), 1);
+  CHECK(d3_eq_eps(transform + 9, transform_ + 9, 1e-7), 1);
 
   /* release memory */
   CHECK(my_type_release(&t1), RES_OK);