Cleanup: Math lib naming (use v3 suffix)
authorCampbell Barton <ideasman42@gmail.com>
Fri, 6 Oct 2017 10:05:34 +0000 (21:05 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 6 Oct 2017 10:06:38 +0000 (21:06 +1100)
source/blender/blenkernel/intern/mball_tessellate.c
source/blender/blenkernel/intern/mesh_evaluate.c
source/blender/blenkernel/intern/pbvh.c
source/blender/blenkernel/intern/softbody.c
source/blender/blenlib/BLI_math_geom.h
source/blender/blenlib/intern/math_geom.c
source/blender/bmesh/intern/bmesh_mesh.c
source/blender/editors/sculpt_paint/paint_vertex.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/render/intern/source/convertblender.c

index 76965176be82325262d669763d22b8be0a5ba26b..82d82ce71c4aa6407712cf29e416f5d78dc0d373 100644 (file)
@@ -423,13 +423,13 @@ static void make_face(PROCESS *process, int i1, int i2, int i3, int i4)
 #ifdef USE_ACCUM_NORMAL
        if (i4 == 0) {
                normal_tri_v3(n, process->co[i1], process->co[i2], process->co[i3]);
-               accumulate_vertex_normals(
+               accumulate_vertex_normals_v3(
                        process->no[i1], process->no[i2], process->no[i3], NULL, n,
                        process->co[i1], process->co[i2], process->co[i3], NULL);
        }
        else {
                normal_quad_v3(n, process->co[i1], process->co[i2], process->co[i3], process->co[i4]);
-               accumulate_vertex_normals(
+               accumulate_vertex_normals_v3(
                        process->no[i1], process->no[i2], process->no[i3], process->no[i4], n,
                        process->co[i1], process->co[i2], process->co[i3], process->co[i4]);
        }
index 643ca3ee5367af02faeaafa6f4d63a641029fd0b..b28ec7f4fff5d6ff0638445a9f598e35d48f2cac 100644 (file)
@@ -225,7 +225,7 @@ static void mesh_calc_normals_poly_accum_task_cb(void *userdata, const int pidx)
        }
 
        /* accumulate angle weighted face normal */
-       /* inline version of #accumulate_vertex_normals_poly */
+       /* inline version of #accumulate_vertex_normals_poly_v3 */
        {
                const float *prev_edge = edgevecbuf[nverts - 1];
 
@@ -334,8 +334,9 @@ void BKE_mesh_calc_normals_tessface(
                else
                        normal_tri_v3(f_no, mverts[mf->v1].co, mverts[mf->v2].co, mverts[mf->v3].co);
 
-               accumulate_vertex_normals(tnorms[mf->v1], tnorms[mf->v2], tnorms[mf->v3], n4,
-                                         f_no, mverts[mf->v1].co, mverts[mf->v2].co, mverts[mf->v3].co, c4);
+               accumulate_vertex_normals_v3(
+                       tnorms[mf->v1], tnorms[mf->v2], tnorms[mf->v3], n4,
+                       f_no, mverts[mf->v1].co, mverts[mf->v2].co, mverts[mf->v3].co, c4);
        }
 
        /* following Mesh convention; we use vertex coordinate itself for normal in this case */
@@ -379,7 +380,7 @@ void BKE_mesh_calc_normals_looptri(
                        f_no,
                        mverts[vtri[0]].co, mverts[vtri[1]].co, mverts[vtri[2]].co);
 
-               accumulate_vertex_normals_tri(
+               accumulate_vertex_normals_tri_v3(
                        tnorms[vtri[0]], tnorms[vtri[1]], tnorms[vtri[2]],
                        f_no, mverts[vtri[0]].co, mverts[vtri[1]].co, mverts[vtri[2]].co);
        }
@@ -845,7 +846,7 @@ static void split_loop_nor_fan_do(LoopSplitTaskDataCommon *common_data, LoopSpli
 //             printf("\thandling edge %d / loop %d\n", mlfan_curr->e, mlfan_curr_index);
 
                {
-                       /* Code similar to accumulate_vertex_normals_poly. */
+                       /* Code similar to accumulate_vertex_normals_poly_v3. */
                        /* Calculate angle between the two poly edges incident on this vertex. */
                        const float fac = saacos(dot_v3v3(vec_curr, vec_prev));
                        /* Accumulate */
index d739f804fef93ee46ef5166fd2def4433ca58c8d..aa8ab07518f559dbe320840fb685d24a221125a8 100644 (file)
@@ -1837,7 +1837,7 @@ static bool nearest_to_ray_aabb_dist_sq(PBVHNode *node, void *data_v)
        }
 
        float co_dummy[3], depth;
-       node->tmin = dist_squared_ray_to_aabb(&rcd->dist_ray_to_aabb_precalc, bb_min, bb_max, co_dummy, &depth);
+       node->tmin = dist_squared_ray_to_aabb_v3(&rcd->dist_ray_to_aabb_precalc, bb_min, bb_max, co_dummy, &depth);
        /* Ideally we would skip distances outside the range. */
        return depth > 0.0f;
 }
@@ -1849,7 +1849,7 @@ void BKE_pbvh_find_nearest_to_ray(
 {
        FindNearestRayData ncd;
 
-       dist_squared_ray_to_aabb_precalc(&ncd.dist_ray_to_aabb_precalc, ray_start, ray_normal);
+       dist_squared_ray_to_aabb_v3_precalc(&ncd.dist_ray_to_aabb_precalc, ray_start, ray_normal);
        ncd.original = original;
 
        BKE_pbvh_search_callback_occluded(bvh, nearest_to_ray_aabb_dist_sq, &ncd, cb, data);
index 600bc3f453de804337eab797d189bd9800ef5c4a..3052a70813700e6361cee137bf27dd253d7a1311 100644 (file)
@@ -3412,7 +3412,7 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
  * lloc, lrot, lscale are allowed to be NULL, just in case you don't need it.
  * should be pretty useful for pythoneers :)
  * not! velocity .. 2nd order stuff
- * vcloud_estimate_transform see
+ * vcloud_estimate_transform_v3 see
  */
 
 void SB_estimate_transform(Object *ob, float lloc[3], float lrot[3][3], float lscale[3][3])
@@ -3436,7 +3436,7 @@ void SB_estimate_transform(Object *ob, float lloc[3], float lrot[3][3], float ls
                copy_v3_v3(opos[a], bp->pos);
        }
 
-       vcloud_estimate_transform(sb->totpoint, opos, NULL, rpos, NULL, com, rcom, lrot, lscale);
+       vcloud_estimate_transform_v3(sb->totpoint, opos, NULL, rpos, NULL, com, rcom, lrot, lscale);
        //sub_v3_v3(com, rcom);
        if (lloc) copy_v3_v3(lloc, com);
        copy_v3_v3(sb->lcom, com);
index d0b5924438407503933f347d7f423ceaa9b42c8e..933e31ba84bfc2a93be9dceeb9e90f6231a078a4 100644 (file)
@@ -126,15 +126,15 @@ struct DistRayAABB_Precalc {
        float ray_inv_dir[3];
        bool sign[3];
 };
-void dist_squared_ray_to_aabb_precalc(
+void dist_squared_ray_to_aabb_v3_precalc(
         struct DistRayAABB_Precalc *neasrest_precalc,
         const float ray_origin[3], const float ray_direction[3]);
-float dist_squared_ray_to_aabb(
+float dist_squared_ray_to_aabb_v3(
         const struct DistRayAABB_Precalc *data,
         const float bb_min[3], const float bb_max[3],
         float r_point[3], float *r_depth);
 /* when there is no advantage to precalc. */
-float dist_squared_to_ray_to_aabb_simple(
+float dist_squared_ray_to_aabb_v3_simple(
         const float ray_origin[3], const float ray_direction[3],
         const float bb_min[3], const float bb_max[3],
         float r_point[3], float *r_depth);
@@ -407,23 +407,23 @@ void map_to_plane_axis_angle_v2_v3v3fl(float r_co[2], const float co[3], const f
 
 /********************************** Normals **********************************/
 
-void accumulate_vertex_normals_tri(
+void accumulate_vertex_normals_tri_v3(
         float n1[3], float n2[3], float n3[3],
         const float f_no[3],
         const float co1[3], const float co2[3], const float co3[3]);
 
-void accumulate_vertex_normals(
+void accumulate_vertex_normals_v3(
         float n1[3], float n2[3], float n3[3], float n4[3],
         const float f_no[3],
         const float co1[3], const float co2[3], const float co3[3], const float co4[3]);
 
-void accumulate_vertex_normals_poly(
+void accumulate_vertex_normals_poly_v3(
         float **vertnos, const float polyno[3],
         const float **vertcos, float vdiffs[][3], const int nverts);
 
 /********************************* Tangents **********************************/
 
-void tangent_from_uv(
+void tangent_from_uv_v3(
         const float uv1[2], const float uv2[2], const float uv3[2],
         const float co1[3], const float co2[3], const float co3[3],
         const float n[3],
@@ -431,9 +431,9 @@ void tangent_from_uv(
 
 /******************************** Vector Clouds ******************************/
 
-void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight,
-                               float (*rpos)[3], float *rweight,
-                               float lloc[3], float rloc[3], float lrot[3][3], float lscale[3][3]);
+void vcloud_estimate_transform_v3(
+        const int list_size, const float (*pos)[3], const float *weight, const float (*rpos)[3], const float *rweight,
+        float lloc[3], float rloc[3], float lrot[3][3], float lscale[3][3]);
 
 /****************************** Spherical Harmonics *************************/
 
@@ -464,7 +464,7 @@ float form_factor_hemi_poly(float p[3], float n[3],
                             float v1[3], float v2[3], float v3[3], float v4[3]);
 
 void axis_dominant_v3_to_m3_negate(float r_mat[3][3], const float normal[3]);
-void  axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3]);
+void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3]);
 
 MINLINE void  axis_dominant_v3(int *r_axis_a, int *r_axis_b, const float axis[3]);
 MINLINE float axis_dominant_v3_max(int *r_axis_a, int *r_axis_b, const float axis[3]) ATTR_WARN_UNUSED_RESULT;
index dbbc1adb5344a6e4b1411a59ed527c5945068ea6..d3080e5530f84e854c36416ea7a4c4c505c3655b 100644 (file)
@@ -623,7 +623,7 @@ float dist_squared_ray_to_seg_v3(
 /** \name dist_squared_to_ray_to_aabb and helpers
  * \{ */
 
-void dist_squared_ray_to_aabb_precalc(
+void dist_squared_ray_to_aabb_v3_precalc(
         struct DistRayAABB_Precalc *neasrest_precalc,
         const float ray_origin[3], const float ray_direction[3])
 {
@@ -641,7 +641,7 @@ void dist_squared_ray_to_aabb_precalc(
 /**
  * Returns the distance from a ray to a bound-box (projected on ray)
  */
-float dist_squared_ray_to_aabb(
+float dist_squared_ray_to_aabb_v3(
         const struct DistRayAABB_Precalc *data,
         const float bb_min[3], const float bb_max[3],
         float r_point[3], float *r_depth)
@@ -753,14 +753,14 @@ float dist_squared_ray_to_aabb(
                r_point, r_depth);
 }
 
-float dist_squared_to_ray_to_aabb_simple(
+float dist_squared_ray_to_aabb_v3_simple(
         const float ray_origin[3], const float ray_direction[3],
         const float bbmin[3], const float bbmax[3],
         float r_point[3], float *r_depth)
 {
        struct DistRayAABB_Precalc data;
-       dist_squared_ray_to_aabb_precalc(&data, ray_origin, ray_direction);
-       return dist_squared_ray_to_aabb(&data, bbmin, bbmax, r_point, r_depth);
+       dist_squared_ray_to_aabb_v3_precalc(&data, ray_origin, ray_direction);
+       return dist_squared_ray_to_aabb_v3(&data, bbmin, bbmax, r_point, r_depth);
 }
 /** \} */
 
@@ -4053,7 +4053,7 @@ void map_to_plane_axis_angle_v2_v3v3fl(float r_co[2], const float co[3], const f
 
 /********************************* Normals **********************************/
 
-void accumulate_vertex_normals_tri(
+void accumulate_vertex_normals_tri_v3(
         float n1[3], float n2[3], float n3[3],
         const float f_no[3],
         const float co1[3], const float co2[3], const float co3[3])
@@ -4087,7 +4087,7 @@ void accumulate_vertex_normals_tri(
        }
 }
 
-void accumulate_vertex_normals(
+void accumulate_vertex_normals_v3(
         float n1[3], float n2[3], float n3[3], float n4[3],
         const float f_no[3],
         const float co1[3], const float co2[3], const float co3[3], const float co4[3])
@@ -4131,7 +4131,7 @@ void accumulate_vertex_normals(
 
 /* Add weighted face normal component into normals of the face vertices.
  * Caller must pass pre-allocated vdiffs of nverts length. */
-void accumulate_vertex_normals_poly(float **vertnos, const float polyno[3],
+void accumulate_vertex_normals_poly_v3(float **vertnos, const float polyno[3],
                                     const float **vertcos, float vdiffs[][3], const int nverts)
 {
        int i;
@@ -4162,7 +4162,7 @@ void accumulate_vertex_normals_poly(float **vertnos, const float polyno[3],
 
 /********************************* Tangents **********************************/
 
-void tangent_from_uv(
+void tangent_from_uv_v3(
         const float uv1[2], const float uv2[2], const float uv3[3],
         const float co1[3], const float co2[3], const float co3[3],
         const float n[3],
@@ -4204,30 +4204,28 @@ void tangent_from_uv(
 /****************************** Vector Clouds ********************************/
 
 /* vector clouds */
-/* void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight, float (*rpos)[3], float *rweight,
- *                                float lloc[3], float rloc[3], float lrot[3][3], float lscale[3][3])
- *
+/**
  * input
- * (
- * int list_size
- * 4 lists as pointer to array[list_size]
- * 1. current pos array of 'new' positions
- * 2. current weight array of 'new'weights (may be NULL pointer if you have no weights )
- * 3. reference rpos array of 'old' positions
- * 4. reference rweight array of 'old'weights (may be NULL pointer if you have no weights )
- * )
+ *
+ * \param list_size: 4 lists as pointer to array[list_size]
+ * \param pos: current pos array of 'new' positions
+ * \param weight: current weight array of 'new'weights (may be NULL pointer if you have no weights)
+ * \param rpos: Reference rpos array of 'old' positions
+ * \param rweight: Reference rweight array of 'old'weights (may be NULL pointer if you have no weights).
+ *
  * output
- * (
- * float lloc[3] center of mass pos
- * float rloc[3] center of mass rpos
- * float lrot[3][3] rotation matrix
- * float lscale[3][3] scale matrix
+ *
+ * \param lloc: Center of mass pos.
+ * \param rloc: Center of mass rpos.
+ * \param lrot: Rotation matrix.
+ * \param lscale: Scale matrix.
+ *
  * pointers may be NULL if not needed
- * )
  */
 
-void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight, float (*rpos)[3], float *rweight,
-                               float lloc[3], float rloc[3], float lrot[3][3], float lscale[3][3])
+void vcloud_estimate_transform_v3(
+        const int list_size, const float (*pos)[3], const float *weight, const float (*rpos)[3], const float *rweight,
+        float lloc[3], float rloc[3], float lrot[3][3], float lscale[3][3])
 {
        float accu_com[3] = {0.0f, 0.0f, 0.0f}, accu_rcom[3] = {0.0f, 0.0f, 0.0f};
        float accu_weight = 0.0f, accu_rweight = 0.0f;
index d5d9e4abe2c7b33d0708eaa1c581f6d7d2f82e0d..2ff670c770e83747b58f38e83ffebfcced980195 100644 (file)
@@ -775,7 +775,7 @@ static void bm_mesh_loops_calc_normals(
                                        }
 
                                        {
-                                               /* Code similar to accumulate_vertex_normals_poly. */
+                                               /* Code similar to accumulate_vertex_normals_poly_v3. */
                                                /* Calculate angle between the two poly edges incident on this vertex. */
                                                const BMFace *f = lfan_pivot->f;
                                                const float fac = saacos(dot_v3v3(vec_next, vec_curr));
index 6a1dbfc6b469b268e875c37b47b04b83e6b2008b..65306f1dd86603e4ab50161b21b95122767be83a 100644 (file)
@@ -1907,7 +1907,7 @@ static PBVHNode **vwpaint_pbvh_gather_generic(
        }
        else {
                struct DistRayAABB_Precalc dist_ray_to_aabb_precalc;
-               dist_squared_ray_to_aabb_precalc(&dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
+               dist_squared_ray_to_aabb_v3_precalc(&dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
                SculptSearchCircleData data = {
                        .ss = ss,
                        .sd = sd,
index ad58adfe4affe99e0da17dd1fd7d20117b906f59..84bb4652d33ea4052e7b07922d97d85928209ec8 100644 (file)
@@ -1278,7 +1278,7 @@ bool sculpt_search_circle_cb(PBVHNode *node, void *data_v)
                BKE_pbvh_node_get_BB(node, bb_min, bb_min);
 
        float dummy_co[3], dummy_depth;
-       const float dist_sq = dist_squared_ray_to_aabb(
+       const float dist_sq = dist_squared_ray_to_aabb_v3(
                data->dist_ray_to_aabb_precalc, bb_min, bb_max, dummy_co, &dummy_depth);
 
        return dist_sq < data->radius_squared || 1;
@@ -1318,7 +1318,7 @@ static PBVHNode **sculpt_pbvh_gather_generic(
        }
        else {
                struct DistRayAABB_Precalc dist_ray_to_aabb_precalc;
-               dist_squared_ray_to_aabb_precalc(&dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
+               dist_squared_ray_to_aabb_v3_precalc(&dist_ray_to_aabb_precalc, ss->cache->location, ss->cache->view_normal);
                SculptSearchCircleData data = {
                        .ss = ss,
                        .sd = sd,
index 9633d95855e91715b7ddcabc60aebc350660b60c..fd46acc363839a07aa93c5e64499d30c41ee4632 100644 (file)
@@ -271,7 +271,7 @@ static void calc_tangent_vector(ObjectRen *obr, VlakRen *vlr, int do_tangent)
        }
        else return;
 
-       tangent_from_uv(uv1, uv2, uv3, v1->co, v2->co, v3->co, vlr->n, tang);
+       tangent_from_uv_v3(uv1, uv2, uv3, v1->co, v2->co, v3->co, vlr->n, tang);
        
        if (do_tangent) {
                tav= RE_vertren_get_tangent(obr, v1, 1);
@@ -283,7 +283,7 @@ static void calc_tangent_vector(ObjectRen *obr, VlakRen *vlr, int do_tangent)
        }
        
        if (v4) {
-               tangent_from_uv(uv1, uv3, uv4, v1->co, v3->co, v4->co, vlr->n, tang);
+               tangent_from_uv_v3(uv1, uv3, uv4, v1->co, v3->co, v4->co, vlr->n, tang);
                
                if (do_tangent) {
                        tav= RE_vertren_get_tangent(obr, v1, 1);
@@ -398,7 +398,7 @@ static void calc_vertexnormals(Render *UNUSED(re), ObjectRen *obr, bool do_verte
                        float *n4= (vlr->v4)? vlr->v4->n: NULL;
                        const float *c4= (vlr->v4)? vlr->v4->co: NULL;
 
-                       accumulate_vertex_normals(vlr->v1->n, vlr->v2->n, vlr->v3->n, n4,
+                       accumulate_vertex_normals_v3(vlr->v1->n, vlr->v2->n, vlr->v3->n, n4,
                                vlr->n, vlr->v1->co, vlr->v2->co, vlr->v3->co, c4);
                }
                if (do_tangent) {