sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

Code cleanup: suffix vars to make obvious they are squared

Browse Source
This commit is contained in:
Campbell Barton 2014-02-03 02:46:45 +11:00
parent dda63375b2
commit fed1b8b16d
37 changed files with 218 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_bvhutils.h
View File

@ -108,7 +108,7 @@ void free_bvhtree_from_mesh(struct BVHTreeFromMesh *data);
* Math functions used by callbacks * Math functions used by callbacks
*/ */
float bvhtree_ray_tri_intersection(const BVHTreeRay *ray, const float m_dist, const float v0[3], const float v1[3], const float v2[3]); float bvhtree_ray_tri_intersection(const BVHTreeRay *ray, const float m_dist, const float v0[3], const float v1[3], const float v2[3]);
float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const float v2[3], const float p[3], int *v, int *e, float nearest[3]); float nearest_point_in_tri_surface_squared(const float v0[3], const float v1[3], const float v2[3], const float p[3], int *v, int *e, float nearest[3]);
/* /*
* BVHCache * BVHCache

4
source/blender/blenkernel/BKE_editmesh_bvh.h
View File

@ -53,8 +53,8 @@ struct BMFace *BKE_bmbvh_ray_cast(BMBVHTree *tree, const float co[3], const flo
/* find a face intersecting a segment (but not apart of the segment) */ /* find a face intersecting a segment (but not apart of the segment) */
struct BMFace *BKE_bmbvh_find_face_segment(BMBVHTree *tree, const float co_a[3], const float co_b[3], struct BMFace *BKE_bmbvh_find_face_segment(BMBVHTree *tree, const float co_a[3], const float co_b[3],
float *r_fac, float r_hitout[3], float r_cagehit[3]); float *r_fac, float r_hitout[3], float r_cagehit[3]);
/* find a vert closest to co in a sphere of radius maxdist */ /* find a vert closest to co in a sphere of radius dist_max */
struct BMVert *BKE_bmbvh_find_vert_closest(BMBVHTree *tree, const float co[3], const float maxdist); struct BMVert *BKE_bmbvh_find_vert_closest(BMBVHTree *tree, const float co[3], const float dist_max);
/* BKE_bmbvh_new flag parameter */ /* BKE_bmbvh_new flag parameter */
enum { enum {

14
source/blender/blenkernel/intern/armature.c
View File

@ -663,7 +663,7 @@ static void b_bone_deform(bPoseChanDeform *pdef_info, Bone *bone, float co[3], D
/* using vec with dist to bone b1 - b2 */ /* using vec with dist to bone b1 - b2 */
float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3], float rad1, float rad2, float rdist) float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3], float rad1, float rad2, float rdist)
{ {
float dist = 0.0f; float dist_sq;
float bdelta[3]; float bdelta[3];
float pdelta[3]; float pdelta[3];
float hsqr, a, l, rad; float hsqr, a, l, rad;
@ -678,16 +678,16 @@ float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3
if (a < 0.0f) { if (a < 0.0f) {
/* If we're past the end of the bone, do a spherical field attenuation thing */ /* If we're past the end of the bone, do a spherical field attenuation thing */
dist = len_squared_v3v3(b1, vec); dist_sq = len_squared_v3v3(b1, vec);
rad = rad1; rad = rad1;
} }
else if (a > l) { else if (a > l) {
/* If we're past the end of the bone, do a spherical field attenuation thing */ /* If we're past the end of the bone, do a spherical field attenuation thing */
dist = len_squared_v3v3(b2, vec); dist_sq = len_squared_v3v3(b2, vec);
rad = rad2; rad = rad2;
} }
else { else {
dist = (hsqr - (a * a)); dist_sq = (hsqr - (a * a));
if (l != 0.0f) { if (l != 0.0f) {
rad = a / l; rad = a / l;
@ -698,15 +698,15 @@ float distfactor_to_bone(const float vec[3], const float b1[3], const float b2[3
} }
a = rad * rad; a = rad * rad;
if (dist < a) if (dist_sq < a)
return 1.0f; return 1.0f;
else { else {
l = rad + rdist; l = rad + rdist;
l *= l; l *= l;
if (rdist == 0.0f || dist >= l) if (rdist == 0.0f || dist_sq >= l)
return 0.0f; return 0.0f;
else { else {
a = sqrtf(dist) - rad; a = sqrtf(dist_sq) - rad;
return 1.0f - (a * a) / (rdist * rdist); return 1.0f - (a * a) / (rdist * rdist);
} }
} }

28
source/blender/blenkernel/intern/bvhutils.c
View File

@ -82,7 +82,9 @@ static float sphereray_tri_intersection(const BVHTreeRay *ray, float radius, con
* Function adapted from David Eberly's distance tools (LGPL) * Function adapted from David Eberly's distance tools (LGPL)
* http://www.geometrictools.com/LibFoundation/Distance/Distance.html * http://www.geometrictools.com/LibFoundation/Distance/Distance.html
*/ */
float nearest_point_in_tri_surface(const float v0[3], const float v1[3], const float v2[3], const float p[3], int *v, int *e, float nearest[3]) float nearest_point_in_tri_surface_squared(
const float v0[3], const float v1[3], const float v2[3],
const float p[3], int *v, int *e, float nearest[3])
{ {
float diff[3]; float diff[3];
float e0[3]; float e0[3];
@ -377,13 +379,13 @@ static void mesh_faces_nearest_point(void *userdata, int index, const float co[3
do { do {
float nearest_tmp[3], dist; float nearest_tmp[3], dist_sq;
int vertex, edge; int vertex, edge;
dist = nearest_point_in_tri_surface(t0, t1, t2, co, &vertex, &edge, nearest_tmp); dist_sq = nearest_point_in_tri_surface_squared(t0, t1, t2, co, &vertex, &edge, nearest_tmp);
if (dist < nearest->dist) { if (dist_sq < nearest->dist_sq) {
nearest->index = index; nearest->index = index;
nearest->dist = dist; nearest->dist_sq = dist_sq;
copy_v3_v3(nearest->co, nearest_tmp); copy_v3_v3(nearest->co, nearest_tmp);
normal_tri_v3(nearest->no, t0, t1, t2); normal_tri_v3(nearest->no, t0, t1, t2);
@ -410,13 +412,13 @@ static void editmesh_faces_nearest_point(void *userdata, int index, const float
t2 = ltri[2]->v->co; t2 = ltri[2]->v->co;
{ {
float nearest_tmp[3], dist; float nearest_tmp[3], dist_sq;
int vertex, edge; int vertex, edge;
dist = nearest_point_in_tri_surface(t0, t1, t2, co, &vertex, &edge, nearest_tmp); dist_sq = nearest_point_in_tri_surface_squared(t0, t1, t2, co, &vertex, &edge, nearest_tmp);
if (dist < nearest->dist) { if (dist_sq < nearest->dist_sq) {
nearest->index = index; nearest->index = index;
nearest->dist = dist; nearest->dist_sq = dist_sq;
copy_v3_v3(nearest->co, nearest_tmp); copy_v3_v3(nearest->co, nearest_tmp);
normal_tri_v3(nearest->no, t0, t1, t2); normal_tri_v3(nearest->no, t0, t1, t2);
} }
@ -499,18 +501,18 @@ static void mesh_edges_nearest_point(void *userdata, int index, const float co[3
const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata; const BVHTreeFromMesh *data = (BVHTreeFromMesh *) userdata;
MVert *vert = data->vert; MVert *vert = data->vert;
MEdge *edge = data->edge + index; MEdge *edge = data->edge + index;
float nearest_tmp[3], dist; float nearest_tmp[3], dist_sq;
float *t0, *t1; float *t0, *t1;
t0 = vert[edge->v1].co; t0 = vert[edge->v1].co;
t1 = vert[edge->v2].co; t1 = vert[edge->v2].co;
closest_to_line_segment_v3(nearest_tmp, co, t0, t1); closest_to_line_segment_v3(nearest_tmp, co, t0, t1);
dist = len_squared_v3v3(nearest_tmp, co); dist_sq = len_squared_v3v3(nearest_tmp, co);
if (dist < nearest->dist) { if (dist_sq < nearest->dist_sq) {
nearest->index = index; nearest->index = index;
nearest->dist = dist; nearest->dist_sq = dist_sq;
copy_v3_v3(nearest->co, nearest_tmp); copy_v3_v3(nearest->co, nearest_tmp);
sub_v3_v3v3(nearest->no, t0, t1); sub_v3_v3v3(nearest->no, t0, t1);
normalize_v3(nearest->no); normalize_v3(nearest->no);

2
source/blender/blenkernel/intern/constraint.c
View File

@ -3348,7 +3348,7 @@ static void shrinkwrap_get_tarmat(bConstraint *con, bConstraintOb *cob, bConstra
float dist; float dist;
nearest.index = -1; nearest.index = -1;
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
if (scon->shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX) if (scon->shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX)
bvhtree_from_mesh_verts(&treeData, target, 0.0, 2, 6); bvhtree_from_mesh_verts(&treeData, target, 0.0, 2, 6);

12
source/blender/blenkernel/intern/dynamicpaint.c
View File

@ -2944,13 +2944,13 @@ static void mesh_faces_nearest_point_dp(void *userdata, int index, const float c
t3 = face->v4 ? vert[face->v4].co : NULL; t3 = face->v4 ? vert[face->v4].co : NULL;
do { do {
float nearest_tmp[3], dist; float nearest_tmp[3], dist_sq;
int vertex, edge; int vertex, edge;
dist = nearest_point_in_tri_surface(t0, t1, t2, co, &vertex, &edge, nearest_tmp); dist_sq = nearest_point_in_tri_surface_squared(t0, t1, t2, co, &vertex, &edge, nearest_tmp);
if (dist < nearest->dist) { if (dist_sq < nearest->dist_sq) {
nearest->index = index; nearest->index = index;
nearest->dist = dist; nearest->dist_sq = dist_sq;
copy_v3_v3(nearest->co, nearest_tmp); copy_v3_v3(nearest->co, nearest_tmp);
nearest->no[0] = (quad) ? 1.0f : 0.0f; nearest->no[0] = (quad) ? 1.0f : 0.0f;
} }
@ -3405,7 +3405,7 @@ static int dynamicPaint_paintMesh(DynamicPaintSurface *surface,
hit.index = -1; hit.index = -1;
hit.dist = 9999; hit.dist = 9999;
nearest.index = -1; nearest.index = -1;
nearest.dist = brush_radius * brush_radius; /* find_nearest uses squared distance */ nearest.dist_sq = brush_radius * brush_radius; /* find_nearest uses squared distance */
/* Check volume collision */ /* Check volume collision */
if (brush->collision == MOD_DPAINT_COL_VOLUME || brush->collision == MOD_DPAINT_COL_VOLDIST) if (brush->collision == MOD_DPAINT_COL_VOLUME || brush->collision == MOD_DPAINT_COL_VOLDIST)
@ -3463,7 +3463,7 @@ static int dynamicPaint_paintMesh(DynamicPaintSurface *surface,
/* If pure distance proximity, find the nearest point on the mesh */ /* If pure distance proximity, find the nearest point on the mesh */
if (!(brush->flags & MOD_DPAINT_PROX_PROJECT)) { if (!(brush->flags & MOD_DPAINT_PROX_PROJECT)) {
if (BLI_bvhtree_find_nearest(treeData.tree, ray_start, &nearest, mesh_faces_nearest_point_dp, &treeData) != -1) { if (BLI_bvhtree_find_nearest(treeData.tree, ray_start, &nearest, mesh_faces_nearest_point_dp, &treeData) != -1) {
proxDist = sqrtf(nearest.dist); proxDist = sqrtf(nearest.dist_sq);
copy_v3_v3(hitCo, nearest.co); copy_v3_v3(hitCo, nearest.co);
hQuad = (nearest.no[0] == 1.0f); hQuad = (nearest.no[0] == 1.0f);
face = nearest.index; face = nearest.index;

19
source/blender/blenkernel/intern/editmesh_bvh.c
View File

@ -378,7 +378,7 @@ struct VertSearchUserData {
const float (*cos_cage)[3]; const float (*cos_cage)[3];
/* from the hit */ /* from the hit */
float maxdist; float dist_max_sq;
int index_tri; int index_tri;
}; };
@ -386,8 +386,7 @@ static void bmbvh_find_vert_closest_cb(void *userdata, int index, const float co
{ {
struct VertSearchUserData *bmcb_data = userdata; struct VertSearchUserData *bmcb_data = userdata;
const BMLoop **ltri = bmcb_data->looptris[index]; const BMLoop **ltri = bmcb_data->looptris[index];
const float maxdist = bmcb_data->maxdist; const float dist_max_sq = bmcb_data->dist_max_sq;
float dist;
int i; int i;
const float *tri_cos[3]; const float *tri_cos[3];
@ -395,32 +394,32 @@ static void bmbvh_find_vert_closest_cb(void *userdata, int index, const float co
bmbvh_tri_from_face(tri_cos, ltri, bmcb_data->cos_cage); bmbvh_tri_from_face(tri_cos, ltri, bmcb_data->cos_cage);
for (i = 0; i < 3; i++) { for (i = 0; i < 3; i++) {
dist = len_squared_v3v3(co, tri_cos[i]); const float dist_sq = len_squared_v3v3(co, tri_cos[i]);
if (dist < hit->dist && dist < maxdist) { if (dist_sq < hit->dist_sq && dist_sq < dist_max_sq) {
copy_v3_v3(hit->co, tri_cos[i]); copy_v3_v3(hit->co, tri_cos[i]);
/* XXX, normal ignores cage */ /* XXX, normal ignores cage */
copy_v3_v3(hit->no, ltri[i]->v->no); copy_v3_v3(hit->no, ltri[i]->v->no);
hit->dist = dist; hit->dist_sq = dist_sq;
hit->index = index; hit->index = index;
bmcb_data->index_tri = i; bmcb_data->index_tri = i;
} }
} }
} }
BMVert *BKE_bmbvh_find_vert_closest(BMBVHTree *bmtree, const float co[3], const float maxdist) BMVert *BKE_bmbvh_find_vert_closest(BMBVHTree *bmtree, const float co[3], const float dist_max)
{ {
BVHTreeNearest hit; BVHTreeNearest hit;
struct VertSearchUserData bmcb_data; struct VertSearchUserData bmcb_data;
const float maxdist_sq = maxdist * maxdist; const float dist_max_sq = dist_max * dist_max;
if (bmtree->cos_cage) BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT)); if (bmtree->cos_cage) BLI_assert(!(bmtree->bm->elem_index_dirty & BM_VERT));
hit.dist = maxdist_sq; hit.dist_sq = dist_max_sq;
hit.index = -1; hit.index = -1;
bmcb_data.looptris = (const BMLoop *(*)[3])bmtree->looptris; bmcb_data.looptris = (const BMLoop *(*)[3])bmtree->looptris;
bmcb_data.cos_cage = (const float (*)[3])bmtree->cos_cage; bmcb_data.cos_cage = (const float (*)[3])bmtree->cos_cage;
bmcb_data.maxdist = maxdist_sq; bmcb_data.dist_max_sq = dist_max_sq;
BLI_bvhtree_find_nearest(bmtree->tree, co, &hit, bmbvh_find_vert_closest_cb, &bmcb_data); BLI_bvhtree_find_nearest(bmtree->tree, co, &hit, bmbvh_find_vert_closest_cb, &bmcb_data);
if (hit.index != -1) { if (hit.index != -1) {

2
source/blender/blenkernel/intern/effect.c
View File

@ -537,7 +537,7 @@ int closest_point_on_surface(SurfaceModifierData *surmd, const float co[3], floa
BVHTreeNearest nearest; BVHTreeNearest nearest;
nearest.index = -1; nearest.index = -1;
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
BLI_bvhtree_find_nearest(surmd->bvhtree->tree, co, &nearest, surmd->bvhtree->nearest_callback, surmd->bvhtree); BLI_bvhtree_find_nearest(surmd->bvhtree->tree, co, &nearest, surmd->bvhtree->nearest_callback, surmd->bvhtree);

6
source/blender/blenkernel/intern/mask.c
View File

@ -359,7 +359,7 @@ float BKE_mask_spline_project_co(MaskSpline *spline, MaskSplinePoint *point,
float start_u, const float co[2], const eMaskSign sign) float start_u, const float co[2], const eMaskSign sign)
{ {
const float proj_eps = 1e-3; const float proj_eps = 1e-3;
const float proj_eps_squared = proj_eps * proj_eps; const float proj_eps_sq = proj_eps * proj_eps;
const int N = 1000; const int N = 1000;
float u = -1.0f, du = 1.0f / N, u1 = start_u, u2 = start_u; float u = -1.0f, du = 1.0f / N, u1 = start_u, u2 = start_u;
float ang = -1.0f; float ang = -1.0f;
@ -381,7 +381,7 @@ float BKE_mask_spline_project_co(MaskSpline *spline, MaskSplinePoint *point,
((sign == MASK_PROJ_POS) && (dot_v2v2(v1, n1) >= 0.0f))) ((sign == MASK_PROJ_POS) && (dot_v2v2(v1, n1) >= 0.0f)))
{ {
if (len_squared_v2(v1) > proj_eps_squared) { if (len_squared_v2(v1) > proj_eps_sq) {
ang1 = angle_v2v2(v1, n1); ang1 = angle_v2v2(v1, n1);
if (ang1 > (float)M_PI / 2.0f) if (ang1 > (float)M_PI / 2.0f)
ang1 = (float)M_PI - ang1; ang1 = (float)M_PI - ang1;
@ -408,7 +408,7 @@ float BKE_mask_spline_project_co(MaskSpline *spline, MaskSplinePoint *point,
((sign == MASK_PROJ_POS) && (dot_v2v2(v2, n2) >= 0.0f))) ((sign == MASK_PROJ_POS) && (dot_v2v2(v2, n2) >= 0.0f)))
{ {
if (len_squared_v2(v2) > proj_eps_squared) { if (len_squared_v2(v2) > proj_eps_sq) {
ang2 = angle_v2v2(v2, n2); ang2 = angle_v2v2(v2, n2);
if (ang2 > (float)M_PI / 2.0f) if (ang2 > (float)M_PI / 2.0f)
ang2 = (float)M_PI - ang2; ang2 = (float)M_PI - ang2;

10
source/blender/blenkernel/intern/mball.c
View File

@ -1500,7 +1500,7 @@ static void find_first_points(PROCESS *process, MetaBall *mb, int a)
float in_v /*, out_v*/; float in_v /*, out_v*/;
float workp[3]; float workp[3];
float dvec[3]; float dvec[3];
float tmp_v, workp_v, max_len, nx, ny, nz, max_dim; float tmp_v, workp_v, max_len_sq, nx, ny, nz, max_dim;
calc_mballco(ml, in); calc_mballco(ml, in);
in_v = process->function(process, in[0], in[1], in[2]); in_v = process->function(process, in[0], in[1], in[2]);
@ -1553,7 +1553,7 @@ static void find_first_points(PROCESS *process, MetaBall *mb, int a)
/* find "first points" on Implicit Surface of MetaElemnt ml */ /* find "first points" on Implicit Surface of MetaElemnt ml */
copy_v3_v3(workp, in); copy_v3_v3(workp, in);
workp_v = in_v; workp_v = in_v;
max_len = len_squared_v3v3(out, in); max_len_sq = len_squared_v3v3(out, in);
nx = fabsf((out[0] - in[0]) / process->size); nx = fabsf((out[0] - in[0]) / process->size);
ny = fabsf((out[1] - in[1]) / process->size); ny = fabsf((out[1] - in[1]) / process->size);
@ -1561,13 +1561,13 @@ static void find_first_points(PROCESS *process, MetaBall *mb, int a)
max_dim = max_fff(nx, ny, nz); max_dim = max_fff(nx, ny, nz);
if (max_dim != 0.0f) { if (max_dim != 0.0f) {
float len = 0.0f; float len_sq = 0.0f;
dvec[0] = (out[0] - in[0]) / max_dim; dvec[0] = (out[0] - in[0]) / max_dim;
dvec[1] = (out[1] - in[1]) / max_dim; dvec[1] = (out[1] - in[1]) / max_dim;
dvec[2] = (out[2] - in[2]) / max_dim; dvec[2] = (out[2] - in[2]) / max_dim;
while (len <= max_len) { while (len_sq <= max_len_sq) {
add_v3_v3(workp, dvec); add_v3_v3(workp, dvec);
/* compute value of implicite function */ /* compute value of implicite function */
@ -1589,7 +1589,7 @@ static void find_first_points(PROCESS *process, MetaBall *mb, int a)
add_cube(process, c_i, c_j, c_k, 2); add_cube(process, c_i, c_j, c_k, 2);
} }
} }
len = len_squared_v3v3(workp, in); len_sq = len_squared_v3v3(workp, in);
workp_v = tmp_v; workp_v = tmp_v;
} }

10
source/blender/blenkernel/intern/object.c
View File

@ -1110,23 +1110,23 @@ static LodLevel *lod_level_select(Object *ob, const float cam_loc[3])
{ {
LodLevel *current = ob->currentlod; LodLevel *current = ob->currentlod;
float ob_loc[3], delta[3]; float ob_loc[3], delta[3];
float distance2; float dist_sq;
if (!current) return NULL; if (!current) return NULL;
copy_v3_v3(ob_loc, ob->obmat[3]); copy_v3_v3(ob_loc, ob->obmat[3]);
sub_v3_v3v3(delta, ob_loc, cam_loc); sub_v3_v3v3(delta, ob_loc, cam_loc);
distance2 = len_squared_v3(delta); dist_sq = len_squared_v3(delta);
if (distance2 < current->distance * current->distance) { if (dist_sq < current->distance * current->distance) {
/* check for higher LoD */ /* check for higher LoD */
while (current->prev && distance2 < (current->distance * current->distance)) { while (current->prev && dist_sq < (current->distance * current->distance)) {
current = current->prev; current = current->prev;
} }
} }
else { else {
/* check for lower LoD */ /* check for lower LoD */
while (current->next && distance2 > (current->next->distance * current->next->distance)) { while (current->next && dist_sq > (current->next->distance * current->next->distance)) {
current = current->next; current = current->next;
} }
} }

18
source/blender/blenkernel/intern/shrinkwrap.c
View File

@ -139,7 +139,7 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
/* Setup nearest */ /* Setup nearest */
nearest.index = -1; nearest.index = -1;
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
#ifndef __APPLE__ #ifndef __APPLE__
#pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(treeData, calc) schedule(static) #pragma omp parallel for default(none) private(i) firstprivate(nearest) shared(treeData, calc) schedule(static)
#endif #endif
@ -167,9 +167,9 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
* so we can initiate the "nearest.dist" with the expected value to that last hit. * so we can initiate the "nearest.dist" with the expected value to that last hit.
* This will lead in pruning of the search tree. */ * This will lead in pruning of the search tree. */
if (nearest.index != -1) if (nearest.index != -1)
nearest.dist = len_squared_v3v3(tmp_co, nearest.co); nearest.dist_sq = len_squared_v3v3(tmp_co, nearest.co);
else else
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
BLI_bvhtree_find_nearest(treeData.tree, tmp_co, &nearest, treeData.nearest_callback, &treeData); BLI_bvhtree_find_nearest(treeData.tree, tmp_co, &nearest, treeData.nearest_callback, &treeData);
@ -178,8 +178,8 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
if (nearest.index != -1) { if (nearest.index != -1) {
/* Adjusting the vertex weight, /* Adjusting the vertex weight,
* so that after interpolating it keeps a certain distance from the nearest position */ * so that after interpolating it keeps a certain distance from the nearest position */
if (nearest.dist > FLT_EPSILON) { if (nearest.dist_sq > FLT_EPSILON) {
const float dist = sqrtf(nearest.dist); const float dist = sqrtf(nearest.dist_sq);
weight *= (dist - calc->keepDist) / dist; weight *= (dist - calc->keepDist) / dist;
} }
@ -441,7 +441,7 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
/* Setup nearest */ /* Setup nearest */
nearest.index = -1; nearest.index = -1;
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
/* Find the nearest vertex */ /* Find the nearest vertex */
@ -469,9 +469,9 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
* so we can initiate the "nearest.dist" with the expected value to that last hit. * so we can initiate the "nearest.dist" with the expected value to that last hit.
* This will lead in pruning of the search tree. */ * This will lead in pruning of the search tree. */
if (nearest.index != -1) if (nearest.index != -1)
nearest.dist = len_squared_v3v3(tmp_co, nearest.co); nearest.dist_sq = len_squared_v3v3(tmp_co, nearest.co);
else else
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
BLI_bvhtree_find_nearest(treeData.tree, tmp_co, &nearest, treeData.nearest_callback, &treeData); BLI_bvhtree_find_nearest(treeData.tree, tmp_co, &nearest, treeData.nearest_callback, &treeData);
@ -484,7 +484,7 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
else { else {
/* Adjusting the vertex weight, /* Adjusting the vertex weight,
* so that after interpolating it keeps a certain distance from the nearest position */ * so that after interpolating it keeps a certain distance from the nearest position */
float dist = sasqrt(nearest.dist); const float dist = sasqrt(nearest.dist_sq);
if (dist > FLT_EPSILON) { if (dist > FLT_EPSILON) {
/* linear interpolation */ /* linear interpolation */
interp_v3_v3v3(tmp_co, tmp_co, nearest.co, (dist - calc->keepDist) / dist); interp_v3_v3v3(tmp_co, tmp_co, nearest.co, (dist - calc->keepDist) / dist);

6
source/blender/blenkernel/intern/smoke.c
View File

@ -797,7 +797,7 @@ static void obstacles_from_derivedmesh(Object *coll_ob, SmokeDomainSettings *sds
float ray_start[3] = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f}; float ray_start[3] = {(float)x + 0.5f, (float)y + 0.5f, (float)z + 0.5f};
BVHTreeNearest nearest = {0}; BVHTreeNearest nearest = {0};
nearest.index = -1; nearest.index = -1;
nearest.dist = surface_distance * surface_distance; /* find_nearest uses squared distance */ nearest.dist_sq = surface_distance * surface_distance; /* find_nearest uses squared distance */
/* find the nearest point on the mesh */ /* find the nearest point on the mesh */
if (BLI_bvhtree_find_nearest(treeData.tree, ray_start, &nearest, treeData.nearest_callback, &treeData) != -1) { if (BLI_bvhtree_find_nearest(treeData.tree, ray_start, &nearest, treeData.nearest_callback, &treeData) != -1) {
@ -1434,7 +1434,7 @@ static void sample_derivedmesh(SmokeFlowSettings *sfs, MVert *mvert, MTFace *tfa
hit.index = -1; hit.index = -1;
hit.dist = 9999; hit.dist = 9999;
nearest.index = -1; nearest.index = -1;
nearest.dist = sfs->surface_distance * sfs->surface_distance; /* find_nearest uses squared distance */ nearest.dist_sq = sfs->surface_distance * sfs->surface_distance; /* find_nearest uses squared distance */
/* Check volume collision */ /* Check volume collision */
if (sfs->volume_density) { if (sfs->volume_density) {
@ -1465,7 +1465,7 @@ static void sample_derivedmesh(SmokeFlowSettings *sfs, MVert *mvert, MTFace *tfa
/* emit from surface based on distance */ /* emit from surface based on distance */
if (sfs->surface_distance) { if (sfs->surface_distance) {
sample_str = sqrtf(nearest.dist) / sfs->surface_distance; sample_str = sqrtf(nearest.dist_sq) / sfs->surface_distance;
CLAMP(sample_str, 0.0f, 1.0f); CLAMP(sample_str, 0.0f, 1.0f);
sample_str = pow(1.0f - sample_str, 0.5f); sample_str = pow(1.0f - sample_str, 0.5f);
} }

4
source/blender/blenlib/BLI_kdopbvh.h
View File

@ -56,7 +56,7 @@ typedef struct BVHTreeNearest {
int index; /* the index of the nearest found (untouched if none is found within a dist radius from the given coordinates) */ int index; /* the index of the nearest found (untouched if none is found within a dist radius from the given coordinates) */
float co[3]; /* nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */ float co[3]; /* nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */
float no[3]; /* normal at nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */ float no[3]; /* normal at nearest coordinates (untouched it none is found within a dist radius from the given coordinates) */
float dist; /* squared distance to search arround */ float dist_sq; /* squared distance to search arround */
int flags; int flags;
} BVHTreeNearest; } BVHTreeNearest;
@ -81,7 +81,7 @@ typedef void (*BVHTree_NearestPointCallback)(void *userdata, int index, const fl
typedef void (*BVHTree_RayCastCallback)(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit); typedef void (*BVHTree_RayCastCallback)(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit);
/* callback to range search query */ /* callback to range search query */
typedef void (*BVHTree_RangeQuery)(void *userdata, int index, float squared_dist); typedef void (*BVHTree_RangeQuery)(void *userdata, int index, float dist_sq);
BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis); BVHTree *BLI_bvhtree_new(int maxsize, float epsilon, char tree_type, char axis);
void BLI_bvhtree_free(BVHTree *tree); void BLI_bvhtree_free(BVHTree *tree);

36
source/blender/blenlib/intern/BLI_kdopbvh.c
View File

@ -1135,7 +1135,7 @@ BVHTreeOverlap *BLI_bvhtree_overlap(BVHTree *tree1, BVHTree *tree2, unsigned int
} }
/* Determines the nearest point of the given node BV. Returns the squared distance to that point. */ /* Determines the nearest point of the given node BV. Returns the squared distance to that point. */
static float calc_nearest_point(const float proj[3], BVHNode *node, float *nearest) static float calc_nearest_point_squared(const float proj[3], BVHNode *node, float *nearest)
{ {
int i; int i;
const float *bv = node->bv; const float *bv = node->bv;
@ -1185,7 +1185,7 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
data->callback(data->userdata, node->index, data->co, &data->nearest); data->callback(data->userdata, node->index, data->co, &data->nearest);
else { else {
data->nearest.index = node->index; data->nearest.index = node->index;
data->nearest.dist = calc_nearest_point(data->proj, node, data->nearest.co); data->nearest.dist_sq = calc_nearest_point_squared(data->proj, node, data->nearest.co);
} }
} }
else { else {
@ -1196,13 +1196,15 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
if (data->proj[node->main_axis] <= node->children[0]->bv[node->main_axis * 2 + 1]) { if (data->proj[node->main_axis] <= node->children[0]->bv[node->main_axis * 2 + 1]) {
for (i = 0; i != node->totnode; i++) { for (i = 0; i != node->totnode; i++) {
if (calc_nearest_point(data->proj, node->children[i], nearest) >= data->nearest.dist) continue; if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq)
continue;
dfs_find_nearest_dfs(data, node->children[i]); dfs_find_nearest_dfs(data, node->children[i]);
} }
} }
else { else {
for (i = node->totnode - 1; i >= 0; i--) { for (i = node->totnode - 1; i >= 0; i--) {
if (calc_nearest_point(data->proj, node->children[i], nearest) >= data->nearest.dist) continue; if (calc_nearest_point_squared(data->proj, node->children[i], nearest) >= data->nearest.dist_sq)
continue;
dfs_find_nearest_dfs(data, node->children[i]); dfs_find_nearest_dfs(data, node->children[i]);
} }
} }
@ -1211,9 +1213,11 @@ static void dfs_find_nearest_dfs(BVHNearestData *data, BVHNode *node)
static void dfs_find_nearest_begin(BVHNearestData *data, BVHNode *node) static void dfs_find_nearest_begin(BVHNearestData *data, BVHNode *node)
{ {
float nearest[3], sdist; float nearest[3], dist_sq;
sdist = calc_nearest_point(data->proj, node, nearest); dist_sq = calc_nearest_point_squared(data->proj, node, nearest);
if (sdist >= data->nearest.dist) return; if (dist_sq >= data->nearest.dist_sq) {
return;
}
dfs_find_nearest_dfs(data, node); dfs_find_nearest_dfs(data, node);
} }
@ -1329,7 +1333,7 @@ int BLI_bvhtree_find_nearest(BVHTree *tree, const float co[3], BVHTreeNearest *n
} }
else { else {
data.nearest.index = -1; data.nearest.index = -1;
data.nearest.dist = FLT_MAX; data.nearest.dist_sq = FLT_MAX;
} }
/* dfs search */ /* dfs search */
@ -1568,7 +1572,7 @@ float BLI_bvhtree_bb_raycast(const float bv[6], const float light_start[3], cons
typedef struct RangeQueryData { typedef struct RangeQueryData {
BVHTree *tree; BVHTree *tree;
const float *center; const float *center;
float radius; /* squared radius */ float radius_sq; /* squared radius */
int hits; int hits;
@ -1594,12 +1598,12 @@ static void dfs_range_query(RangeQueryData *data, BVHNode *node)
int i; int i;
for (i = 0; i != node->totnode; i++) { for (i = 0; i != node->totnode; i++) {
float nearest[3]; float nearest[3];
float dist = calc_nearest_point(data->center, node->children[i], nearest); float dist_sq = calc_nearest_point_squared(data->center, node->children[i], nearest);
if (dist < data->radius) { if (dist_sq < data->radius_sq) {
/* Its a leaf.. call the callback */ /* Its a leaf.. call the callback */
if (node->children[i]->totnode == 0) { if (node->children[i]->totnode == 0) {
data->hits++; data->hits++;
data->callback(data->userdata, node->children[i]->index, dist); data->callback(data->userdata, node->children[i]->index, dist_sq);
} }
else else
dfs_range_query(data, node->children[i]); dfs_range_query(data, node->children[i]);
@ -1615,7 +1619,7 @@ int BLI_bvhtree_range_query(BVHTree *tree, const float co[3], float radius, BVHT
RangeQueryData data; RangeQueryData data;
data.tree = tree; data.tree = tree;
data.center = co; data.center = co;
data.radius = radius * radius; data.radius_sq = radius * radius;
data.hits = 0; data.hits = 0;
data.callback = callback; data.callback = callback;
@ -1623,12 +1627,12 @@ int BLI_bvhtree_range_query(BVHTree *tree, const float co[3], float radius, BVHT
if (root != NULL) { if (root != NULL) {
float nearest[3]; float nearest[3];
float dist = calc_nearest_point(data.center, root, nearest); float dist_sq = calc_nearest_point_squared(data.center, root, nearest);
if (dist < data.radius) { if (dist_sq < data.radius_sq) {
/* Its a leaf.. call the callback */ /* Its a leaf.. call the callback */
if (root->totnode == 0) { if (root->totnode == 0) {
data.hits++; data.hits++;
data.callback(data.userdata, root->index, dist); data.callback(data.userdata, root->index, dist_sq);
} }
else else
dfs_range_query(&data, root); dfs_range_query(&data, root);

16
source/blender/blenlib/intern/math_geom.c
View File

@ -335,17 +335,17 @@ void closest_to_line_segment_v3(float close_r[3], const float v1[3], const float
*/ */
void closest_to_plane_v3(float close_r[3], const float plane[4], const float pt[3]) void closest_to_plane_v3(float close_r[3], const float plane[4], const float pt[3])
{ {
const float length = len_squared_v3(plane); const float len_sq = len_squared_v3(plane);
const float side = plane_point_side_v3(plane, pt); const float side = plane_point_side_v3(plane, pt);
madd_v3_v3v3fl(close_r, pt, plane, -side / length); madd_v3_v3v3fl(close_r, pt, plane, -side / len_sq);
} }
float dist_squared_to_plane_v3(const float pt[3], const float plane[4]) float dist_squared_to_plane_v3(const float pt[3], const float plane[4])
{ {
const float length = len_squared_v3(plane); const float len_sq = len_squared_v3(plane);
const float side = plane_point_side_v3(plane, pt); const float side = plane_point_side_v3(plane, pt);
const float fac = side / length; const float fac = side / len_sq;
return copysignf(length * (fac * fac), side); return copysignf(len_sq * (fac * fac), side);
} }
/** /**
@ -353,10 +353,10 @@ float dist_squared_to_plane_v3(const float pt[3], const float plane[4])
*/ */
float dist_to_plane_v3(const float pt[3], const float plane[4]) float dist_to_plane_v3(const float pt[3], const float plane[4])
{ {
const float length = len_squared_v3(plane); const float len_sq = len_squared_v3(plane);
const float side = plane_point_side_v3(plane, pt); const float side = plane_point_side_v3(plane, pt);
const float fac = side / length; const float fac = side / len_sq;
return sqrtf(length) * fac; return sqrtf(len_sq) * fac;
} }
/* distance v1 to line-piece l1-l2 in 3D */ /* distance v1 to line-piece l1-l2 in 3D */

10
source/blender/bmesh/intern/bmesh_construct.c
View File

@ -394,7 +394,7 @@ BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len,
float far_cross_vec[3]; float far_cross_vec[3];
float sign_vec[3]; /* work out if we are pos/neg angle */ float sign_vec[3]; /* work out if we are pos/neg angle */
float far_dist, far_best; float far_dist_sq, far_dist_max_sq;
float far_cross_dist, far_cross_best = 0.0f; float far_cross_dist, far_cross_best = 0.0f;
/* get the center point and collect vector array since we loop over these a lot */ /* get the center point and collect vector array since we loop over these a lot */
@ -405,12 +405,12 @@ BMFace *BM_face_create_ngon_vcloud(BMesh *bm, BMVert **vert_arr, int len,
/* find the far point from cent */ /* find the far point from cent */
far_best = 0.0f; far_dist_max_sq = 0.0f;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
far_dist = len_squared_v3v3(vert_arr[i]->co, cent); far_dist_sq = len_squared_v3v3(vert_arr[i]->co, cent);
if (far_dist > far_best || far == NULL) { if (far_dist_sq > far_dist_max_sq || far == NULL) {
far = vert_arr[i]->co; far = vert_arr[i]->co;
far_best = far_dist; far_dist_max_sq = far_dist_sq;
} }
} }

22
source/blender/bmesh/intern/bmesh_edgeloop.c
View File

@ -406,11 +406,11 @@ void BM_mesh_edgeloops_calc_order(BMesh *UNUSED(bm), ListBase *eloops, const boo
/* find far outest loop */ /* find far outest loop */
{ {
BMEdgeLoopStore *el_store_best = NULL; BMEdgeLoopStore *el_store_best = NULL;
float len_best = -1.0f; float len_best_sq = -1.0f;
for (el_store = eloops->first; el_store; el_store = el_store->next) { for (el_store = eloops->first; el_store; el_store = el_store->next) {
const float len = len_squared_v3v3(cent, el_store->co); const float len_sq = len_squared_v3v3(cent, el_store->co);
if (len > len_best) { if (len_sq > len_best_sq) {
len_best = len; len_best_sq = len_sq;
el_store_best = el_store; el_store_best = el_store;
} }
} }
@ -424,27 +424,27 @@ void BM_mesh_edgeloops_calc_order(BMesh *UNUSED(bm), ListBase *eloops, const boo
BMEdgeLoopStore *el_store_best = NULL; BMEdgeLoopStore *el_store_best = NULL;
const float *co = ((BMEdgeLoopStore *)eloops_ordered.last)->co; const float *co = ((BMEdgeLoopStore *)eloops_ordered.last)->co;
const float *no = ((BMEdgeLoopStore *)eloops_ordered.last)->no; const float *no = ((BMEdgeLoopStore *)eloops_ordered.last)->no;
float len_best = FLT_MAX; float len_best_sq = FLT_MAX;
if (use_normals) if (use_normals)
BLI_ASSERT_UNIT_V3(no); BLI_ASSERT_UNIT_V3(no);
for (el_store = eloops->first; el_store; el_store = el_store->next) { for (el_store = eloops->first; el_store; el_store = el_store->next) {
float len; float len_sq;
if (use_normals) { if (use_normals) {
/* scale the length by how close the loops are to pointing at eachother */ /* scale the length by how close the loops are to pointing at eachother */
float dir[3]; float dir[3];
sub_v3_v3v3(dir, co, el_store->co); sub_v3_v3v3(dir, co, el_store->co);
len = normalize_v3(dir); len_sq = normalize_v3(dir);
len = len * ((1.0f - fabsf(dot_v3v3(dir, no))) + len_sq = len_sq * ((1.0f - fabsf(dot_v3v3(dir, no))) +
(1.0f - fabsf(dot_v3v3(dir, el_store->no)))); (1.0f - fabsf(dot_v3v3(dir, el_store->no))));
} }
else { else {
len = len_squared_v3v3(co, el_store->co); len_sq = len_squared_v3v3(co, el_store->co);
} }
if (len < len_best) { if (len_sq < len_best_sq) {
len_best = len; len_best_sq = len_sq;
el_store_best = el_store; el_store_best = el_store;
} }
} }

14
source/blender/bmesh/intern/bmesh_queries.c
View File

@ -1323,10 +1323,10 @@ BMLoop *BM_face_find_shortest_loop(BMFace *f)
l_iter = l_first = BM_FACE_FIRST_LOOP(f); l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do { do {
const float len = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co); const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
if (len <= shortest_len) { if (len_sq <= shortest_len) {
shortest_loop = l_iter; shortest_loop = l_iter;
shortest_len = len; shortest_len = len_sq;
} }
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);
@ -1339,7 +1339,7 @@ BMLoop *BM_face_find_shortest_loop(BMFace *f)
BMLoop *BM_face_find_longest_loop(BMFace *f) BMLoop *BM_face_find_longest_loop(BMFace *f)
{ {
BMLoop *longest_loop = NULL; BMLoop *longest_loop = NULL;
float longest_len = 0.0f; float len_max_sq = 0.0f;
BMLoop *l_iter; BMLoop *l_iter;
BMLoop *l_first; BMLoop *l_first;
@ -1347,10 +1347,10 @@ BMLoop *BM_face_find_longest_loop(BMFace *f)
l_iter = l_first = BM_FACE_FIRST_LOOP(f); l_iter = l_first = BM_FACE_FIRST_LOOP(f);
do { do {
const float len = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co); const float len_sq = len_squared_v3v3(l_iter->v->co, l_iter->next->v->co);
if (len >= longest_len) { if (len_sq >= len_max_sq) {
longest_loop = l_iter; longest_loop = l_iter;
longest_len = len; len_max_sq = len_sq;
} }
} while ((l_iter = l_iter->next) != l_first); } while ((l_iter = l_iter->next) != l_first);

10
source/blender/bmesh/operators/bmo_normals.c
View File

@ -63,7 +63,7 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f
int i, f_start_index; int i, f_start_index;
const short oflag_flip = oflag | FACE_FLIP; const short oflag_flip = oflag | FACE_FLIP;
float f_len_best; float f_len_best_sq;
BMFace *f; BMFace *f;
BLI_LINKSTACK_DECLARE(fstack, BMFace *); BLI_LINKSTACK_DECLARE(fstack, BMFace *);
@ -80,13 +80,13 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f
BLI_assert(BM_face_is_normal_valid(faces[i])); BLI_assert(BM_face_is_normal_valid(faces[i]));
} }
f_len_best = -FLT_MAX; f_len_best_sq = -FLT_MAX;
for (i = 0; i < faces_len; i++) { for (i = 0; i < faces_len; i++) {
float f_len_test; float f_len_test_sq;
if ((f_len_test = len_squared_v3v3(faces_center[i], cent)) > f_len_best) { if ((f_len_test_sq = len_squared_v3v3(faces_center[i], cent)) > f_len_best_sq) {
f_len_best = f_len_test; f_len_best_sq = f_len_test_sq;
f_start_index = i; f_start_index = i;
} }
} }

4
source/blender/editors/interface/interface_widgets.c
View File

@ -1981,9 +1981,9 @@ void ui_hsvcircle_vals_from_pos(float *val_rad, float *val_dist, const rcti *rec
const float centy = BLI_rcti_cent_y_fl(rect); const float centy = BLI_rcti_cent_y_fl(rect);
const float radius = (float)min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)) / 2.0f; const float radius = (float)min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)) / 2.0f;
const float m_delta[2] = {mx - centx, my - centy}; const float m_delta[2] = {mx - centx, my - centy};
const float dist_squared = len_squared_v2(m_delta); const float dist_sq = len_squared_v2(m_delta);
*val_dist = (dist_squared < (radius * radius)) ? sqrtf(dist_squared) / radius : 1.0f; *val_dist = (dist_sq < (radius * radius)) ? sqrtf(dist_sq) / radius : 1.0f;
*val_rad = atan2f(m_delta[0], m_delta[1]) / (2.0f * (float)M_PI) + 0.5f; *val_rad = atan2f(m_delta[0], m_delta[1]) / (2.0f * (float)M_PI) + 0.5f;
} }

28
source/blender/editors/mask/mask_ops.c
View File

@ -72,7 +72,7 @@ MaskSplinePoint *ED_mask_point_find_nearest(const bContext *C, Mask *mask, const
MaskSplinePoint *point = NULL; MaskSplinePoint *point = NULL;
float co[2]; float co[2];
const float threshold_sq = threshold * threshold; const float threshold_sq = threshold * threshold;
float len = FLT_MAX, scalex, scaley; float len_sq = FLT_MAX, scalex, scaley;
int is_handle = FALSE, width, height; int is_handle = FALSE, width, height;
ED_mask_get_size(sa, &width, &height); ED_mask_get_size(sa, &width, &height);
@ -96,7 +96,7 @@ MaskSplinePoint *ED_mask_point_find_nearest(const bContext *C, Mask *mask, const
for (i = 0; i < spline->tot_point; i++) { for (i = 0; i < spline->tot_point; i++) {
MaskSplinePoint *cur_point = &spline->points[i]; MaskSplinePoint *cur_point = &spline->points[i];
MaskSplinePoint *cur_point_deform = &points_array[i]; MaskSplinePoint *cur_point_deform = &points_array[i];
float cur_len, vec[2], handle[2]; float cur_len_sq, vec[2], handle[2];
vec[0] = cur_point_deform->bezt.vec[1][0] * scalex; vec[0] = cur_point_deform->bezt.vec[1][0] * scalex;
vec[1] = cur_point_deform->bezt.vec[1][1] * scaley; vec[1] = cur_point_deform->bezt.vec[1][1] * scaley;
@ -106,31 +106,31 @@ MaskSplinePoint *ED_mask_point_find_nearest(const bContext *C, Mask *mask, const
handle[0] *= scalex; handle[0] *= scalex;
handle[1] *= scaley; handle[1] *= scaley;
cur_len = len_squared_v2v2(co, handle); cur_len_sq = len_squared_v2v2(co, handle);
if (cur_len < len) { if (cur_len_sq < len_sq) {
point_masklay = masklay; point_masklay = masklay;
point_spline = spline; point_spline = spline;
point = cur_point; point = cur_point;
len = cur_len; len_sq = cur_len_sq;
is_handle = TRUE; is_handle = TRUE;
} }
} }
cur_len = len_squared_v2v2(co, vec); cur_len_sq = len_squared_v2v2(co, vec);
if (cur_len < len) { if (cur_len_sq < len_sq) {
point_spline = spline; point_spline = spline;
point_masklay = masklay; point_masklay = masklay;
point = cur_point; point = cur_point;
len = cur_len; len_sq = cur_len_sq;
is_handle = FALSE; is_handle = FALSE;
} }
} }
} }
} }
if (len < threshold_sq) { if (len_sq < threshold_sq) {
if (masklay_r) if (masklay_r)
*masklay_r = point_masklay; *masklay_r = point_masklay;
@ -141,7 +141,7 @@ MaskSplinePoint *ED_mask_point_find_nearest(const bContext *C, Mask *mask, const
*is_handle_r = is_handle; *is_handle_r = is_handle;
if (score) if (score)
*score = sqrtf(len); *score = sqrtf(len_sq);
return point; return point;
} }
@ -200,14 +200,14 @@ bool ED_mask_feather_find_nearest(const bContext *C, Mask *mask, const float nor
MaskSplinePoint *cur_point = &spline->points[i]; MaskSplinePoint *cur_point = &spline->points[i];
for (j = 0; j <= cur_point->tot_uw; j++) { for (j = 0; j <= cur_point->tot_uw; j++) {
float cur_len, vec[2]; float cur_len_sq, vec[2];
vec[0] = (*fp)[0] * scalex; vec[0] = (*fp)[0] * scalex;
vec[1] = (*fp)[1] * scaley; vec[1] = (*fp)[1] * scaley;
cur_len = len_squared_v2v2(vec, co); cur_len_sq = len_squared_v2v2(vec, co);
if (point == NULL || cur_len < len) { if (point == NULL || cur_len_sq < len) {
if (j == 0) if (j == 0)
uw = NULL; uw = NULL;
else else
@ -216,7 +216,7 @@ bool ED_mask_feather_find_nearest(const bContext *C, Mask *mask, const float nor
point_masklay = masklay; point_masklay = masklay;
point_spline = spline; point_spline = spline;
point = cur_point; point = cur_point;
len = cur_len; len = cur_len_sq;
} }
fp++; fp++;

16
source/blender/editors/mesh/editmesh_knife.c
View File

@ -1842,7 +1842,7 @@ static void sort_by_frac_along(ListBase *lst, BMEdge *e)
for (cur = ((Ref *)lst->first)->next; cur; cur = next) { for (cur = ((Ref *)lst->first)->next; cur; cur = next) {
KnifeVert *vcur = cur->ref; KnifeVert *vcur = cur->ref;
const float vcur_fac = len_squared_v3v3(v1co, vcur->co); const float vcur_fac_sq = len_squared_v3v3(v1co, vcur->co);
next = cur->next; next = cur->next;
prev = cur->prev; prev = cur->prev;
@ -1851,7 +1851,7 @@ static void sort_by_frac_along(ListBase *lst, BMEdge *e)
while (prev) { while (prev) {
KnifeVert *vprev = prev->ref; KnifeVert *vprev = prev->ref;
if (len_squared_v3v3(v1co, vprev->co) <= vcur_fac) if (len_squared_v3v3(v1co, vprev->co) <= vcur_fac_sq)
break; break;
prev = prev->prev; prev = prev->prev;
} }
@ -2057,7 +2057,7 @@ static bool find_hole_chains(KnifeTool_OpData *kcd, ListBase *hole, BMFace *f, L
BMIter iter; BMIter iter;
int nh, nf, i, j, k, m, ax, ay, sep = 0 /* Quite warnings */, bestsep; int nh, nf, i, j, k, m, ax, ay, sep = 0 /* Quite warnings */, bestsep;
int besti[2], bestj[2]; int besti[2], bestj[2];
float d, bestd; float dist_sq, dist_best_sq;
nh = BLI_countlist(hole); nh = BLI_countlist(hole);
nf = f->len; nf = f->len;
@ -2110,7 +2110,7 @@ static bool find_hole_chains(KnifeTool_OpData *kcd, ListBase *hole, BMFace *f, L
for (m = 0; m < 2; m++) { for (m = 0; m < 2; m++) {
besti[m] = -1; besti[m] = -1;
bestj[m] = -1; bestj[m] = -1;
bestd = FLT_MAX; dist_best_sq = FLT_MAX;
bestsep = 0; bestsep = 0;
for (i = 0; i < nh; i++) { for (i = 0; i < nh; i++) {
if (m == 1) { if (m == 1) {
@ -2120,15 +2120,15 @@ static bool find_hole_chains(KnifeTool_OpData *kcd, ListBase *hole, BMFace *f, L
sep = MIN2(sep, nh - sep); sep = MIN2(sep, nh - sep);
if (sep < bestsep) if (sep < bestsep)
continue; continue;
bestd = FLT_MAX; dist_best_sq = FLT_MAX;
} }
for (j = 0; j < nf; j++) { for (j = 0; j < nf; j++) {
bool ok; bool ok;
if (m == 1 && j == bestj[0]) if (m == 1 && j == bestj[0])
continue; continue;
d = len_squared_v2v2(hco[i], fco[j]); dist_sq = len_squared_v2v2(hco[i], fco[j]);
if (d > bestd) if (dist_sq > dist_best_sq)
continue; continue;
ok = true; ok = true;
@ -2151,7 +2151,7 @@ static bool find_hole_chains(KnifeTool_OpData *kcd, ListBase *hole, BMFace *f, L
bestj[m] = j; bestj[m] = j;
if (m == 1) if (m == 1)
bestsep = sep; bestsep = sep;
bestd = d; dist_best_sq = dist_sq;
} }
} }
} }

6
source/blender/editors/object/object_vgroup.c
View File

@ -997,7 +997,7 @@ static bool ed_vgroup_transfer_weight(Object *ob_dst, Object *ob_src, bDeformGro
} }
/* Reset nearest.*/ /* Reset nearest.*/
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
/* It is faster to start searching at the top of the tree instead of previous search result.*/ /* It is faster to start searching at the top of the tree instead of previous search result.*/
nearest.index = -1; nearest.index = -1;
@ -1037,7 +1037,7 @@ static bool ed_vgroup_transfer_weight(Object *ob_dst, Object *ob_src, bDeformGro
} }
/* Reset nearest.*/ /* Reset nearest.*/
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
/* It is faster to start searching at the top of the tree instead of previous search result.*/ /* It is faster to start searching at the top of the tree instead of previous search result.*/
nearest.index = -1; nearest.index = -1;
@ -1098,7 +1098,7 @@ static bool ed_vgroup_transfer_weight(Object *ob_dst, Object *ob_src, bDeformGro
} }
/* Reset nearest.*/ /* Reset nearest.*/
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
/* It is faster to start searching at the top of the tree instead of previous search result.*/ /* It is faster to start searching at the top of the tree instead of previous search result.*/
nearest.index = -1; nearest.index = -1;

2
source/blender/editors/physics/particle_object.c
View File

@ -675,7 +675,7 @@ static int connect_hair(Scene *scene, Object *ob, ParticleSystem *psys)
key = pa->hair; key = pa->hair;
nearest.index = -1; nearest.index = -1;
nearest.dist = FLT_MAX; nearest.dist_sq = FLT_MAX;
BLI_bvhtree_find_nearest(bvhtree.tree, key->co, &nearest, bvhtree.nearest_callback, &bvhtree); BLI_bvhtree_find_nearest(bvhtree.tree, key->co, &nearest, bvhtree.nearest_callback, &bvhtree);

8
source/blender/editors/sculpt_paint/paint_image_proj.c
View File

@ -3814,7 +3814,7 @@ static void *do_projectpaint_thread(void *ph_v)
ProjPaintImage *last_projIma = NULL; ProjPaintImage *last_projIma = NULL;
ImagePaintPartialRedraw *last_partial_redraw_cell; ImagePaintPartialRedraw *last_partial_redraw_cell;
float dist_nosqrt, dist; float dist_sq, dist;
float falloff; float falloff;
int bucket_index; int bucket_index;
@ -3914,11 +3914,11 @@ static void *do_projectpaint_thread(void *ph_v)
projPixel = (ProjPixel *)node->link; projPixel = (ProjPixel *)node->link;
dist_nosqrt = len_squared_v2v2(projPixel->projCoSS, pos); dist_sq = len_squared_v2v2(projPixel->projCoSS, pos);
/*if (dist < radius) {*/ /* correct but uses a sqrtf */ /*if (dist < radius) {*/ /* correct but uses a sqrtf */
if (dist_nosqrt <= brush_radius_sq) { if (dist_sq <= brush_radius_sq) {
dist = sqrtf(dist_nosqrt); dist = sqrtf(dist_sq);
falloff = BKE_brush_curve_strength_clamp(ps->brush, dist, brush_radius); falloff = BKE_brush_curve_strength_clamp(ps->brush, dist, brush_radius);

6
source/blender/editors/sculpt_paint/paint_vertex.c
View File

@ -917,11 +917,11 @@ static float calc_vp_strength_col_dl(VPaint *vp, ViewContext *vc, const float co
co, co_ss, co, co_ss,
V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_NEAR) == V3D_PROJ_RET_OK) V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_NEAR) == V3D_PROJ_RET_OK)
{ {
const float dist_squared = len_squared_v2v2(mval, co_ss); const float dist_sq = len_squared_v2v2(mval, co_ss);
if (dist_squared <= brush_size_pressure * brush_size_pressure) { if (dist_sq <= brush_size_pressure * brush_size_pressure) {
Brush *brush = BKE_paint_brush(&vp->paint); Brush *brush = BKE_paint_brush(&vp->paint);
const float dist = sqrtf(dist_squared); const float dist = sqrtf(dist_sq);
float factor; float factor;
if (brush->mtex.tex && rgba) { if (brush->mtex.tex && rgba) {

16
source/blender/editors/sculpt_paint/paint_vertex_proj.c
View File

@ -56,7 +56,7 @@ struct VertProjHandle {
bool use_update; bool use_update;
/* use for update */ /* use for update */
float *dists; float *dists_sq;
Object *ob; Object *ob;
Scene *scene; Scene *scene;
@ -144,13 +144,13 @@ static void vpaint_proj_dm_map_cosnos_update__map_cb(void *userData, int index,
co, co_ss, co, co_ss,
V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_NEAR) == V3D_PROJ_RET_OK) V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_NEAR) == V3D_PROJ_RET_OK)
{ {
const float dist = len_squared_v2v2(vp_update->mval_fl, co_ss); const float dist_sq = len_squared_v2v2(vp_update->mval_fl, co_ss);
if (dist > vp_handle->dists[index]) { if (dist_sq > vp_handle->dists_sq[index]) {
/* bail out! */ /* bail out! */
return; return;
} }
vp_handle->dists[index] = dist; vp_handle->dists_sq[index] = dist_sq;
} }
} }
/* continue with regular functionality */ /* continue with regular functionality */
@ -181,7 +181,7 @@ static void vpaint_proj_dm_map_cosnos_update(struct VertProjHandle *vp_handle,
/* highly unlikely this will become unavailable once painting starts (perhaps with animated modifiers) */ /* highly unlikely this will become unavailable once painting starts (perhaps with animated modifiers) */
if (LIKELY(dm->foreachMappedVert)) { if (LIKELY(dm->foreachMappedVert)) {
fill_vn_fl(vp_handle->dists, me->totvert, FLT_MAX); fill_vn_fl(vp_handle->dists_sq, me->totvert, FLT_MAX);
dm->foreachMappedVert(dm, vpaint_proj_dm_map_cosnos_update__map_cb, &vp_update, DM_FOREACH_USE_NORMAL); dm->foreachMappedVert(dm, vpaint_proj_dm_map_cosnos_update__map_cb, &vp_update, DM_FOREACH_USE_NORMAL);
} }
@ -207,13 +207,13 @@ struct VertProjHandle *ED_vpaint_proj_handle_create(Scene *scene, Object *ob,
vpaint_proj_dm_map_cosnos_init(scene, ob, vp_handle); vpaint_proj_dm_map_cosnos_init(scene, ob, vp_handle);
if (vp_handle->use_update) { if (vp_handle->use_update) {
vp_handle->dists = MEM_mallocN(sizeof(float) * me->totvert, __func__); vp_handle->dists_sq = MEM_mallocN(sizeof(float) * me->totvert, __func__);
vp_handle->ob = ob; vp_handle->ob = ob;
vp_handle->scene = scene; vp_handle->scene = scene;
} }
else { else {
vp_handle->dists = NULL; vp_handle->dists_sq = NULL;
vp_handle->ob = NULL; vp_handle->ob = NULL;
vp_handle->scene = NULL; vp_handle->scene = NULL;
@ -234,7 +234,7 @@ void ED_vpaint_proj_handle_update(struct VertProjHandle *vp_handle,
void ED_vpaint_proj_handle_free(struct VertProjHandle *vp_handle) void ED_vpaint_proj_handle_free(struct VertProjHandle *vp_handle)
{ {
if (vp_handle->use_update) { if (vp_handle->use_update) {
MEM_freeN(vp_handle->dists); MEM_freeN(vp_handle->dists_sq);
} }
MEM_freeN(vp_handle->vcosnos); MEM_freeN(vp_handle->vcosnos);

6
source/blender/editors/space_clip/clip_draw.c
View File

@ -762,7 +762,7 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
static float get_shortest_pattern_side(MovieTrackingMarker *marker) static float get_shortest_pattern_side(MovieTrackingMarker *marker)
{ {
int i, next; int i, next;
float len = FLT_MAX; float len_sq = FLT_MAX;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
float cur_len; float cur_len;
@ -771,10 +771,10 @@ static float get_shortest_pattern_side(MovieTrackingMarker *marker)
cur_len = len_squared_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]); cur_len = len_squared_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]);
len = min_ff(cur_len, len); len_sq = min_ff(cur_len, len_sq);
} }
return sqrtf(len); return sqrtf(len_sq);
} }
static void draw_marker_slide_square(float x, float y, float dx, float dy, int outline, float px[2]) static void draw_marker_slide_square(float x, float y, float dx, float dy, int outline, float px[2])

6
source/blender/editors/space_clip/tracking_ops.c
View File

@ -542,13 +542,13 @@ static int get_mouse_pattern_corner(SpaceClip *sc, MovieTrackingMarker *marker,
float len = FLT_MAX, dx, dy; float len = FLT_MAX, dx, dy;
for (i = 0; i < 4; i++) { for (i = 0; i < 4; i++) {
float cur_len; float cur_len_sq;
next = (i + 1) % 4; next = (i + 1) % 4;
cur_len = len_squared_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]); cur_len_sq = len_squared_v2v2(marker->pattern_corners[i], marker->pattern_corners[next]);
len = min_ff(cur_len, len); len = min_ff(cur_len_sq, len);
} }
len = sqrtf(len); len = sqrtf(len);

20
source/blender/editors/transform/transform.c
View File

@ -5273,8 +5273,8 @@ static void calcNonProportionalEdgeSlide(TransInfo *t, EdgeSlideData *sld, const
int i = 0; int i = 0;
float v_proj[2]; float v_proj[2];
float dist = 0; float dist_sq = 0;
float min_dist = FLT_MAX; float dist_min_sq = FLT_MAX;
if (t->spacetype == SPACE_VIEW3D) { if (t->spacetype == SPACE_VIEW3D) {
/* background mode support */ /* background mode support */
@ -5294,9 +5294,9 @@ static void calcNonProportionalEdgeSlide(TransInfo *t, EdgeSlideData *sld, const
sv->edge_len = len_v3v3(sv->dir_a, sv->dir_b); sv->edge_len = len_v3v3(sv->dir_a, sv->dir_b);
ED_view3d_project_float_v2_m4(ar, sv->v->co, v_proj, projectMat); ED_view3d_project_float_v2_m4(ar, sv->v->co, v_proj, projectMat);
dist = len_squared_v2v2(mval, v_proj); dist_sq = len_squared_v2v2(mval, v_proj);
if (dist < min_dist) { if (dist_sq < dist_min_sq) {
min_dist = dist; dist_min_sq = dist_sq;
sld->curr_sv_index = i; sld->curr_sv_index = i;
} }
} }
@ -6249,14 +6249,14 @@ static void calcVertSlideMouseActiveVert(struct TransInfo *t, const int mval[2])
TransDataVertSlideVert *sv; TransDataVertSlideVert *sv;
/* set the vertex to use as a reference for the mouse direction 'curr_sv_index' */ /* set the vertex to use as a reference for the mouse direction 'curr_sv_index' */
float dist = 0.0f; float dist_sq = 0.0f;
float min_dist = FLT_MAX; float dist_min_sq = FLT_MAX;
int i; int i;
for (i = 0, sv = sld->sv; i < sld->totsv; i++, sv++) { for (i = 0, sv = sld->sv; i < sld->totsv; i++, sv++) {
dist = len_squared_v2v2(mval_fl, sv->co_orig_2d); dist_sq = len_squared_v2v2(mval_fl, sv->co_orig_2d);
if (dist < min_dist) { if (dist_sq < dist_min_sq) {
min_dist = dist; dist_min_sq = dist_sq;
sld->curr_sv_index = i; sld->curr_sv_index = i;
} }
} }

8
source/blender/editors/transform/transform_conversions.c
View File

@ -238,7 +238,7 @@ static void set_prop_dist(TransInfo *t, const bool with_dist)
if ((tob->flag & TD_SELECTED) == 0) { if ((tob->flag & TD_SELECTED) == 0) {
TransData *td; TransData *td;
int i; int i;
float dist, vec[3]; float dist_sq, vec[3];
tob->rdist = -1.0f; // signal for next loop tob->rdist = -1.0f; // signal for next loop
@ -253,9 +253,9 @@ static void set_prop_dist(TransInfo *t, const bool with_dist)
sub_v3_v3(vec, vec_p); sub_v3_v3(vec, vec_p);
} }
dist = len_squared_v3(vec); dist_sq = len_squared_v3(vec);
if ((tob->rdist == -1.0f) || (dist < (tob->rdist * tob->rdist))) { if ((tob->rdist == -1.0f) || (dist_sq < (tob->rdist * tob->rdist))) {
tob->rdist = sqrtf(dist); tob->rdist = sqrtf(dist_sq);
} }
} }
else { else {

10
source/blender/editors/transform/transform_snap.c
View File

@ -680,22 +680,22 @@ eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
if (t->tsnap.status & MULTI_POINTS) { if (t->tsnap.status & MULTI_POINTS) {
TransSnapPoint *p, *closest_p = NULL; TransSnapPoint *p, *closest_p = NULL;
float closest_dist = TRANSFORM_SNAP_MAX_PX; float dist_min_sq = TRANSFORM_SNAP_MAX_PX;
const float mval_fl[2] = {t->mval[0], t->mval[1]}; const float mval_fl[2] = {t->mval[0], t->mval[1]};
float screen_loc[2]; float screen_loc[2];
for (p = t->tsnap.points.first; p; p = p->next) { for (p = t->tsnap.points.first; p; p = p->next) {
float dist; float dist_sq;
if (ED_view3d_project_float_global(t->ar, p->co, screen_loc, V3D_PROJ_TEST_NOP) != V3D_PROJ_RET_OK) { if (ED_view3d_project_float_global(t->ar, p->co, screen_loc, V3D_PROJ_TEST_NOP) != V3D_PROJ_RET_OK) {
continue; continue;
} }
dist = len_squared_v2v2(mval_fl, screen_loc); dist_sq = len_squared_v2v2(mval_fl, screen_loc);
if (dist < closest_dist) { if (dist_sq < dist_min_sq) {
closest_p = p; closest_p = p;
closest_dist = dist; dist_min_sq = dist_sq;
} }
} }

2
source/blender/makesrna/intern/rna_object_api.c
View File

@ -344,7 +344,7 @@ static void rna_Object_closest_point_on_mesh(Object *ob, ReportList *reports, fl
BVHTreeNearest nearest; BVHTreeNearest nearest;
nearest.index = -1; nearest.index = -1;
nearest.dist = max_dist * max_dist; nearest.dist_sq = max_dist * max_dist;
if (BLI_bvhtree_find_nearest(treeData.tree, point_co, &nearest, treeData.nearest_callback, &treeData) != -1) { if (BLI_bvhtree_find_nearest(treeData.tree, point_co, &nearest, treeData.nearest_callback, &treeData) != -1) {
copy_v3_v3(n_location, nearest.co); copy_v3_v3(n_location, nearest.co);

22
source/blender/modifiers/intern/MOD_solidify.c
View File

@ -425,12 +425,12 @@ static DerivedMesh *applyModifier(
const float offset_sq = offset * offset; const float offset_sq = offset * offset;
if (do_clamp) { if (do_clamp) {
vert_lens = MEM_callocN(sizeof(float) * numVerts, "vert_lens"); vert_lens = MEM_mallocN(sizeof(float) * numVerts, "vert_lens");
fill_vn_fl(vert_lens, (int)numVerts, FLT_MAX); fill_vn_fl(vert_lens, (int)numVerts, FLT_MAX);
for (i = 0; i < numEdges; i++) { for (i = 0; i < numEdges; i++) {
const float ed_len = len_squared_v3v3(mvert[medge[i].v1].co, mvert[medge[i].v2].co); const float ed_len_sq = len_squared_v3v3(mvert[medge[i].v1].co, mvert[medge[i].v2].co);
vert_lens[medge[i].v1] = min_ff(vert_lens[medge[i].v1], ed_len); vert_lens[medge[i].v1] = min_ff(vert_lens[medge[i].v1], ed_len_sq);
vert_lens[medge[i].v2] = min_ff(vert_lens[medge[i].v2], ed_len); vert_lens[medge[i].v2] = min_ff(vert_lens[medge[i].v2], ed_len_sq);
} }
} }
@ -578,22 +578,22 @@ static DerivedMesh *applyModifier(
} }
if (do_clamp) { if (do_clamp) {
float *vert_lens = MEM_callocN(sizeof(float) * numVerts, "vert_lens"); float *vert_lens_sq = MEM_callocN(sizeof(float) * numVerts, "vert_lens");
const float offset = fabsf(smd->offset) * smd->offset_clamp; const float offset = fabsf(smd->offset) * smd->offset_clamp;
const float offset_sq = offset * offset; const float offset_sq = offset * offset;
fill_vn_fl(vert_lens, (int)numVerts, FLT_MAX); fill_vn_fl(vert_lens_sq, (int)numVerts, FLT_MAX);
for (i = 0; i < numEdges; i++) { for (i = 0; i < numEdges; i++) {
const float ed_len = len_squared_v3v3(mvert[medge[i].v1].co, mvert[medge[i].v2].co); const float ed_len = len_squared_v3v3(mvert[medge[i].v1].co, mvert[medge[i].v2].co);
vert_lens[medge[i].v1] = min_ff(vert_lens[medge[i].v1], ed_len); vert_lens_sq[medge[i].v1] = min_ff(vert_lens_sq[medge[i].v1], ed_len);
vert_lens[medge[i].v2] = min_ff(vert_lens[medge[i].v2], ed_len); vert_lens_sq[medge[i].v2] = min_ff(vert_lens_sq[medge[i].v2], ed_len);
} }
for (i = 0; i < numVerts; i++) { for (i = 0; i < numVerts; i++) {
if (vert_lens[i] < offset_sq) { if (vert_lens_sq[i] < offset_sq) {
float scalar = sqrtf(vert_lens[i]) / offset; float scalar = sqrtf(vert_lens_sq[i]) / offset;
vert_angles[i] *= scalar; vert_angles[i] *= scalar;
} }
} }
MEM_freeN(vert_lens); MEM_freeN(vert_lens_sq);
} }
if (ofs_new) { if (ofs_new) {

12
source/blender/modifiers/intern/MOD_weightvgproximity.c
View File

@ -131,22 +131,22 @@ static void get_vert2geom_distance(int numVerts, float (*v_cos)[3],
* This will lead in prunning of the search tree. * This will lead in prunning of the search tree.
*/ */
if (dist_v) { if (dist_v) {
nearest_v.dist = nearest_v.index != -1 ? len_squared_v3v3(tmp_co, nearest_v.co) : FLT_MAX; nearest_v.dist_sq = nearest_v.index != -1 ? len_squared_v3v3(tmp_co, nearest_v.co) : FLT_MAX;
/* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */ /* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */
BLI_bvhtree_find_nearest(treeData_v.tree, tmp_co, &nearest_v, treeData_v.nearest_callback, &treeData_v); BLI_bvhtree_find_nearest(treeData_v.tree, tmp_co, &nearest_v, treeData_v.nearest_callback, &treeData_v);
dist_v[i] = sqrtf(nearest_v.dist); dist_v[i] = sqrtf(nearest_v.dist_sq);
} }
if (dist_e) { if (dist_e) {
nearest_e.dist = nearest_e.index != -1 ? len_squared_v3v3(tmp_co, nearest_e.co) : FLT_MAX; nearest_e.dist_sq = nearest_e.index != -1 ? len_squared_v3v3(tmp_co, nearest_e.co) : FLT_MAX;
/* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */ /* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */
BLI_bvhtree_find_nearest(treeData_e.tree, tmp_co, &nearest_e, treeData_e.nearest_callback, &treeData_e); BLI_bvhtree_find_nearest(treeData_e.tree, tmp_co, &nearest_e, treeData_e.nearest_callback, &treeData_e);
dist_e[i] = sqrtf(nearest_e.dist); dist_e[i] = sqrtf(nearest_e.dist_sq);
} }
if (dist_f) { if (dist_f) {
nearest_f.dist = nearest_f.index != -1 ? len_squared_v3v3(tmp_co, nearest_f.co) : FLT_MAX; nearest_f.dist_sq = nearest_f.index != -1 ? len_squared_v3v3(tmp_co, nearest_f.co) : FLT_MAX;
/* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */ /* Compute and store result. If invalid (-1 idx), keep FLT_MAX dist. */
BLI_bvhtree_find_nearest(treeData_f.tree, tmp_co, &nearest_f, treeData_f.nearest_callback, &treeData_f); BLI_bvhtree_find_nearest(treeData_f.tree, tmp_co, &nearest_f, treeData_f.nearest_callback, &treeData_f);
dist_f[i] = sqrtf(nearest_f.dist); dist_f[i] = sqrtf(nearest_f.dist_sq);
} }
} }

10
source/gameengine/Converter/BL_BlenderDataConversion.cpp
View File

@ -1238,7 +1238,7 @@ static float my_boundbox_mesh(Mesh *me, float *loc, float *size)
BoundBox *bb; BoundBox *bb;
float min[3], max[3]; float min[3], max[3];
float mloc[3], msize[3]; float mloc[3], msize[3];
float radius=0.0f, vert_radius, *co; float radius_sq=0.0f, vert_radius_sq, *co;
int a; int a;
if (me->bb==0) { if (me->bb==0) {
@ -1260,9 +1260,9 @@ static float my_boundbox_mesh(Mesh *me, float *loc, float *size)
/* radius */ /* radius */
vert_radius = len_squared_v3(co); vert_radius_sq = len_squared_v3(co);
if (vert_radius > radius) if (vert_radius_sq > radius_sq)
radius = vert_radius; radius_sq = vert_radius_sq;
} }
if (me->totvert) { if (me->totvert) {
@ -1288,7 +1288,7 @@ static float my_boundbox_mesh(Mesh *me, float *loc, float *size)
bb->vec[0][2] = bb->vec[3][2] = bb->vec[4][2] = bb->vec[7][2] = loc[2]-size[2]; bb->vec[0][2] = bb->vec[3][2] = bb->vec[4][2] = bb->vec[7][2] = loc[2]-size[2];
bb->vec[1][2] = bb->vec[2][2] = bb->vec[5][2] = bb->vec[6][2] = loc[2]+size[2]; bb->vec[1][2] = bb->vec[2][2] = bb->vec[5][2] = bb->vec[6][2] = loc[2]+size[2];
return sqrt(radius); return sqrtf_signed(radius_sq);
} }