Remove unused functions related to distance between BoundBox and ray
authorGermano Cavalcante <germano.costa@ig.com.br>
Fri, 17 Feb 2017 12:49:20 +0000 (09:49 -0300)
committerGermano Cavalcante <germano.costa@ig.com.br>
Fri, 17 Feb 2017 12:49:20 +0000 (09:49 -0300)
source/blender/blenkernel/BKE_bvhutils.h
source/blender/blenkernel/intern/bvhutils.c
source/blender/blenlib/BLI_kdopbvh.h
source/blender/blenlib/BLI_math_geom.h
source/blender/blenlib/intern/BLI_kdopbvh.c
source/blender/blenlib/intern/math_geom.c

index ad729ad37dd128b24680ed6b6955a0370deeb378..cb72f0859d55c0cff4cea1541a96a6fc309f051f 100644 (file)
@@ -54,7 +54,6 @@ typedef struct BVHTreeFromEditMesh {
        /* default callbacks to bvh nearest and raycast */
        BVHTree_NearestPointCallback nearest_callback;
        BVHTree_RayCastCallback raycast_callback;
-       BVHTree_NearestToRayCallback nearest_to_ray_callback;
 
        struct BMEditMesh *em;
 
@@ -75,7 +74,6 @@ typedef struct BVHTreeFromMesh {
        /* default callbacks to bvh nearest and raycast */
        BVHTree_NearestPointCallback nearest_callback;
        BVHTree_RayCastCallback raycast_callback;
-       BVHTree_NearestToRayCallback nearest_to_ray_callback;
 
        /* Vertex array, so that callbacks have instante access to data */
        const struct MVert *vert;
index 5a0006e679f0fd76c58089b64b5549b0a6239906..c0e4ef37a93f0a92a92ddd2be95b67f2304ca301 100644 (file)
@@ -376,45 +376,6 @@ static void mesh_edges_spherecast(void *userdata, int index, const BVHTreeRay *r
        }
 }
 
-#define V3_MUL_ELEM(a, b) \
-       (a)[0] * (b)[0], \
-       (a)[1] * (b)[1], \
-       (a)[2] * (b)[2]
-
-/* Callback to bvh tree nearest edge to ray.
- * The tree must have been built using bvhtree_from_mesh_edges.
- * userdata must be a BVHMeshCallbackUserdata built from the same mesh as the tree. */
-static void mesh_edges_nearest_to_ray(
-        void *userdata, const float ray_co[3], const float ray_dir[3],
-        const float scale[3], int index, BVHTreeNearest *nearest)
-{
-       struct BVHTreeFromMesh *data = userdata;
-       const MVert *vert = data->vert;
-       const MEdge *e = &data->edge[index];
-
-       const float t0[3]        = {V3_MUL_ELEM(vert[e->v1].co, scale)};
-       const float t1[3]        = {V3_MUL_ELEM(vert[e->v2].co, scale)};
-       const float origin_sc[3] = {V3_MUL_ELEM(ray_co, scale)};
-       const float dir_sc[3]    = {V3_MUL_ELEM(ray_dir, scale)};
-
-       float depth, point[3];
-       const float dist_sq = dist_squared_ray_to_seg_v3(origin_sc, dir_sc, t0, t1, point, &depth);
-
-       if (dist_sq < nearest->dist_sq) {
-               nearest->dist_sq = dist_sq;
-               nearest->index = index;
-
-               point[0] /= scale[0];
-               point[1] /= scale[1];
-               point[2] /= scale[2];
-
-               copy_v3_v3(nearest->co, point);
-               sub_v3_v3v3(nearest->no, t0, t1);
-       }
-}
-
-#undef V3_MUL_ELEM
-
 /** \} */
 
 /*
@@ -499,7 +460,6 @@ static void bvhtree_from_mesh_verts_setup_data(
         * remember the min distance to point is the same as the min distance to BV of point */
        data->nearest_callback = NULL;
        data->raycast_callback = mesh_verts_spherecast;
-       data->nearest_to_ray_callback = NULL;
 
        data->vert = vert;
        data->vert_allocated = vert_allocated;
@@ -524,7 +484,6 @@ BVHTree *bvhtree_from_editmesh_verts_ex(
                data->em = em;
                data->nearest_callback = NULL;
                data->raycast_callback = editmesh_verts_spherecast;
-               data->nearest_to_ray_callback = NULL;
        }
 
        return tree;
@@ -707,7 +666,6 @@ static void bvhtree_from_mesh_edges_setup_data(
 
        data->nearest_callback = mesh_edges_nearest_point;
        data->raycast_callback = mesh_edges_spherecast;
-       data->nearest_to_ray_callback = mesh_edges_nearest_to_ray;
 
        data->vert = vert;
        data->vert_allocated = vert_allocated;
@@ -735,8 +693,6 @@ BVHTree *bvhtree_from_editmesh_edges_ex(
                data->em = em;
                data->nearest_callback = NULL;  /* TODO */
                data->raycast_callback = NULL;  /* TODO */
-               /* TODO: not urgent however since users currently define own callbacks */
-               data->nearest_to_ray_callback = NULL;
        }
 
        return tree;
@@ -893,7 +849,6 @@ static void bvhtree_from_mesh_faces_setup_data(
 
        data->nearest_callback = mesh_faces_nearest_point;
        data->raycast_callback = mesh_faces_spherecast;
-       data->nearest_to_ray_callback = NULL;
 
        data->vert = vert;
        data->vert_allocated = vert_allocated;
@@ -1098,7 +1053,6 @@ static void bvhtree_from_mesh_looptri_setup_data(
 
        data->nearest_callback = mesh_looptri_nearest_point;
        data->raycast_callback = mesh_looptri_spherecast;
-       data->nearest_to_ray_callback = NULL;
 
        data->vert = vert;
        data->vert_allocated = vert_allocated;
@@ -1152,7 +1106,6 @@ BVHTree *bvhtree_from_editmesh_looptri_ex(
                data->tree = tree;
                data->nearest_callback = editmesh_looptri_nearest_point;
                data->raycast_callback = editmesh_looptri_spherecast;
-               data->nearest_to_ray_callback = NULL;
                data->sphere_radius = 0.0f;
                data->em = em;
                data->cached = bvhCache != NULL;
index 91d398016454ca10b45084928d3f44b5c91dad75..ba565fca52229fd96e076c1acac97b9f2d98d4f0 100644 (file)
@@ -95,10 +95,6 @@ typedef void (*BVHTree_NearestPointCallback)(void *userdata, int index, const fl
 /* callback must update hit in case it finds a nearest successful hit */
 typedef void (*BVHTree_RayCastCallback)(void *userdata, int index, const BVHTreeRay *ray, BVHTreeRayHit *hit);
 
-/* callback must update nearest in case it finds a nearest result */
-typedef void (*BVHTree_NearestToRayCallback)(void *userdata, const float ray_co[3], const float ray_dir[3],
-                                             const float scale[3], int index, BVHTreeNearest *nearest);
-
 /* callback to check if 2 nodes overlap (use thread if intersection results need to be stored) */
 typedef bool (*BVHTree_OverlapCallback)(void *userdata, int index_a, int index_b, int thread);
 
@@ -143,18 +139,6 @@ int BLI_bvhtree_find_nearest(
         BVHTree *tree, const float co[3], BVHTreeNearest *nearest,
         BVHTree_NearestPointCallback callback, void *userdata);
 
-int BLI_bvhtree_find_nearest_to_ray_angle(
-        BVHTree *tree, const float co[3], const float dir[3],
-        const bool ray_is_normalized, const float scale[3],
-        BVHTreeNearest *nearest,
-        BVHTree_NearestToRayCallback callback, void *userdata);
-
-int BLI_bvhtree_find_nearest_to_ray(
-        BVHTree *tree, const float co[3], const float dir[3],
-        const bool ray_is_normalized, const float scale[3],
-        BVHTreeNearest *nearest,
-        BVHTree_NearestToRayCallback callback, void *userdata);
-
 int BLI_bvhtree_ray_cast_ex(
         BVHTree *tree, const float co[3], const float dir[3], float radius, BVHTreeRayHit *hit,
         BVHTree_RayCastCallback callback, void *userdata,
index 4a85e859c16699f21ba1a8badd3d78e72875af36..f1d9c9571f207fad40a7207a6c3daae6c5b43c22 100644 (file)
@@ -298,23 +298,6 @@ bool isect_ray_aabb_v3_simple(
         const float bb_min[3], const float bb_max[3],
         float *tmin, float *tmax);
 
-struct NearestRayToAABB_Precalc {
-       float ray_origin[3];
-       float ray_direction[3];
-       float ray_inv_dir[3];
-       float cdot_axis[3];
-       float idiag_sq[3];
-       bool sign[3];
-};
-
-void dist_squared_ray_to_aabb_v3_precalc(
-        struct NearestRayToAABB_Precalc *data,
-        const float ray_origin[3], const float ray_direction[3]);
-float dist_squared_ray_to_aabb_v3(
-        const struct NearestRayToAABB_Precalc *data,
-        const float bb_min[3], const float bb_max[3],
-        bool r_axis_closest[3]);
-
 /* other */
 bool isect_sweeping_sphere_tri_v3(const float p1[3], const float p2[3], const float radius,
                                   const float v0[3], const float v1[3], const float v2[3], float *r_lambda, float ipoint[3]);
index b14007a88cb01ce2c3cf8794c1c82d1be070e15b..19d9711922e660012ffbdd63d7f3e841d075c7aa 100644 (file)
@@ -159,29 +159,6 @@ typedef struct BVHRayCastData {
        BVHTreeRayHit hit;
 } BVHRayCastData;
 
-typedef struct BVHNearestRayData {
-       BVHTree *tree;
-       BVHTree_NearestToRayCallback callback;
-       void    *userdata;
-
-       struct {
-               bool sign[3];
-               float origin[3];
-               float direction[3];
-
-               float direction_scaled_square[3];
-               float inv_dir[3];
-
-               float cdot_axis[3];
-       } ray;
-
-       bool pick_smallest[3];
-
-       BVHTreeNearest nearest;
-
-       float scale[3];
-} BVHNearestRayData;
-
 /** \} */
 
 
@@ -1898,453 +1875,6 @@ void BLI_bvhtree_ray_cast_all(
 }
 
 
-/* -------------------------------------------------------------------- */
-
-/** \name BLI_bvhtree_find_nearest_to_ray functions
- *
- * \{ */
-
-static void dist_squared_ray_to_aabb_scaled_v3_precalc(
-        BVHNearestRayData *data,
-        const float ray_origin[3], const float ray_direction[3],
-        const bool ray_is_normalized, const float scale[3])
-{
-       if (scale) {
-               copy_v3_v3(data->scale, scale);
-       }
-       else {
-               copy_v3_fl(data->scale, 1.0f);
-       }
-       /* un-normalize ray */
-       if (ray_is_normalized && scale &&
-           (data->scale[0] != 1.0f || data->scale[1] != 1.0f || data->scale[2] != 1.0f))
-       {
-               data->ray.direction[0] = ray_direction[0] * data->scale[0];
-               data->ray.direction[1] = ray_direction[1] * data->scale[1];
-               data->ray.direction[2] = ray_direction[2] * data->scale[2];
-
-               mul_v3_v3fl(data->ray.direction, ray_direction, 1 / len_v3(data->ray.direction));
-       }
-       else {
-               copy_v3_v3(data->ray.direction, ray_direction);
-       }
-
-       float dir_sq[3];
-
-       for (int i = 0; i < 3; i++) {
-               data->ray.origin[i] = ray_origin[i];
-               data->ray.inv_dir[i] = (data->ray.direction[i] != 0.0f) ?
-                                      (1.0f / data->ray.direction[i]) : FLT_MAX;
-               /* It has to be in function of `ray.inv_dir`,
-                * since the division of 1 by 0.0f, can be -inf or +inf */
-               data->ray.sign[i] = (data->ray.inv_dir[i] < 0.0f);
-
-               data->ray.direction_scaled_square[i] = data->ray.direction[i] * data->scale[i];
-
-               dir_sq[i] = SQUARE(data->ray.direction_scaled_square[i]);
-
-               data->ray.direction_scaled_square[i] *= data->scale[i];
-       }
-
-       /* `diag_sq` Length square of each face diagonal */
-       float diag_sq[3] = {
-               dir_sq[1] + dir_sq[2],
-               dir_sq[0] + dir_sq[2],
-               dir_sq[0] + dir_sq[1],
-       };
-
-       data->ray.cdot_axis[0] = (diag_sq[0] != 0.0f) ? data->ray.direction[0] / diag_sq[0] : FLT_MAX;
-       data->ray.cdot_axis[1] = (diag_sq[1] != 0.0f) ? data->ray.direction[1] / diag_sq[1] : FLT_MAX;
-       data->ray.cdot_axis[2] = (diag_sq[2] != 0.0f) ? data->ray.direction[2] / diag_sq[2] : FLT_MAX;
-}
-
-/**
- * Returns the squared distance from a ray to a bound-box `AABB`.
- * It is based on `fast_ray_nearest_hit` solution to obtain
- * the coordinates of the nearest edge of Bound Box to the ray
- */
-MINLINE float dist_squared_ray_to_aabb_scaled_v3__impl(
-        const BVHNearestRayData *data,
-        const float bv[6], float *r_depth_sq, bool r_axis_closest[3])
-{
-
-       /* `tmin` is a vector that has the smaller distances to each of the
-        * infinite planes of the `AABB` faces (hit in nearest face X plane,
-        * nearest face Y plane and nearest face Z plane) */
-       float local_bvmin[3], local_bvmax[3];
-
-       if (data->ray.sign[0]) {
-               local_bvmin[0] = bv[1];
-               local_bvmax[0] = bv[0];
-       }
-       else {
-               local_bvmin[0] = bv[0];
-               local_bvmax[0] = bv[1];
-       }
-
-       if (data->ray.sign[1]) {
-               local_bvmin[1] = bv[3];
-               local_bvmax[1] = bv[2];
-       }
-       else {
-               local_bvmin[1] = bv[2];
-               local_bvmax[1] = bv[3];
-       }
-
-       if (data->ray.sign[2]) {
-               local_bvmin[2] = bv[5];
-               local_bvmax[2] = bv[4];
-       }
-       else {
-               local_bvmin[2] = bv[4];
-               local_bvmax[2] = bv[5];
-       }
-
-       sub_v3_v3(local_bvmin, data->ray.origin);
-       sub_v3_v3(local_bvmax, data->ray.origin);
-
-       const float tmin[3] = {
-               local_bvmin[0] * data->ray.inv_dir[0],
-               local_bvmin[1] * data->ray.inv_dir[1],
-               local_bvmin[2] * data->ray.inv_dir[2],
-       };
-
-       /* `tmax` is a vector that has the longer distances to each of the
-        * infinite planes of the `AABB` faces (hit in farthest face X plane,
-        * farthest face Y plane and farthest face Z plane) */
-       const float tmax[3] = {
-               local_bvmax[0] * data->ray.inv_dir[0],
-               local_bvmax[1] * data->ray.inv_dir[1],
-               local_bvmax[2] * data->ray.inv_dir[2],
-       };
-       /* `v1` and `v3` is be the coordinates of the nearest `AABB` edge to the ray*/
-       float v1[3], v2[3];
-       /* `rtmin` is the highest value of the smaller distances. == max_axis_v3(tmin)
-        * `rtmax` is the lowest value of longer distances. == min_axis_v3(tmax)*/
-       float rtmin, rtmax, mul;
-       /* `main_axis` is the axis equivalent to edge close to the ray */
-       int main_axis;
-
-       r_axis_closest[0] = false;
-       r_axis_closest[1] = false;
-       r_axis_closest[2] = false;
-
-       /* *** min_axis_v3(tmax) *** */
-       if ((tmax[0] <= tmax[1]) && (tmax[0] <= tmax[2])) {
-               // printf("# Hit in X %s\n", data->sign[0] ? "min", "max");
-               rtmax = tmax[0];
-               v1[0] = v2[0] = local_bvmax[0];
-               mul = local_bvmax[0] * data->ray.direction_scaled_square[0];
-               main_axis = 3;
-               r_axis_closest[0] = data->ray.sign[0];
-       }
-       else if ((tmax[1] <= tmax[0]) && (tmax[1] <= tmax[2])) {
-               // printf("# Hit in Y %s\n", data->sign[1] ? "min", "max");
-               rtmax = tmax[1];
-               v1[1] = v2[1] = local_bvmax[1];
-               mul = local_bvmax[1] * data->ray.direction_scaled_square[1];
-               main_axis = 2;
-               r_axis_closest[1] = data->ray.sign[1];
-       }
-       else {
-               // printf("# Hit in Z %s\n", data->sign[2] ? "min", "max");
-               rtmax = tmax[2];
-               v1[2] = v2[2] = local_bvmax[2];
-               mul = local_bvmax[2] * data->ray.direction_scaled_square[2];
-               main_axis = 1;
-               r_axis_closest[2] = data->ray.sign[2];
-       }
-
-       /* *** max_axis_v3(tmin) *** */
-       if ((tmin[0] >= tmin[1]) && (tmin[0] >= tmin[2])) {
-               // printf("# To X %s\n", data->sign[0] ? "max", "min");
-               rtmin = tmin[0];
-               v1[0] = v2[0] = local_bvmin[0];
-               mul += local_bvmin[0] * data->ray.direction_scaled_square[0];
-               main_axis -= 3;
-               r_axis_closest[0] = !data->ray.sign[0];
-       }
-       else if ((tmin[1] >= tmin[0]) && (tmin[1] >= tmin[2])) {
-               // printf("# To Y %s\n", data->sign[1] ? "max", "min");
-               rtmin = tmin[1];
-               v1[1] = v2[1] = local_bvmin[1];
-               mul += local_bvmin[1] * data->ray.direction_scaled_square[1];
-               main_axis -= 1;
-               r_axis_closest[1] = !data->ray.sign[1];
-       }
-       else {
-               // printf("# To Z %s\n", data->sign[2] ? "max", "min");
-               rtmin = tmin[2];
-               v1[2] = v2[2] = local_bvmin[2];
-               mul += local_bvmin[2] * data->ray.direction_scaled_square[2];
-               main_axis -= 2;
-               r_axis_closest[2] = !data->ray.sign[2];
-       }
-       /* *** end min/max axis *** */
-
-       if (main_axis < 0)
-               main_axis += 3;
-
-       /* if rtmin < rtmax, ray intersect `AABB` */
-       if (rtmin <= rtmax) {
-#ifdef IGNORE_BEHIND_RAY
-               /* `if rtmax < depth_min`, the whole `AABB` is behind us */
-               if (rtmax < min_depth) {
-                       return fallback;
-               }
-#endif
-               const float proj = rtmin * data->ray.direction[main_axis];
-
-               if (data->ray.sign[main_axis])
-                       r_axis_closest[main_axis] = (proj - local_bvmax[main_axis]) < (local_bvmin[main_axis] - proj);
-               else
-                       r_axis_closest[main_axis] = (proj - local_bvmin[main_axis]) < (local_bvmax[main_axis] - proj);
-
-               //if (r_depth_sq)
-               //      *r_depth_sq = SQUARE(rtmin);
-
-               return 0.0f;
-       }
-#ifdef IGNORE_BEHIND_RAY
-       /* `if rtmin < depth_min`, the whole `AABB` is behing us */
-       else if (rtmin < min_depth) {
-               return fallback;
-       }
-#endif
-
-       if (data->ray.sign[main_axis]) {
-               v1[main_axis] = local_bvmax[main_axis];
-               v2[main_axis] = local_bvmin[main_axis];
-       }
-       else {
-               v1[main_axis] = local_bvmin[main_axis];
-               v2[main_axis] = local_bvmax[main_axis];
-       }
-       {
-               /* `proj` equals to nearest point on the ray closest to the edge `v1 v2` of the `AABB`. */
-               const float proj = mul * data->ray.cdot_axis[main_axis];
-               float depth_sq, r_point[3];
-               if (v1[main_axis] > proj) { /* the nearest point to the ray is the point v1 */
-                       r_axis_closest[main_axis] = true;
-                       /* `depth` is equivalent the distance of the the projection of v1 on the ray */
-                       depth_sq = mul + data->ray.direction_scaled_square[main_axis] * v1[main_axis];
-
-                       copy_v3_v3(r_point, v1);
-               }
-               else if (v2[main_axis] < proj) { /* the nearest point of the ray is the point v2 */
-                       r_axis_closest[main_axis] = false;
-
-                       depth_sq = mul + data->ray.direction_scaled_square[main_axis] * v2[main_axis];
-
-                       copy_v3_v3(r_point, v2);
-               }
-               else {  /* the nearest point of the ray is on the edge of the `AABB`. */
-                       r_axis_closest[main_axis] = (proj - v1[main_axis]) < (v2[main_axis] - proj);
-
-                       depth_sq = mul + data->ray.direction_scaled_square[main_axis] * proj;
-#if 0
-                       r_point[0] = main_axis == 0 ? proj : v2[0];
-                       r_point[1] = main_axis == 1 ? proj : v2[1];
-                       r_point[2] = main_axis == 2 ? proj : v2[2];
-#else
-                       v2[main_axis] = proj;
-                       copy_v3_v3(r_point, v2);
-#endif
-               }
-               depth_sq *= depth_sq;
-
-               if (r_depth_sq)
-                       *r_depth_sq = depth_sq;
-
-               /* TODO: scale can be optional */
-               r_point[0] *= data->scale[0];
-               r_point[1] *= data->scale[1];
-               r_point[2] *= data->scale[2];
-
-               return len_squared_v3(r_point) - depth_sq;
-       }
-}
-
-/**
- * <pre>
- *  + r_point
- *  |
- *  | dist
- *  |
- *  +----depth----+orig <-- dir
- *
- * tangent = dist/depth
- * </pre>
- */
-static float calc_tangent_sq(BVHNearestRayData *data, BVHNode *node)
-{
-       float depth_sq;
-       const float dist_sq = dist_squared_ray_to_aabb_scaled_v3__impl(
-               data, node->bv, &depth_sq, data->pick_smallest);
-
-       return (dist_sq != 0.0f) ? (dist_sq / depth_sq) : 0.0f;
-}
-
-static float calc_dist_sq_to_ray(BVHNearestRayData *data, BVHNode *node)
-{
-       return dist_squared_ray_to_aabb_scaled_v3__impl(
-               data, node->bv, NULL,
-               data->pick_smallest);
-}
-
-static void dfs_find_lowest_tangent_dfs(BVHNearestRayData *data, BVHNode *node)
-{
-       if (node->totnode == 0) {
-               if (data->callback) {
-                       data->callback(data->userdata, data->ray.origin, data->ray.direction,
-                                      data->scale, node->index, &data->nearest);
-               }
-               else {
-                       data->nearest.index = node->index;
-                       data->nearest.dist_sq = calc_tangent_sq(data, node);
-                       /* TODO: return a value to the data->nearest.co
-                        * not urgent however since users currently define own callbacks */
-               }
-       }
-       else {
-               int i;
-               /* First pick the closest node to dive on */
-               if (data->pick_smallest[node->main_axis]) {
-                       for (i = 0; i != node->totnode; i++) {
-                               if (calc_tangent_sq(data, node->children[i]) < data->nearest.dist_sq) {
-                                       dfs_find_lowest_tangent_dfs(data, node->children[i]);
-                               }
-                       }
-               }
-               else {
-                       for (i = node->totnode - 1; i >= 0; i--) {
-                               if (calc_tangent_sq(data, node->children[i]) < data->nearest.dist_sq) {
-                                       dfs_find_lowest_tangent_dfs(data, node->children[i]);
-                               }
-                       }
-               }
-       }
-}
-
-static void dfs_find_nearest_to_ray_dfs(BVHNearestRayData *data, BVHNode *node)
-{
-       if (node->totnode == 0) {
-               if (data->callback) {
-                       data->callback(data->userdata, data->ray.origin, data->ray.direction,
-                                      data->scale, node->index, &data->nearest);
-               }
-               else {
-                       data->nearest.index = node->index;
-                       data->nearest.dist_sq = calc_dist_sq_to_ray(data, node);
-                       /* TODO: return a value to the data->nearest.co
-                        * not urgent however since users currently define own callbacks */
-               }
-       }
-       else {
-               int i;
-               /* First pick the closest node to dive on */
-               if (data->pick_smallest[node->main_axis]) {
-                       for (i = 0; i != node->totnode; i++) {
-                               if (calc_dist_sq_to_ray(data, node->children[i]) < data->nearest.dist_sq) {
-                                       dfs_find_nearest_to_ray_dfs(data, node->children[i]);
-                               }
-                       }
-               }
-               else {
-                       for (i = node->totnode - 1; i >= 0; i--) {
-                               if (calc_dist_sq_to_ray(data, node->children[i]) < data->nearest.dist_sq) {
-                                       dfs_find_nearest_to_ray_dfs(data, node->children[i]);
-                               }
-                       }
-               }
-       }
-}
-
-/**
- * Returns the point whose tangent defined by the angle between the point and ray is the lowest
- * nearest.dist_sq returns the angle's tangent
- */
-int BLI_bvhtree_find_nearest_to_ray_angle(
-        BVHTree *tree, const float co[3], const float dir[3],
-        const bool ray_is_normalized, const float scale[3],
-        BVHTreeNearest *nearest,
-        BVHTree_NearestToRayCallback callback, void *userdata)
-{
-       BVHNearestRayData data;
-       BVHNode *root = tree->nodes[tree->totleaf];
-
-       data.tree = tree;
-
-       data.callback = callback;
-       data.userdata = userdata;
-
-       dist_squared_ray_to_aabb_scaled_v3_precalc(&data, co, dir, ray_is_normalized, scale);
-
-       if (nearest) {
-               memcpy(&data.nearest, nearest, sizeof(*nearest));
-       }
-       else {
-               data.nearest.index = -1;
-               data.nearest.dist_sq = FLT_MAX;
-       }
-
-       /* dfs search */
-       if (root) {
-               if (calc_tangent_sq(&data, root) < data.nearest.dist_sq)
-                       dfs_find_lowest_tangent_dfs(&data, root);
-       }
-
-       /* copy back results */
-       if (nearest) {
-               memcpy(nearest, &data.nearest, sizeof(*nearest));
-       }
-
-       return data.nearest.index;
-}
-
-/* return the nearest point to ray */
-int BLI_bvhtree_find_nearest_to_ray(
-        BVHTree *tree, const float co[3], const float dir[3],
-        const bool ray_is_normalized, const float scale[3],
-        BVHTreeNearest *nearest,
-        BVHTree_NearestToRayCallback callback, void *userdata)
-{
-       BVHNearestRayData data;
-       BVHNode *root = tree->nodes[tree->totleaf];
-
-       data.tree = tree;
-
-       data.callback = callback;
-       data.userdata = userdata;
-
-       dist_squared_ray_to_aabb_scaled_v3_precalc(&data, co, dir, ray_is_normalized, scale);
-
-       if (nearest) {
-               memcpy(&data.nearest, nearest, sizeof(*nearest));
-       }
-       else {
-               data.nearest.index = -1;
-               data.nearest.dist_sq = FLT_MAX;
-       }
-
-       /* dfs search */
-       if (root) {
-               if (calc_dist_sq_to_ray(&data, root) < data.nearest.dist_sq) {
-                       dfs_find_nearest_to_ray_dfs(&data, root);
-               }
-       }
-
-       /* copy back results */
-       if (nearest) {
-               memcpy(nearest, &data.nearest, sizeof(*nearest));
-       }
-
-       return data.nearest.index;
-}
-
-/** \} */
-
-
 /* -------------------------------------------------------------------- */
 
 /** \name BLI_bvhtree_range_query
index aeb6a550cd90a3639efa6d90b2bca4e22975c0dd..3cf26ccf90403c0cb5c15e53ce424e18dbefaede 100644 (file)
@@ -2337,224 +2337,6 @@ bool isect_ray_aabb_v3_simple(
        }
 }
 
-void dist_squared_ray_to_aabb_v3_precalc(
-        struct NearestRayToAABB_Precalc *data,
-        const float ray_origin[3], const float ray_direction[3])
-{
-       float dir_sq[3];
-
-       for (int i = 0; i < 3; i++) {
-               data->ray_origin[i] = ray_origin[i];
-               data->ray_direction[i] = ray_direction[i];
-               data->ray_inv_dir[i] = (data->ray_direction[i] != 0.0f) ? (1.0f / data->ray_direction[i]) : FLT_MAX;
-               /* It has to be a function of `ray_inv_dir`,
-                * since the division of 1 by 0.0f, can be -inf or +inf */
-               data->sign[i] = (data->ray_inv_dir[i] < 0.0f);
-
-               dir_sq[i] = SQUARE(data->ray_direction[i]);
-       }
-
-       /* `diag_sq` Length square of each face diagonal */
-       float diag_sq[3] = {
-               dir_sq[1] + dir_sq[2],
-               dir_sq[0] + dir_sq[2],
-               dir_sq[0] + dir_sq[1],
-       };
-       data->idiag_sq[0] = (diag_sq[0] > FLT_EPSILON) ? (1.0f / diag_sq[0]) : FLT_MAX;
-       data->idiag_sq[1] = (diag_sq[1] > FLT_EPSILON) ? (1.0f / diag_sq[1]) : FLT_MAX;
-       data->idiag_sq[2] = (diag_sq[2] > FLT_EPSILON) ? (1.0f / diag_sq[2]) : FLT_MAX;
-
-       data->cdot_axis[0] = data->ray_direction[0] * data->idiag_sq[0];
-       data->cdot_axis[1] = data->ray_direction[1] * data->idiag_sq[1];
-       data->cdot_axis[2] = data->ray_direction[2] * data->idiag_sq[2];
-}
-
-/**
- * Returns the squared distance from a ray to a bound-box `AABB`.
- * It is based on `fast_ray_nearest_hit` solution to obtain
- * the coordinates of the nearest edge of Bound Box to the ray
- */
-float dist_squared_ray_to_aabb_v3(
-        const struct NearestRayToAABB_Precalc *data,
-        const float bb_min[3], const float bb_max[3],
-        bool r_axis_closest[3])
-{
-       /* `tmin` is a vector that has the smaller distances to each of the
-        * infinite planes of the `AABB` faces (hit in nearest face X plane,
-        * nearest face Y plane and nearest face Z plane) */
-       float local_bvmin[3], local_bvmax[3];
-
-       if (data->sign[0] == 0) {
-               local_bvmin[0] = bb_min[0] - data->ray_origin[0];
-               local_bvmax[0] = bb_max[0] - data->ray_origin[0];
-       }
-       else {
-               local_bvmin[0] = bb_max[0] - data->ray_origin[0];
-               local_bvmax[0] = bb_min[0] - data->ray_origin[0];
-       }
-
-       if (data->sign[1] == 0) {
-               local_bvmin[1] = bb_min[1] - data->ray_origin[1];
-               local_bvmax[1] = bb_max[1] - data->ray_origin[1];
-       }
-       else {
-               local_bvmin[1] = bb_max[1] - data->ray_origin[1];
-               local_bvmax[1] = bb_min[1] - data->ray_origin[1];
-       }
-
-       if (data->sign[2] == 0) {
-               local_bvmin[2] = bb_min[2] - data->ray_origin[2];
-               local_bvmax[2] = bb_max[2] - data->ray_origin[2];
-       }
-       else {
-               local_bvmin[2] = bb_max[2] - data->ray_origin[2];
-               local_bvmax[2] = bb_min[2] - data->ray_origin[2];
-       }
-
-       const float tmin[3] = {
-               local_bvmin[0] * data->ray_inv_dir[0],
-               local_bvmin[1] * data->ray_inv_dir[1],
-               local_bvmin[2] * data->ray_inv_dir[2],
-       };
-
-       /* `tmax` is a vector that has the longer distances to each of the
-        * infinite planes of the `AABB` faces (hit in farthest face X plane,
-        * farthest face Y plane and farthest face Z plane) */
-       const float tmax[3] = {
-               local_bvmax[0] * data->ray_inv_dir[0],
-               local_bvmax[1] * data->ray_inv_dir[1],
-               local_bvmax[2] * data->ray_inv_dir[2],
-       };
-       /* `v1` and `v3` is be the coordinates of the nearest `AABB` edge to the ray*/
-       float v1[3], v2[3];
-       /* `rtmin` is the highest value of the smaller distances. == max_axis_v3(tmin)
-        * `rtmax` is the lowest value of longer distances. == min_axis_v3(tmax)*/
-       float rtmin, rtmax, mul, rdist;
-       /* `main_axis` is the axis equivalent to edge close to the ray */
-       int main_axis;
-
-       r_axis_closest[0] = false;
-       r_axis_closest[1] = false;
-       r_axis_closest[2] = false;
-
-       /* *** min_axis_v3(tmax) *** */
-       if ((tmax[0] <= tmax[1]) && (tmax[0] <= tmax[2])) {
-               // printf("# Hit in X %s\n", data->sign[0] ? "min", "max");
-               rtmax = tmax[0];
-               v1[0] = v2[0] = local_bvmax[0];
-               mul = local_bvmax[0] * data->ray_direction[0];
-               main_axis = 3;
-               r_axis_closest[0] = data->sign[0];
-       }
-       else if ((tmax[1] <= tmax[0]) && (tmax[1] <= tmax[2])) {
-               // printf("# Hit in Y %s\n", data->sign[1] ? "min", "max");
-               rtmax = tmax[1];
-               v1[1] = v2[1] = local_bvmax[1];
-               mul = local_bvmax[1] * data->ray_direction[1];
-               main_axis = 2;
-               r_axis_closest[1] = data->sign[1];
-       }
-       else {
-               // printf("# Hit in Z %s\n", data->sign[2] ? "min", "max");
-               rtmax = tmax[2];
-               v1[2] = v2[2] = local_bvmax[2];
-               mul = local_bvmax[2] * data->ray_direction[2];
-               main_axis = 1;
-               r_axis_closest[2] = data->sign[2];
-       }
-
-       /* *** max_axis_v3(tmin) *** */
-       if ((tmin[0] >= tmin[1]) && (tmin[0] >= tmin[2])) {
-               // printf("# To X %s\n", data->sign[0] ? "max", "min");
-               rtmin = tmin[0];
-               v1[0] = v2[0] = local_bvmin[0];
-               mul += local_bvmin[0] * data->ray_direction[0];
-               main_axis -= 3;
-               r_axis_closest[0] = !data->sign[0];
-       }
-       else if ((tmin[1] >= tmin[0]) && (tmin[1] >= tmin[2])) {
-               // printf("# To Y %s\n", data->sign[1] ? "max", "min");
-               rtmin = tmin[1];
-               v1[1] = v2[1] = local_bvmin[1];
-               mul += local_bvmin[1] * data->ray_direction[1];
-               main_axis -= 1;
-               r_axis_closest[1] = !data->sign[1];
-       }
-       else {
-               // printf("# To Z %s\n", data->sign[2] ? "max", "min");
-               rtmin = tmin[2];
-               v1[2] = v2[2] = local_bvmin[2];
-               mul += local_bvmin[2] * data->ray_direction[2];
-               main_axis -= 2;
-               r_axis_closest[2] = !data->sign[2];
-       }
-       /* *** end min/max axis *** */
-
-
-       /* `if rtmax < 0`, the whole `AABB` is behing us */
-       if ((rtmax < 0.0f) && (rtmin < 0.0f)) {
-               return FLT_MAX;
-       }
-
-       if (main_axis < 0) {
-               main_axis += 3;
-       }
-
-       if (data->sign[main_axis] == 0) {
-               v1[main_axis] = local_bvmin[main_axis];
-               v2[main_axis] = local_bvmax[main_axis];
-       }
-       else {
-               v1[main_axis] = local_bvmax[main_axis];
-               v2[main_axis] = local_bvmin[main_axis];
-       }
-
-       /* if rtmin < rtmax, ray intersect `AABB` */
-       if (rtmin <= rtmax) {
-               const float proj = rtmin * data->ray_direction[main_axis];
-               rdist = 0.0f;
-               r_axis_closest[main_axis] = (proj - v1[main_axis]) < (v2[main_axis] - proj);
-       }
-       else {
-               /* `proj` equals to nearest point on the ray closest to the edge `v1 v2` of the `AABB`. */
-               const float proj = mul * data->cdot_axis[main_axis];
-               float depth;
-               if (v1[main_axis] > proj) {  /* the nearest point to the ray is the point v1 */
-                       /* `depth` is equivalent the distance from the origin to the point v1,
-                        * Here's a faster way to calculate the dot product of v1 and ray
-                        * (depth = dot_v3v3(v1, data->ray.direction))*/
-                       depth = mul + data->ray_direction[main_axis] * v1[main_axis];
-                       rdist = len_squared_v3(v1) - SQUARE(depth);
-                       r_axis_closest[main_axis] = true;
-               }
-               else if (v2[main_axis] < proj) {  /* the nearest point of the ray is the point v2 */
-                       depth = mul + data->ray_direction[main_axis] * v2[main_axis];
-                       rdist = len_squared_v3(v2) - SQUARE(depth);
-                       r_axis_closest[main_axis] = false;
-               }
-               else {  /* the nearest point of the ray is on the edge of the `AABB`. */
-                       float v[2];
-                       mul *= data->idiag_sq[main_axis];
-                       if (main_axis == 0) {
-                               v[0] = (mul * data->ray_direction[1]) - v1[1];
-                               v[1] = (mul * data->ray_direction[2]) - v1[2];
-                       }
-                       else if (main_axis == 1) {
-                               v[0] = (mul * data->ray_direction[0]) - v1[0];
-                               v[1] = (mul * data->ray_direction[2]) - v1[2];
-                       }
-                       else {
-                               v[0] = (mul * data->ray_direction[0]) - v1[0];
-                               v[1] = (mul * data->ray_direction[1]) - v1[1];
-                       }
-                       rdist = len_squared_v2(v);
-                       r_axis_closest[main_axis] = (proj - v1[main_axis]) < (v2[main_axis] - proj);
-               }
-       }
-
-       return rdist;
-}
-
 /* find closest point to p on line through (l1, l2) and return lambda,
  * where (0 <= lambda <= 1) when cp is in the line segment (l1, l2)
  */