code cleanup: favor braces when blocks have mixed brace use.
[blender.git] / source / blender / blenlib / intern / math_geom.c
index 618c237c8ba216884b4c9099cb413f0c31639c9b..49be60dda36177bdaf68ea60cd9a3c8711da4f15 100644 (file)
@@ -39,9 +39,9 @@
 
 void cent_tri_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3])
 {
 
 void cent_tri_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3])
 {
-       cent[0] = 0.33333f * (v1[0] + v2[0] + v3[0]);
-       cent[1] = 0.33333f * (v1[1] + v2[1] + v3[1]);
-       cent[2] = 0.33333f * (v1[2] + v2[2] + v3[2]);
+       cent[0] = (v1[0] + v2[0] + v3[0]) / 3.0f;
+       cent[1] = (v1[1] + v2[1] + v3[1]) / 3.0f;
+       cent[2] = (v1[2] + v2[2] + v3[2]) / 3.0f;
 }
 
 void cent_quad_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
 }
 
 void cent_quad_v3(float cent[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
@@ -106,12 +106,12 @@ float area_quad_v3(const float v1[3], const float v2[3], const float v3[3], cons
        sub_v3_v3v3(vec1, v2, v1);
        sub_v3_v3v3(vec2, v4, v1);
        cross_v3_v3v3(n, vec1, vec2);
        sub_v3_v3v3(vec1, v2, v1);
        sub_v3_v3v3(vec2, v4, v1);
        cross_v3_v3v3(n, vec1, vec2);
-       len = normalize_v3(n);
+       len = len_v3(n);
 
        sub_v3_v3v3(vec1, v4, v3);
        sub_v3_v3v3(vec2, v2, v3);
        cross_v3_v3v3(n, vec1, vec2);
 
        sub_v3_v3v3(vec1, v4, v3);
        sub_v3_v3v3(vec2, v2, v3);
        cross_v3_v3v3(n, vec1, vec2);
-       len += normalize_v3(n);
+       len += len_v3(n);
 
        return (len / 2.0f);
 }
 
        return (len / 2.0f);
 }
@@ -119,14 +119,29 @@ float area_quad_v3(const float v1[3], const float v2[3], const float v3[3], cons
 /* Triangles */
 float area_tri_v3(const float v1[3], const float v2[3], const float v3[3])
 {
 /* Triangles */
 float area_tri_v3(const float v1[3], const float v2[3], const float v3[3])
 {
-       float len, vec1[3], vec2[3], n[3];
+       float vec1[3], vec2[3], n[3];
 
        sub_v3_v3v3(vec1, v3, v2);
        sub_v3_v3v3(vec2, v1, v2);
        cross_v3_v3v3(n, vec1, vec2);
 
        sub_v3_v3v3(vec1, v3, v2);
        sub_v3_v3v3(vec2, v1, v2);
        cross_v3_v3v3(n, vec1, vec2);
-       len = normalize_v3(n);
 
 
-       return (len / 2.0f);
+       return len_v3(n) / 2.0f;
+}
+
+float area_tri_signed_v3(const float v1[3], const float v2[3], const float v3[3], const float normal[3])
+{
+       float area, vec1[3], vec2[3], n[3];
+
+       sub_v3_v3v3(vec1, v3, v2);
+       sub_v3_v3v3(vec2, v1, v2);
+       cross_v3_v3v3(n, vec1, vec2);
+       area = len_v3(n) / 2.0f;
+
+       /* negate area for flipped triangles */
+       if (dot_v3v3(n, normal) < 0.0f)
+               area = -area;
+
+       return area;
 }
 
 float area_poly_v3(int nr, float verts[][3], const float normal[3])
 }
 
 float area_poly_v3(int nr, float verts[][3], const float normal[3])
@@ -1985,10 +2000,7 @@ bool axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3])
        float angle;
 
        /* double check they are normalized */
        float angle;
 
        /* double check they are normalized */
-#ifdef DEBUG
-       float test;
-       BLI_assert(fabsf((test = len_squared_v3(normal)) - 1.0f) < 0.0001f || fabsf(test) < 0.0001f);
-#endif
+       BLI_ASSERT_UNIT_V3(normal);
 
        cross_v3_v3v3(axis, normal, up);
        angle = saacos(dot_v3v3(normal, up));
 
        cross_v3_v3v3(axis, normal, up);
        angle = saacos(dot_v3v3(normal, up));
@@ -2551,7 +2563,9 @@ void resolve_tri_uv(float r_uv[2], const float st[2], const float st0[2], const
                r_uv[0] = (float)((d * x[0] - b * x[1]) / det);
                r_uv[1] = (float)(((-c) * x[0] + a * x[1]) / det);
        }
                r_uv[0] = (float)((d * x[0] - b * x[1]) / det);
                r_uv[1] = (float)(((-c) * x[0] + a * x[1]) / det);
        }
-       else zero_v2(r_uv);
+       else {
+               zero_v2(r_uv);
+       }
 }
 
 /* bilinear reverse */
 }
 
 /* bilinear reverse */
@@ -3050,7 +3064,9 @@ void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight, fl
                                add_v3_v3(accu_com, v);
                                accu_weight += weight[a];
                        }
                                add_v3_v3(accu_com, v);
                                accu_weight += weight[a];
                        }
-                       else add_v3_v3(accu_com, pos[a]);
+                       else {
+                               add_v3_v3(accu_com, pos[a]);
+                       }
 
                        if (rweight) {
                                float v[3];
 
                        if (rweight) {
                                float v[3];
@@ -3059,8 +3075,9 @@ void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight, fl
                                add_v3_v3(accu_rcom, v);
                                accu_rweight += rweight[a];
                        }
                                add_v3_v3(accu_rcom, v);
                                accu_rweight += rweight[a];
                        }
-                       else add_v3_v3(accu_rcom, rpos[a]);
-
+                       else {
+                               add_v3_v3(accu_rcom, rpos[a]);
+                       }
                }
                if (!weight || !rweight) {
                        accu_weight = accu_rweight = list_size;
                }
                if (!weight || !rweight) {
                        accu_weight = accu_rweight = list_size;
@@ -3158,9 +3175,9 @@ static void vec_add_dir(float r[3], const float v1[3], const float v2[3], const
        r[2] = v1[2] + fac * (v2[2] - v1[2]);
 }
 
        r[2] = v1[2] + fac * (v2[2] - v1[2]);
 }
 
-static int ff_visible_quad(const float p[3], const float n[3],
-                           const float v0[3], const float v1[3], const float v2[3],
-                           float q0[3], float q1[3], float q2[3], float q3[3])
+int form_factor_visible_quad(const float p[3], const float n[3],
+                             const float v0[3], const float v1[3], const float v2[3],
+                             float q0[3], float q1[3], float q2[3], float q3[3])
 {
        static const float epsilon = 1e-6f;
        float c, sd[3];
 {
        static const float epsilon = 1e-6f;
        float c, sd[3];
@@ -3519,8 +3536,8 @@ static void ff_normalize(float n[3])
        }
 }
 
        }
 }
 
-static float ff_quad_form_factor(const float p[3], const float n[3],
-                                 const float q0[3], const float q1[3], const float q2[3], const float q3[3])
+float form_factor_quad(const float p[3], const float n[3],
+                       const float q0[3], const float q1[3], const float q2[3], const float q3[3])
 {
        float r0[3], r1[3], r2[3], r3[3], g0[3], g1[3], g2[3], g3[3];
        float a1, a2, a3, a4, dot1, dot2, dot3, dot4, result;
 {
        float r0[3], r1[3], r2[3], r3[3], g0[3], g1[3], g2[3], g3[3];
        float a1, a2, a3, a4, dot1, dot2, dot3, dot4, result;
@@ -3566,11 +3583,11 @@ float form_factor_hemi_poly(float p[3], float n[3], float v1[3], float v2[3], fl
         * covered by a quad or triangle, cosine weighted */
        float q0[3], q1[3], q2[3], q3[3], contrib = 0.0f;
 
         * covered by a quad or triangle, cosine weighted */
        float q0[3], q1[3], q2[3], q3[3], contrib = 0.0f;
 
-       if (ff_visible_quad(p, n, v1, v2, v3, q0, q1, q2, q3))
-               contrib += ff_quad_form_factor(p, n, q0, q1, q2, q3);
+       if (form_factor_visible_quad(p, n, v1, v2, v3, q0, q1, q2, q3))
+               contrib += form_factor_quad(p, n, q0, q1, q2, q3);
 
 
-       if (v4 && ff_visible_quad(p, n, v1, v3, v4, q0, q1, q2, q3))
-               contrib += ff_quad_form_factor(p, n, q0, q1, q2, q3);
+       if (v4 && form_factor_visible_quad(p, n, v1, v3, v4, q0, q1, q2, q3))
+               contrib += form_factor_quad(p, n, q0, q1, q2, q3);
 
        return contrib;
 }
 
        return contrib;
 }
@@ -3578,29 +3595,42 @@ float form_factor_hemi_poly(float p[3], float n[3], float v1[3], float v2[3], fl
 /* evaluate if entire quad is a proper convex quad */
 int is_quad_convex_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3])
 {
 /* evaluate if entire quad is a proper convex quad */
 int is_quad_convex_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3])
 {
-       float nor[3], nor1[3], nor2[3], vec[4][2];
+       float nor[3], nor_a[3], nor_b[3], vec[4][2];
        float mat[3][3];
        float mat[3][3];
+       const bool is_ok_a = (normal_tri_v3(nor_a, v1, v2, v3) > FLT_EPSILON);
+       const bool is_ok_b = (normal_tri_v3(nor_b, v1, v3, v4) > FLT_EPSILON);
 
        /* define projection, do both trias apart, quad is undefined! */
 
        /* check normal length incase one size is zero area */
 
        /* define projection, do both trias apart, quad is undefined! */
 
        /* check normal length incase one size is zero area */
-       if (UNLIKELY((normal_tri_v3(nor1, v1, v2, v3) <= FLT_EPSILON) ||
-                    (normal_tri_v3(nor2, v1, v3, v4) <= FLT_EPSILON)))
-       {
-               return false;
-       }
+       if (is_ok_a) {
+               if (is_ok_b) {
+                       /* use both, most common outcome */
+
+                       /* when the face is folded over as 2 tris we probably don't want to create
+                        * a quad from it, but go ahead with the intersection test since this
+                        * isn't a function for degenerate faces */
+                       if (UNLIKELY(dot_v3v3(nor_a, nor_b) < 0.0f)) {
+                               /* flip so adding normals in the opposite direction
+                                * doesn't give a zero length vector */
+                               negate_v3(nor_b);
+                       }
 
 
-       /* when the face is folded over as 2 tris we probably don't want to create
-        * a quad from it, but go ahead with the intersection test since this
-        * isn't a function for degenerate faces */
-       if (UNLIKELY(dot_v3v3(nor1, nor2) < 0.0f)) {
-               /* flip so adding normals in the opposite direction
-                * doesnt give a zero length vector */
-               negate_v3(nor2);
+                       add_v3_v3v3(nor, nor_a, nor_b);
+                       normalize_v3(nor);
+               }
+               else {
+                       copy_v3_v3(nor, nor_a);  /* only 'a' */
+               }
+       }
+       else {
+               if (is_ok_b) {
+                       copy_v3_v3(nor, nor_b);  /* only 'b' */
+               }
+               else {
+                       return false;  /* both zero, we can't do anything useful here */
+               }
        }
        }
-
-       add_v3_v3v3(nor, nor1, nor2);
-       normalize_v3(nor);
 
        axis_dominant_v3_to_m3(mat, nor);
 
 
        axis_dominant_v3_to_m3(mat, nor);
 
@@ -3610,12 +3640,12 @@ int is_quad_convex_v3(const float v1[3], const float v2[3], const float v3[3], c
        mul_v2_m3v3(vec[3], mat, v4);
 
        /* linetests, the 2 diagonals have to instersect to be convex */
        mul_v2_m3v3(vec[3], mat, v4);
 
        /* linetests, the 2 diagonals have to instersect to be convex */
-       return (isect_line_line_v2(vec[0], vec[2], vec[1], vec[3]) == ISECT_LINE_LINE_CROSS);
+       return (isect_line_line_v2(vec[0], vec[2], vec[1], vec[3]) > 0);
 }
 
 int is_quad_convex_v2(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
        /* linetests, the 2 diagonals have to instersect to be convex */
 }
 
 int is_quad_convex_v2(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
        /* linetests, the 2 diagonals have to instersect to be convex */
-       return (isect_line_line_v2(v1, v3, v2, v4) == ISECT_LINE_LINE_CROSS);
+       return (isect_line_line_v2(v1, v3, v2, v4) > 0);
 }
 
 }