refactor screen foreach functions to accept float[2] arguments rather then int pairs.
authorCampbell Barton <ideasman42@gmail.com>
Wed, 10 Oct 2012 01:22:19 +0000 (01:22 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 10 Oct 2012 01:22:19 +0000 (01:22 +0000)
overall means less converting between float and int (and short in some cases).

16 files changed:
source/blender/blenlib/BLI_math_vector.h
source/blender/blenlib/BLI_rect.h
source/blender/blenlib/intern/math_vector_inline.c
source/blender/blenlib/intern/rct.c
source/blender/editors/curve/editcurve.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/ED_mesh.h
source/blender/editors/include/ED_view3d.h
source/blender/editors/mesh/editmesh_knife.c
source/blender/editors/mesh/editmesh_loopcut.c
source/blender/editors/mesh/editmesh_select.c
source/blender/editors/mesh/meshtools.c
source/blender/editors/object/object_lattice.c
source/blender/editors/space_view3d/drawobject.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_select.c

index de1d423..a471f95 100644 (file)
@@ -139,12 +139,16 @@ MINLINE void star_m3_v3(float rmat[3][3], float a[3]);
 
 MINLINE float len_squared_v2(const float v[2]);
 MINLINE float len_squared_v3(const float v[3]);
+MINLINE float len_manhattan_v2(const float v[2]);
+MINLINE float len_manhattan_v3(const float v[3]);
 MINLINE float len_v2(const float a[2]);
 MINLINE float len_v2v2(const float a[2], const float b[2]);
 MINLINE float len_squared_v2v2(const float a[2], const float b[2]);
+MINLINE float len_squared_v3v3(const float a[3], const float b[3]);
+MINLINE float len_manhattan_v2v2(const float a[2], const float b[2]);
+MINLINE float len_manhattan_v3v3(const float a[3], const float b[3]);
 MINLINE float len_v3(const float a[3]);
 MINLINE float len_v3v3(const float a[3], const float b[3]);
-MINLINE float len_squared_v3v3(const float a[3], const float b[3]);
 
 MINLINE float normalize_v2(float r[2]);
 MINLINE float normalize_v2_v2(float r[2], const float a[2]);
index de4c2cf..f84820e 100644 (file)
@@ -66,9 +66,7 @@ int  BLI_rcti_isect_pt_v(const struct rcti *rect, const int xy[2]);
 int  BLI_rctf_isect_pt(const struct rctf *rect, const float x, const float y);
 int  BLI_rctf_isect_pt_v(const struct rctf *rect, const float xy[2]);
 int  BLI_rcti_isect_segment(const struct rcti *rect, const int s1[2], const int s2[2]);
-#if 0 /* NOT NEEDED YET */
-int  BLI_rctf_isect_segment(struct rcti *rect, int s1[2], int s2[2]);
-#endif
+int  BLI_rctf_isect_segment(const struct rctf *rect, const float s1[2], const float s2[2]);
 void BLI_rctf_union(struct rctf *rctf1, const struct rctf *rctf2);
 void BLI_rcti_union(struct rcti *rcti1, const struct rcti *rcti2);
 void BLI_rcti_rctf_copy(struct rcti *dst, const struct rctf *src);
index 2cfe999..de10387 100644 (file)
@@ -561,6 +561,16 @@ MINLINE float len_squared_v3(const float v[3])
        return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
 }
 
+MINLINE float len_manhattan_v2(const float v[2])
+{
+       return fabsf(v[0]) + fabsf(v[1]);
+}
+
+MINLINE float len_manhattan_v3(const float v[3])
+{
+       return fabsf(v[0]) + fabsf(v[1]) + fabsf(v[2]);
+}
+
 MINLINE float len_v2(const float v[2])
 {
        return sqrtf(v[0] * v[0] + v[1] * v[1]);
@@ -588,20 +598,36 @@ MINLINE float len_squared_v2v2(const float a[2], const float b[2])
        return dot_v2v2(d, d);
 }
 
-MINLINE float len_v3v3(const float a[3], const float b[3])
+MINLINE float len_squared_v3v3(const float a[3], const float b[3])
 {
        float d[3];
 
        sub_v3_v3v3(d, b, a);
-       return len_v3(d);
+       return dot_v3v3(d, d);
 }
 
-MINLINE float len_squared_v3v3(const float a[3], const float b[3])
+MINLINE float len_manhattan_v2v2(const float a[2], const float b[2])
+{
+       float d[2];
+
+       sub_v2_v2v2(d, b, a);
+       return len_manhattan_v2(d);
+}
+
+MINLINE float len_manhattan_v3v3(const float a[3], const float b[3])
 {
        float d[3];
 
        sub_v3_v3v3(d, b, a);
-       return dot_v3v3(d, d);
+       return len_manhattan_v3(d);
+}
+
+MINLINE float len_v3v3(const float a[3], const float b[3])
+{
+       float d[3];
+
+       sub_v3_v3v3(d, b, a);
+       return len_v3(d);
 }
 
 MINLINE float normalize_v2_v2(float r[2], const float a[2])
index cab383b..2e2619d 100644 (file)
@@ -102,7 +102,19 @@ int BLI_rctf_isect_pt_v(const rctf *rect, const float xy[2])
 }
 
 /* based closely on 'isect_line_line_v2_int', but in modified so corner cases are treated as intersections */
-static int isect_segments(const int v1[2], const int v2[2], const int v3[2], const int v4[2])
+static int isect_segments_i(const int v1[2], const int v2[2], const int v3[2], const int v4[2])
+{
+       const double div = (double)((v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]));
+       if (div == 0.0f) {
+               return 1; /* co-linear */
+       }
+       else {
+               const double labda = (double)((v1[1] - v3[1]) * (v4[0] - v3[0]) - (v1[0] - v3[0]) * (v4[1] - v3[1])) / div;
+               const double mu    = (double)((v1[1] - v3[1]) * (v2[0] - v1[0]) - (v1[0] - v3[0]) * (v2[1] - v1[1])) / div;
+               return (labda >= 0.0f && labda <= 1.0f && mu >= 0.0f && mu <= 1.0f);
+       }
+}
+static int isect_segments_fl(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
 {
        const double div = (double)((v2[0] - v1[0]) * (v4[1] - v3[1]) - (v2[1] - v1[1]) * (v4[0] - v3[0]));
        if (div == 0.0f) {
@@ -134,14 +146,49 @@ int BLI_rcti_isect_segment(const rcti *rect, const int s1[2], const int s2[2])
                /* diagonal: [/] */
                tvec1[0] = rect->xmin; tvec1[1] = rect->ymin;
                tvec2[0] = rect->xmin; tvec2[1] = rect->ymax;
-               if (isect_segments(s1, s2, tvec1, tvec2)) {
+               if (isect_segments_i(s1, s2, tvec1, tvec2)) {
+                       return 1;
+               }
+
+               /* diagonal: [\] */
+               tvec1[0] = rect->xmin; tvec1[1] = rect->ymax;
+               tvec2[0] = rect->xmax; tvec2[1] = rect->ymin;
+               if (isect_segments_i(s1, s2, tvec1, tvec2)) {
+                       return 1;
+               }
+
+               /* no intersection */
+               return 0;
+       }
+}
+
+int BLI_rctf_isect_segment(const rctf *rect, const float s1[2], const float s2[2])
+{
+       /* first do outside-bounds check for both points of the segment */
+       if (s1[0] < rect->xmin && s2[0] < rect->xmin) return 0;
+       if (s1[0] > rect->xmax && s2[0] > rect->xmax) return 0;
+       if (s1[1] < rect->ymin && s2[1] < rect->ymin) return 0;
+       if (s1[1] > rect->ymax && s2[1] > rect->ymax) return 0;
+
+       /* if either points intersect then we definetly intersect */
+       if (BLI_rctf_isect_pt_v(rect, s1) || BLI_rctf_isect_pt_v(rect, s2)) {
+               return 1;
+       }
+       else {
+               /* both points are outside but may insersect the rect */
+               float tvec1[2];
+               float tvec2[2];
+               /* diagonal: [/] */
+               tvec1[0] = rect->xmin; tvec1[1] = rect->ymin;
+               tvec2[0] = rect->xmin; tvec2[1] = rect->ymax;
+               if (isect_segments_fl(s1, s2, tvec1, tvec2)) {
                        return 1;
                }
 
                /* diagonal: [\] */
                tvec1[0] = rect->xmin; tvec1[1] = rect->ymax;
                tvec2[0] = rect->xmax; tvec2[1] = rect->ymin;
-               if (isect_segments(s1, s2, tvec1, tvec2)) {
+               if (isect_segments_fl(s1, s2, tvec1, tvec2)) {
                        return 1;
                }
 
index d22b9f2..14c233a 100644 (file)
@@ -3226,12 +3226,12 @@ void CURVE_OT_subdivide(wmOperatorType *ot)
 
 /******************** find nearest ************************/
 
-static void findnearestNurbvert__doClosest(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
+static void findnearestNurbvert__doClosest(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co[2])
 {
-       struct { BPoint *bp; BezTriple *bezt; Nurb *nurb; int dist, hpoint, select, mval[2]; } *data = userData;
+       struct { BPoint *bp; BezTriple *bezt; Nurb *nurb; float dist; int hpoint, select; float mval_fl[2]; } *data = userData;
 
        short flag;
-       short temp;
+       float dist_test;
 
        if (bp) {
                flag = bp->f1;
@@ -3248,12 +3248,12 @@ static void findnearestNurbvert__doClosest(void *userData, Nurb *nu, BPoint *bp,
                }
        }
 
-       temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
-       if ((flag & 1) == data->select) temp += 5;
-       if (bezt && beztindex == 1) temp += 3;  /* middle points get a small disadvantage */
+       dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
+       if ((flag & SELECT) == data->select) dist_test += 5.0f;
+       if (bezt && beztindex == 1) dist_test += 3.0f;  /* middle points get a small disadvantage */
 
-       if (temp < data->dist) {
-               data->dist = temp;
+       if (dist_test < data->dist) {
+               data->dist = dist_test;
 
                data->bp = bp;
                data->bezt = bezt;
@@ -3267,13 +3267,13 @@ static short findnearestNurbvert(ViewContext *vc, short sel, const int mval[2],
        /* (sel == 1): selected gets a disadvantage */
        /* in nurb and bezt or bp the nearest is written */
        /* return 0 1 2: handlepunt */
-       struct { BPoint *bp; BezTriple *bezt; Nurb *nurb; int dist, hpoint, select, mval[2]; } data = {NULL};
+       struct { BPoint *bp; BezTriple *bezt; Nurb *nurb; float dist; int hpoint, select; float mval_fl[2]; } data = {NULL};
 
        data.dist = 100;
        data.hpoint = 0;
        data.select = sel;
-       data.mval[0] = mval[0];
-       data.mval[1] = mval[1];
+       data.mval_fl[0] = mval[0];
+       data.mval_fl[1] = mval[1];
 
        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
        nurbs_foreachScreenVert(vc, findnearestNurbvert__doClosest, &data);
index c07f0db..d0b4877 100644 (file)
@@ -787,11 +787,16 @@ static short gp_stroke_eraser_strokeinside(const int mval[], const int UNUSED(mv
                                            int rad, int x0, int y0, int x1, int y1)
 {
        /* simple within-radius check for now */
-       if (edge_inside_circle(mval[0], mval[1], rad, x0, y0, x1, y1))
-               return 1;
+       const float mval_fl[2]     = {mval[0], mval[1]};
+       const float screen_co_a[2] = {x0, y0};
+       const float screen_co_b[2] = {x1, y1};
+
+       if (edge_inside_circle(mval_fl, rad, screen_co_a, screen_co_b)) {
+               return TRUE;
+       }
        
        /* not inside */
-       return 0;
+       return FALSE;
 } 
 
 static void gp_point_to_xy(ARegion *ar, View2D *v2d, rctf *subrect, bGPDstroke *gps, bGPDspoint *pt,
index 093872c..f55f775 100644 (file)
@@ -142,9 +142,9 @@ int  EDBM_backbuf_border_mask_init(struct ViewContext *vc, const int mcords[][2]
                                    short xmin, short ymin, short xmax, short ymax);
 int  EDBM_backbuf_circle_init(struct ViewContext *vc, short xs, short ys, short rads);
 
-struct BMVert *EDBM_vert_find_nearest(struct ViewContext *vc, int *dist, short sel, short strict);
-struct BMEdge *EDBM_edge_find_nearest(struct ViewContext *vc, int *dist);
-struct BMFace *EDBM_face_find_nearest(struct ViewContext *vc, int *dist);
+struct BMVert *EDBM_vert_find_nearest(struct ViewContext *vc, float *r_dist, const short sel, const short strict);
+struct BMEdge *EDBM_edge_find_nearest(struct ViewContext *vc, float *r_dist);
+struct BMFace *EDBM_face_find_nearest(struct ViewContext *vc, float *r_dist);
 
 int  EDBM_select_pick(struct bContext *C, const int mval[2], short extend, short deselect, short toggle);
 
index f71133d..c02bc1d 100644 (file)
@@ -167,14 +167,14 @@ void ED_view3d_calc_camera_border(struct Scene *scene, struct ARegion *ar, struc
 void ED_view3d_calc_camera_border_size(struct Scene *scene, struct ARegion *ar, struct View3D *v3d, struct RegionView3D *rv3d, float size_r[2]);
 
 /* drawobject.c iterators */
-void mesh_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BMVert *eve, int x, int y, int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenEdge(struct ViewContext *vc, void (*func)(void *userData, struct BMEdge *eed, int x0, int y0, int x1, int y1, int index), void *userData, eV3DClipTest clipVerts);
-void mesh_foreachScreenFace(struct ViewContext *vc, void (*func)(void *userData, struct BMFace *efa, int x, int y, int index), void *userData);
-void nurbs_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt, int beztindex, int x, int y), void *userData);
-void mball_foreachScreenElem(struct ViewContext *vc, void (*func)(void *userData, struct MetaElem *ml, int x, int y), void *userData);
-void lattice_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BPoint *bp, int x, int y), void *userData);
-void armature_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct EditBone *ebone, int x0, int y0, int x1, int y1), void *userData);
-void pose_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct bPoseChannel *pchan, int x0, int y0, int x1, int y1), void *userData);
+void mesh_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BMVert *eve, const float screen_co[2], int index), void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenEdge(struct ViewContext *vc, void (*func)(void *userData, struct BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index), void *userData, eV3DClipTest clipVerts);
+void mesh_foreachScreenFace(struct ViewContext *vc, void (*func)(void *userData, struct BMFace *efa, const float screen_co[2], int index), void *userData);
+void nurbs_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct Nurb *nu, struct BPoint *bp, struct BezTriple *bezt, int beztindex, const float screen_co[2]), void *userData);
+void mball_foreachScreenElem(struct ViewContext *vc, void (*func)(void *userData, struct MetaElem *ml, const float screen_co[2]), void *userData);
+void lattice_foreachScreenVert(struct ViewContext *vc, void (*func)(void *userData, struct BPoint *bp, const float screen_co[2]), void *userData);
+void armature_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
+void pose_foreachScreenBone(struct ViewContext *vc, void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]), void *userData);
 
 
 void ED_view3d_clipping_calc(struct BoundBox *bb, float planes[4][4], struct bglMats *mats, const struct rcti *rect);
@@ -191,7 +191,8 @@ void drawcircball(int mode, const float cent[3], float rad, float tmat[][4]);
 /* backbuffer select and draw support */
 void view3d_validate_backbuf(struct ViewContext *vc);
 struct ImBuf *view3d_read_backbuf(struct ViewContext *vc, short xmin, short ymin, short xmax, short ymax);
-unsigned int view3d_sample_backbuf_rect(struct ViewContext *vc, const int mval[2], int size, unsigned int min, unsigned int max, int *dist, short strict,
+unsigned int view3d_sample_backbuf_rect(struct ViewContext *vc, const int mval[2], int size,
+                                        unsigned int min, unsigned int max, float *dist, short strict,
                                         void *handle, unsigned int (*indextest)(void *handle, unsigned int index));
 unsigned int view3d_sample_backbuf(struct ViewContext *vc, int x, int y);
 
@@ -215,7 +216,7 @@ int view3d_get_view_aligned_coordinate(struct ViewContext *vc, float fp[3], cons
 void view3d_get_transformation(const struct ARegion *ar, struct RegionView3D *rv3d, struct Object *ob, struct bglMats *mats);
 
 /* XXX should move to BLI_math */
-int edge_inside_circle(int centx, int centy, int rad, int x1, int y1, int x2, int y2);
+int edge_inside_circle(const float cent[2], float radius, const float screen_co_a[2], const float screen_co_b[2]);
 
 /* get 3d region from context, also if mouse is in header or toolbar */
 struct RegionView3D *ED_view3d_context_rv3d(struct bContext *C);
index 4f4fc27..1d19d35 100644 (file)
@@ -1418,7 +1418,7 @@ static void knife_input_ray_cast(KnifeTool_OpData *kcd, const int mval_i[2],
 static BMFace *knife_find_closest_face(KnifeTool_OpData *kcd, float co[3], float cageco[3], int *is_space)
 {
        BMFace *f;
-       int dist = KMAXDIST;
+       float dist = KMAXDIST;
        float origin[3];
        float ray[3];
 
index c0a36e2..98fae2c 100644 (file)
@@ -416,7 +416,7 @@ static int ringcut_invoke(bContext *C, wmOperator *op, wmEvent *evt)
        Object *obedit = CTX_data_edit_object(C);
        RingSelOpData *lcd;
        BMEdge *edge;
-       int dist = 75;
+       float dist = 75.0f;
 
        if (modifiers_isDeformedByLattice(obedit) || modifiers_isDeformedByArmature(obedit))
                BKE_report(op->reports, RPT_WARNING, "Loop cut doesn't work well on deformed edit mesh display");
@@ -513,7 +513,7 @@ static int loopcut_modal(bContext *C, wmOperator *op, wmEvent *event)
                        ED_region_tag_redraw(lcd->ar);
                        break;
                case MOUSEMOVE: { /* mouse moved somewhere to select another loop */
-                       int dist = 75;
+                       float dist = 75.0f;
                        BMEdge *edge;
 
                        lcd->vc.mval[0] = event->mval[0];
index 680d15e..2e40419 100644 (file)
@@ -330,9 +330,9 @@ int EDBM_backbuf_circle_init(ViewContext *vc, short xs, short ys, short rads)
        
 }
 
-static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y, int index)
+static void findnearestvert__doClosest(void *userData, BMVert *eve, const float screen_co[2], int index)
 {
-       struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } *data = userData;
+       struct { float mval_fl[2], pass, select, strict; float dist, lastIndex, closestIndex; BMVert *closest; } *data = userData;
 
        if (data->pass == 0) {
                if (index <= data->lastIndex)
@@ -344,18 +344,18 @@ static void findnearestvert__doClosest(void *userData, BMVert *eve, int x, int y
        }
 
        if (data->dist > 3) {
-               int temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
+               float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
                if (BM_elem_flag_test(eve, BM_ELEM_SELECT) == data->select) {
                        if (data->strict == 1) {
                                return;
                        }
                        else {
-                               temp += 5;
+                               dist_test += 5;
                        }
                }
 
-               if (temp < data->dist) {
-                       data->dist = temp;
+               if (dist_test < data->dist) {
+                       data->dist = dist_test;
                        data->closest = eve;
                        data->closestIndex = index;
                }
@@ -382,10 +382,10 @@ static unsigned int findnearestvert__backbufIndextest(void *handle, unsigned int
  *      if 0, unselected vertice are given the bias
  * strict: if 1, the vertice corresponding to the sel parameter are ignored and not just biased 
  */
-BMVert *EDBM_vert_find_nearest(ViewContext *vc, int *dist, short sel, short strict)
+BMVert *EDBM_vert_find_nearest(ViewContext *vc, float *r_dist, const short sel, const short strict)
 {
        if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
-               int distance;
+               float distance;
                unsigned int index;
                BMVert *eve;
                
@@ -400,8 +400,8 @@ BMVert *EDBM_vert_find_nearest(ViewContext *vc, int *dist, short sel, short stri
                
                eve = BM_vert_at_index(vc->em->bm, index - 1);
                
-               if (eve && distance < *dist) {
-                       *dist = distance;
+               if (eve && distance < *r_dist) {
+                       *r_dist = distance;
                        return eve;
                }
                else {
@@ -410,7 +410,7 @@ BMVert *EDBM_vert_find_nearest(ViewContext *vc, int *dist, short sel, short stri
                        
        }
        else {
-               struct { short mval[2], pass, select, strict; int dist, lastIndex, closestIndex; BMVert *closest; } data;
+               struct { float mval_fl[2], pass, select, strict; float dist, lastIndex, closestIndex; BMVert *closest; } data;
                static int lastSelectedIndex = 0;
                static BMVert *lastSelected = NULL;
                
@@ -420,10 +420,10 @@ BMVert *EDBM_vert_find_nearest(ViewContext *vc, int *dist, short sel, short stri
                }
 
                data.lastIndex = lastSelectedIndex;
-               data.mval[0] = vc->mval[0];
-               data.mval[1] = vc->mval[1];
+               data.mval_fl[0] = vc->mval[0];
+               data.mval_fl[1] = vc->mval[1];
                data.select = sel;
-               data.dist = *dist;
+               data.dist = *r_dist;
                data.strict = strict;
                data.closest = NULL;
                data.closestIndex = 0;
@@ -439,7 +439,7 @@ BMVert *EDBM_vert_find_nearest(ViewContext *vc, int *dist, short sel, short stri
                        mesh_foreachScreenVert(vc, findnearestvert__doClosest, &data, V3D_CLIP_TEST_RV3D_CLIPPING);
                }
 
-               *dist = data.dist;
+               *r_dist = data.dist;
                lastSelected = data.closest;
                lastSelectedIndex = data.closestIndex;
 
@@ -462,18 +462,12 @@ float labda_PdistVL2Dfl(const float v1[2], const float v2[2], const float v3[2])
 }
 
 /* note; uses v3d, so needs active 3d window */
-static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int UNUSED(index))
+static void findnearestedge__doClosest(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int UNUSED(index))
 {
-       struct { ViewContext vc; float mval[2]; int dist; BMEdge *closest; } *data = userData;
-       float v1[2], v2[2];
+       struct { ViewContext vc; float mval_fl[2]; float dist; BMEdge *closest; } *data = userData;
        int distance;
-               
-       v1[0] = x0;
-       v1[1] = y0;
-       v2[0] = x1;
-       v2[1] = y1;
-               
-       distance = dist_to_line_segment_v2(data->mval, v1, v2);
+
+       distance = dist_to_line_segment_v2(data->mval_fl, screen_co_a, screen_co_b);
                
        if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) {
                distance += 5;
@@ -481,7 +475,7 @@ static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int
 
        if (distance < data->dist) {
                if (data->vc.rv3d->rflag & RV3D_CLIPPING) {
-                       float labda = labda_PdistVL2Dfl(data->mval, v1, v2);
+                       float labda = labda_PdistVL2Dfl(data->mval_fl, screen_co_a, screen_co_b);
                        float vec[3];
 
                        vec[0] = eed->v1->co[0] + labda * (eed->v2->co[0] - eed->v1->co[0]);
@@ -499,11 +493,11 @@ static void findnearestedge__doClosest(void *userData, BMEdge *eed, int x0, int
                }
        }
 }
-BMEdge *EDBM_edge_find_nearest(ViewContext *vc, int *dist)
+BMEdge *EDBM_edge_find_nearest(ViewContext *vc, float *r_dist)
 {
 
        if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
-               int distance;
+               float distance;
                unsigned int index;
                BMEdge *eed;
                
@@ -512,8 +506,8 @@ BMEdge *EDBM_edge_find_nearest(ViewContext *vc, int *dist)
                index = view3d_sample_backbuf_rect(vc, vc->mval, 50, bm_solidoffs, bm_wireoffs, &distance, 0, NULL, NULL);
                eed = BM_edge_at_index(vc->em->bm, index - 1);
                
-               if (eed && distance < *dist) {
-                       *dist = distance;
+               if (eed && distance < *r_dist) {
+                       *r_dist = distance;
                        return eed;
                }
                else {
@@ -521,36 +515,37 @@ BMEdge *EDBM_edge_find_nearest(ViewContext *vc, int *dist)
                }
        }
        else {
-               struct { ViewContext vc; float mval[2]; int dist; BMEdge *closest; } data;
+               struct { ViewContext vc; float mval_fl[2]; float dist; BMEdge *closest; } data;
 
                data.vc = *vc;
-               data.mval[0] = vc->mval[0];
-               data.mval[1] = vc->mval[1];
-               data.dist = *dist;
+               data.mval_fl[0] = vc->mval[0];
+               data.mval_fl[1] = vc->mval[1];
+               data.dist = *r_dist;
                data.closest = NULL;
                ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
                mesh_foreachScreenEdge(vc, findnearestedge__doClosest, &data, V3D_CLIP_TEST_REGION);
 
-               *dist = data.dist;
+               *r_dist = data.dist;
                return data.closest;
        }
 }
 
-static void findnearestface__getDistance(void *userData, BMFace *efa, int x, int y, int UNUSED(index))
+static void findnearestface__getDistance(void *userData, BMFace *efa, const float screen_co[2], int UNUSED(index))
 {
-       struct { short mval[2]; int dist; BMFace *toFace; } *data = userData;
+       struct { float mval_fl[2]; float dist; BMFace *toFace; } *data = userData;
 
        if (efa == data->toFace) {
-               int temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
+               const float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
 
-               if (temp < data->dist)
-                       data->dist = temp;
+               if (dist_test < data->dist) {
+                       data->dist = dist_test;
+               }
        }
 }
-static void findnearestface__doClosest(void *userData, BMFace *efa, int x, int y, int index)
+static void findnearestface__doClosest(void *userData, BMFace *efa, const float screen_co[2], int index)
 {
-       struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } *data = userData;
+       struct { float mval_fl[2], pass; float dist, lastIndex, closestIndex; BMFace *closest; } *data = userData;
 
        if (data->pass == 0) {
                if (index <= data->lastIndex)
@@ -562,17 +557,17 @@ static void findnearestface__doClosest(void *userData, BMFace *efa, int x, int y
        }
 
        if (data->dist > 3) {
-               int temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
+               const float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
 
-               if (temp < data->dist) {
-                       data->dist = temp;
+               if (dist_test < data->dist) {
+                       data->dist = dist_test;
                        data->closest = efa;
                        data->closestIndex = index;
                }
        }
 }
 
-BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
+BMFace *EDBM_face_find_nearest(ViewContext *vc, float *r_dist)
 {
 
        if (vc->v3d->drawtype > OB_WIRE && (vc->v3d->flag & V3D_ZBUF_SELECT)) {
@@ -585,17 +580,17 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
                efa = BM_face_at_index(vc->em->bm, index - 1);
                
                if (efa) {
-                       struct { short mval[2]; int dist; BMFace *toFace; } data;
+                       struct { float mval_fl[2]; float dist; BMFace *toFace; } data;
 
-                       data.mval[0] = vc->mval[0];
-                       data.mval[1] = vc->mval[1];
+                       data.mval_fl[0] = vc->mval[0];
+                       data.mval_fl[1] = vc->mval[1];
                        data.dist = 0x7FFF;     /* largest short */
                        data.toFace = efa;
 
                        mesh_foreachScreenFace(vc, findnearestface__getDistance, &data);
 
-                       if (vc->em->selectmode == SCE_SELECT_FACE || data.dist < *dist) {   /* only faces, no dist check */
-                               *dist = data.dist;
+                       if ((vc->em->selectmode == SCE_SELECT_FACE) || (data.dist < *r_dist)) {  /* only faces, no dist check */
+                               *r_dist = data.dist;
                                return efa;
                        }
                }
@@ -603,7 +598,7 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
                return NULL;
        }
        else {
-               struct { short mval[2], pass; int dist, lastIndex, closestIndex; BMFace *closest; } data;
+               struct { float mval_fl[2], pass; float dist, lastIndex, closestIndex; BMFace *closest; } data;
                static int lastSelectedIndex = 0;
                static BMFace *lastSelected = NULL;
 
@@ -613,9 +608,9 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
                }
 
                data.lastIndex = lastSelectedIndex;
-               data.mval[0] = vc->mval[0];
-               data.mval[1] = vc->mval[1];
-               data.dist = *dist;
+               data.mval_fl[0] = vc->mval[0];
+               data.mval_fl[1] = vc->mval[1];
+               data.dist = *r_dist;
                data.closest = NULL;
                data.closestIndex = 0;
                ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
@@ -623,13 +618,13 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
                data.pass = 0;
                mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
 
-               if (data.dist > 3) {
+               if (data.dist > 3.0f) {
                        data.pass = 1;
                        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
                        mesh_foreachScreenFace(vc, findnearestface__doClosest, &data);
                }
 
-               *dist = data.dist;
+               *r_dist = data.dist;
                lastSelected = data.closest;
                lastSelectedIndex = data.closestIndex;
 
@@ -645,7 +640,7 @@ BMFace *EDBM_face_find_nearest(ViewContext *vc, int *dist)
 static int unified_findnearest(ViewContext *vc, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
 {
        BMEditMesh *em = vc->em;
-       int dist = 75;
+       float dist = 75.0f;
        
        *r_eve = NULL;
        *r_eed = NULL;
@@ -1004,7 +999,7 @@ static void mouse_mesh_loop(bContext *C, int mval[2], short extend, short ring)
        BMEditMesh *em;
        BMEdge *eed;
        int select = TRUE;
-       int dist = 50;
+       float dist = 50.0f;
        float mvalf[2];
 
        em_setup_viewcontext(C, &vc);
@@ -1392,7 +1387,7 @@ static int mouse_mesh_shortest_path(bContext *C, int mval[2])
        ViewContext vc;
        BMEditMesh *em;
        BMEdge *e;
-       int dist = 50;
+       float dist = 75.0f;
        
        em_setup_viewcontext(C, &vc);
        vc.mval[0] = mval[0];
index f265113..b5521a5 100644 (file)
@@ -1192,7 +1192,7 @@ int ED_mesh_pick_face(bContext *C, Mesh *me, const int mval[2], unsigned int *in
                /* sample rect to increase chances of selecting, so that when clicking
                 * on an edge in the backbuf, we can still select a face */
 
-               int dummy_dist;
+               float dummy_dist;
                *index = view3d_sample_backbuf_rect(&vc, mval, size, 1, me->totpoly + 1, &dummy_dist, 0, NULL, NULL);
        }
        else {
@@ -1277,7 +1277,7 @@ int ED_mesh_pick_vert(bContext *C, Mesh *me, const int mval[2], unsigned int *in
                /* sample rect to increase chances of selecting, so that when clicking
                 * on an face in the backbuf, we can still select a vert */
 
-               int dummy_dist;
+               float dummy_dist;
                *index = view3d_sample_backbuf_rect(&vc, mval, size, 1, me->totvert + 1, &dummy_dist, 0, NULL, NULL);
        }
        else {
index 1f7be0b..aa9e4d8 100644 (file)
@@ -302,16 +302,16 @@ void LATTICE_OT_make_regular(wmOperatorType *ot)
 
 /****************************** Mouse Selection *************************/
 
-static void findnearestLattvert__doClosest(void *userData, BPoint *bp, int x, int y)
+static void findnearestLattvert__doClosest(void *userData, BPoint *bp, const float screen_co[2])
 {
-       struct { BPoint *bp; short dist, select; int mval[2]; } *data = userData;
-       float temp = abs(data->mval[0] - x) + abs(data->mval[1] - y);
+       struct { BPoint *bp; float dist; int select; float mval_fl[2]; } *data = userData;
+       float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
        
-       if ((bp->f1 & SELECT) == data->select)
-               temp += 5;
+       if ((bp->f1 & SELECT) && data->select)
+               dist_test += 5.0f;
 
-       if (temp < data->dist) {
-               data->dist = temp;
+       if (dist_test < data->dist) {
+               data->dist = dist_test;
 
                data->bp = bp;
        }
@@ -322,12 +322,12 @@ static BPoint *findnearestLattvert(ViewContext *vc, const int mval[2], int sel)
        /* sel==1: selected gets a disadvantage */
        /* in nurb and bezt or bp the nearest is written */
        /* return 0 1 2: handlepunt */
-       struct { BPoint *bp; short dist, select; int mval[2]; } data = {NULL};
+       struct { BPoint *bp; float dist; int select; float mval_fl[2]; } data = {NULL};
 
        data.dist = 100;
        data.select = sel;
-       data.mval[0] = mval[0];
-       data.mval[1] = mval[1];
+       data.mval_fl[0] = mval[0];
+       data.mval_fl[1] = mval[1];
 
        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
        lattice_foreachScreenVert(vc, findnearestLattvert__doClosest, &data);
@@ -341,7 +341,7 @@ int mouse_lattice(bContext *C, const int mval[2], int extend, int deselect, int
        BPoint *bp = NULL;
 
        view3d_set_viewcontext(C, &vc);
-       bp = findnearestLattvert(&vc, mval, 1);
+       bp = findnearestLattvert(&vc, mval, TRUE);
 
        if (bp) {
                if (extend) {
index 1b008c2..fb308db 100644 (file)
@@ -119,22 +119,22 @@ typedef enum eWireDrawMode {
 
 /* user data structures for derived mesh callbacks */
 typedef struct foreachScreenVert_userData {
-       void (*func)(void *userData, BMVert *eve, int x, int y, int index);
+       void (*func)(void *userData, BMVert *eve, const float screen_co_b[2], int index);
        void *userData;
        ViewContext vc;
        eV3DClipTest clipVerts;
 } foreachScreenVert_userData;
 
 typedef struct foreachScreenEdge_userData {
-       void (*func)(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index);
+       void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index);
        void *userData;
        ViewContext vc;
-       rcti win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
+       rctf win_rect; /* copy of: vc.ar->winx/winy, use for faster tests, minx/y will always be 0 */
        eV3DClipTest clipVerts;
 } foreachScreenEdge_userData;
 
 typedef struct foreachScreenFace_userData {
-       void (*func)(void *userData, BMFace *efa, int x, int y, int index);
+       void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index);
        void *userData;
        ViewContext vc;
 } foreachScreenFace_userData;
@@ -1870,7 +1870,7 @@ static void lattice_draw_verts(Lattice *lt, DispList *dl, short sel)
        bglEnd();
 }
 
-void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, int x, int y), void *userData)
+void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPoint *bp, const float screen_co[2]), void *userData)
 {
        Object *obedit = vc->obedit;
        Lattice *lt = obedit->data;
@@ -1883,11 +1883,11 @@ void lattice_foreachScreenVert(ViewContext *vc, void (*func)(void *userData, BPo
 
        for (i = 0; i < N; i++, bp++, co += 3) {
                if (bp->hide == 0) {
-                       int screen_co[2];
-                       if (ED_view3d_project_int_object(vc->ar, dl ? co : bp->vec, screen_co,
-                                                        V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       float screen_co[2];
+                       if (ED_view3d_project_float_object(vc->ar, dl ? co : bp->vec, screen_co,
+                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                        {
-                               func(userData, bp, screen_co[0], screen_co[1]);
+                               func(userData, bp, screen_co);
                        }
                }
        }
@@ -1993,19 +1993,19 @@ static void mesh_foreachScreenVert__mapFunc(void *userData, int index, const flo
                const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_OFF) ?
                            V3D_PROJ_TEST_NOP :
                            V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN;
-               int screen_co[2];
+               float screen_co[2];
 
-               if (ED_view3d_project_int_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
+               if (ED_view3d_project_float_object(data->vc.ar, co, screen_co, flag) != V3D_PROJ_RET_OK) {
                        return;
                }
 
-               data->func(data->userData, eve, screen_co[0], screen_co[1], index);
+               data->func(data->userData, eve, screen_co, index);
        }
 }
 
 void mesh_foreachScreenVert(
         ViewContext *vc,
-        void (*func)(void *userData, BMVert *eve, int x, int y, int index),
+        void (*func)(void *userData, BMVert *eve, const float screen_co[2], int index),
         void *userData, eV3DClipTest clipVerts)
 {
        foreachScreenVert_userData data;
@@ -2060,17 +2060,17 @@ static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const flo
        BMEdge *eed = EDBM_edge_at_index(data->vc.em, index);
 
        if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
-               int screen_co_a[2];
-               int screen_co_b[2];
+               float screen_co_a[2];
+               float screen_co_b[2];
 
                const eV3DProjTest flag = (data->clipVerts == V3D_CLIP_TEST_RV3D_CLIPPING) ?
                            V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN :
                            V3D_PROJ_TEST_NOP;
 
-               if (ED_view3d_project_int_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
+               if (ED_view3d_project_float_object(data->vc.ar, v0co, screen_co_a, flag) != V3D_PROJ_RET_OK) {
                        return;
                }
-               if (ED_view3d_project_int_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
+               if (ED_view3d_project_float_object(data->vc.ar, v1co, screen_co_b, flag) != V3D_PROJ_RET_OK) {
                        return;
                }
 
@@ -2079,21 +2079,19 @@ static void mesh_foreachScreenEdge__mapFunc(void *userData, int index, const flo
                }
                else {
                        if (data->clipVerts == V3D_CLIP_TEST_REGION) {
-                               if (!BLI_rcti_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
+                               if (!BLI_rctf_isect_segment(&data->win_rect, screen_co_a, screen_co_b)) {
                                        return;
                                }
                        }
                }
 
-               data->func(data->userData, eed,
-                          screen_co_a[0], screen_co_a[1],
-                          screen_co_b[0], screen_co_b[1], index);
+               data->func(data->userData, eed, screen_co_a, screen_co_b, index);
        }
 }
 
 void mesh_foreachScreenEdge(
         ViewContext *vc,
-        void (*func)(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index),
+        void (*func)(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index),
         void *userData, eV3DClipTest clipVerts)
 {
        foreachScreenEdge_userData data;
@@ -2126,18 +2124,18 @@ static void mesh_foreachScreenFace__mapFunc(void *userData, int index, const flo
        BMFace *efa = EDBM_face_at_index(data->vc.em, index);
 
        if (efa && !BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
-               int screen_co[2];
-               if (ED_view3d_project_int_object(data->vc.ar, cent, screen_co,
+               float screen_co[2];
+               if (ED_view3d_project_float_object(data->vc.ar, cent, screen_co,
                                                   V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                {
-                       data->func(data->userData, efa, screen_co[0], screen_co[1], index);
+                       data->func(data->userData, efa, screen_co, index);
                }
        }
 }
 
 void mesh_foreachScreenFace(
         ViewContext *vc,
-        void (*func)(void *userData, BMFace *efa, int x, int y, int index),
+        void (*func)(void *userData, BMFace *efa, const float screen_co_b[2], int index),
         void *userData)
 {
        foreachScreenFace_userData data;
@@ -2158,7 +2156,7 @@ void mesh_foreachScreenFace(
 
 void nurbs_foreachScreenVert(
         ViewContext *vc,
-        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, int x, int y),
+        void (*func)(void *userData, Nurb *nu, BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co_b[2]),
         void *userData)
 {
        Curve *cu = vc->obedit->data;
@@ -2174,30 +2172,30 @@ void nurbs_foreachScreenVert(
                                BezTriple *bezt = &nu->bezt[i];
 
                                if (bezt->hide == 0) {
-                                       int screen_co[2];
+                                       float screen_co[2];
                                        
                                        if (cu->drawflag & CU_HIDE_HANDLES) {
-                                               if (ED_view3d_project_int_object(vc->ar, bezt->vec[1], screen_co,
-                                                                                V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                                                {
-                                                       func(userData, nu, NULL, bezt, 1, screen_co[0], screen_co[1]);
+                                                       func(userData, nu, NULL, bezt, 1, screen_co);
                                                }
                                        }
                                        else {
-                                               if (ED_view3d_project_int_object(vc->ar, bezt->vec[0], screen_co,
-                                                                                V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[0], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                                                {
-                                                       func(userData, nu, NULL, bezt, 0, screen_co[0], screen_co[1]);
+                                                       func(userData, nu, NULL, bezt, 0, screen_co);
                                                }
-                                               if (ED_view3d_project_int_object(vc->ar, bezt->vec[1], screen_co,
-                                                                                V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[1], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                                                {
-                                                       func(userData, nu, NULL, bezt, 1, screen_co[0], screen_co[1]);
+                                                       func(userData, nu, NULL, bezt, 1, screen_co);
                                                }
-                                               if (ED_view3d_project_int_object(vc->ar, bezt->vec[2], screen_co,
-                                                                                V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                               if (ED_view3d_project_float_object(vc->ar, bezt->vec[2], screen_co,
+                                                                                  V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                                                {
-                                                       func(userData, nu, NULL, bezt, 2, screen_co[0], screen_co[1]);
+                                                       func(userData, nu, NULL, bezt, 2, screen_co);
                                                }
                                        }
                                }
@@ -2208,11 +2206,11 @@ void nurbs_foreachScreenVert(
                                BPoint *bp = &nu->bp[i];
 
                                if (bp->hide == 0) {
-                                       int screen_co[2];
-                                       if (ED_view3d_project_int_object(vc->ar, bp->vec, screen_co,
-                                                                        V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
+                                       float screen_co[2];
+                                       if (ED_view3d_project_float_object(vc->ar, bp->vec, screen_co,
+                                                                          V3D_PROJ_RET_CLIP_BB | V3D_PROJ_RET_CLIP_WIN) == V3D_PROJ_RET_OK)
                                        {
-                                               func(userData, nu, bp, NULL, -1, screen_co[0], screen_co[1]);
+                                               func(userData, nu, bp, NULL, -1, screen_co);
                                        }
                                }
                        }
@@ -2223,18 +2221,18 @@ void nurbs_foreachScreenVert(
 /* ED_view3d_init_mats_rv3d must be called first */
 void mball_foreachScreenElem(
         struct ViewContext *vc,
-        void (*func)(void *userData, struct MetaElem *ml, int x, int y),
+        void (*func)(void *userData, struct MetaElem *ml, const float screen_co_b[2]),
         void *userData)
 {
        MetaBall *mb = (MetaBall *)vc->obedit->data;
        MetaElem *ml;
 
        for (ml = mb->editelems->first; ml; ml = ml->next) {
-               int screen_co[2];
-               if (ED_view3d_project_int_object(vc->ar, &ml->x, screen_co,
-                                                V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+               float screen_co[2];
+               if (ED_view3d_project_float_object(vc->ar, &ml->x, screen_co,
+                                                  V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                {
-                       func(userData, ml, screen_co[0], screen_co[1]);
+                       func(userData, ml, screen_co);
                }
        }
 }
@@ -2242,7 +2240,7 @@ void mball_foreachScreenElem(
 /* ED_view3d_init_mats_rv3d must be called first */
 void armature_foreachScreenBone(
         struct ViewContext *vc,
-        void (*func)(void *userData, struct EditBone *ebone, int x0, int y0, int x1, int y1),
+        void (*func)(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2]),
         void *userData)
 {
        bArmature *arm = vc->obedit->data;
@@ -2250,12 +2248,12 @@ void armature_foreachScreenBone(
 
        for (ebone = arm->edbo->first; ebone; ebone = ebone->next) {
                if (EBONE_VISIBLE(arm, ebone)) {
-                       int screen_co_a[2], screen_co_b[2];
+                       float screen_co_a[2], screen_co_b[2];
                        int points_proj_tot = 0;
 
                        /* project head location to screenspace */
-                       if (ED_view3d_project_int_object(vc->ar, ebone->head, screen_co_a,
-                                                        V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       if (ED_view3d_project_float_object(vc->ar, ebone->head, screen_co_a,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                        {
                                points_proj_tot++;
                        }
@@ -2265,8 +2263,8 @@ void armature_foreachScreenBone(
                        }
 
                        /* project tail location to screenspace */
-                       if (ED_view3d_project_int_object(vc->ar, ebone->tail, screen_co_b,
-                                                        V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       if (ED_view3d_project_float_object(vc->ar, ebone->tail, screen_co_b,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                        {
                                points_proj_tot++;
                        }
@@ -2276,9 +2274,7 @@ void armature_foreachScreenBone(
                        }
 
                        if (points_proj_tot) {  /* at least one point's projection worked */
-                               func(userData, ebone,
-                                    screen_co_a[0], screen_co_a[1],
-                                    screen_co_b[0], screen_co_b[1]);
+                               func(userData, ebone, screen_co_a, screen_co_b);
                        }
                }
        }
@@ -2288,7 +2284,7 @@ void armature_foreachScreenBone(
 /* almost _exact_ copy of #armature_foreachScreenBone */
 void pose_foreachScreenBone(
         struct ViewContext *vc,
-        void (*func)(void *userData, struct bPoseChannel *pchan, int x0, int y0, int x1, int y1),
+        void (*func)(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2]),
         void *userData)
 {
        bArmature *arm = vc->obact->data;
@@ -2297,12 +2293,12 @@ void pose_foreachScreenBone(
 
        for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {
                if (PBONE_VISIBLE(arm, pchan->bone)) {
-                       int screen_co_a[2], screen_co_b[2];
+                       float screen_co_a[2], screen_co_b[2];
                        int points_proj_tot = 0;
 
                        /* project head location to screenspace */
-                       if (ED_view3d_project_int_object(vc->ar, pchan->pose_head, screen_co_a,
-                                                        V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_head, screen_co_a,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                        {
                                points_proj_tot++;
                        }
@@ -2312,8 +2308,8 @@ void pose_foreachScreenBone(
                        }
 
                        /* project tail location to screenspace */
-                       if (ED_view3d_project_int_object(vc->ar, pchan->pose_tail, screen_co_b,
-                                                        V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
+                       if (ED_view3d_project_float_object(vc->ar, pchan->pose_tail, screen_co_b,
+                                                          V3D_PROJ_TEST_CLIP_BB | V3D_PROJ_TEST_CLIP_WIN) == V3D_PROJ_RET_OK)
                        {
                                points_proj_tot++;
                        }
@@ -2323,9 +2319,7 @@ void pose_foreachScreenBone(
                        }
 
                        if (points_proj_tot) {  /* at least one point's projection worked */
-                               func(userData, pchan,
-                                    screen_co_a[0], screen_co_a[1],
-                                    screen_co_b[0], screen_co_b[1]);
+                               func(userData, pchan, screen_co_a, screen_co_b);
                        }
                }
        }
index c5246b1..88375c4 100644 (file)
@@ -1462,7 +1462,7 @@ ImBuf *view3d_read_backbuf(ViewContext *vc, short xmin, short ymin, short xmax,
 
 /* smart function to sample a rect spiralling outside, nice for backbuf selection */
 unsigned int view3d_sample_backbuf_rect(ViewContext *vc, const int mval[2], int size,
-                                        unsigned int min, unsigned int max, int *dist, short strict,
+                                        unsigned int min, unsigned int max, float *r_dist, short strict,
                                         void *handle, unsigned int (*indextest)(void *handle, unsigned int index))
 {
        struct ImBuf *buf;
@@ -1500,13 +1500,13 @@ unsigned int view3d_sample_backbuf_rect(ViewContext *vc, const int mval[2], int
                                        if (strict) {
                                                indexok =  indextest(handle, *tbuf - min + 1);
                                                if (indexok) {
-                                                       *dist = (short) sqrt( (float)distance);
+                                                       *r_dist = sqrtf((float)distance);
                                                        index = *tbuf - min + 1;
                                                        goto exit; 
                                                }
                                        }
                                        else {
-                                               *dist = (short) sqrt( (float)distance);  /* XXX, this distance is wrong - */
+                                               *r_dist = sqrtf((float)distance);  /* XXX, this distance is wrong - */
                                                index = *tbuf - min + 1;  /* messy yah, but indices start at 1 */
                                                goto exit;
                                        }
index 5f0bb18..d40dc5c 100644 (file)
@@ -258,6 +258,8 @@ static void edbm_backbuf_check_and_select_tfaces(Mesh *me, int select)
 typedef struct LassoSelectUserData {
        ViewContext *vc;
        const rcti *rect;
+       const rctf *rect_fl;
+       rctf       _rect_fl;
        const int (*mcords)[2];
        int moves;
        int select;
@@ -273,7 +275,11 @@ static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data,
                                              const int moves, const int select)
 {
        r_data->vc = vc;
+
        r_data->rect = rect;
+       r_data->rect_fl = &r_data->_rect_fl;
+       BLI_rctf_rcti_copy(&r_data->_rect_fl, rect);
+
        r_data->mcords = mcords;
        r_data->moves = moves;
        r_data->select = select;
@@ -314,29 +320,29 @@ static int view3d_selectable_data(bContext *C)
 
 
 /* helper also for borderselect */
-static int edge_fully_inside_rect(const rcti *rect, int x1, int y1, int x2, int y2)
+static int edge_fully_inside_rect(const rctf *rect, const float v1[2], const float v2[2])
 {
-       return BLI_rcti_isect_pt(rect, x1, y1) && BLI_rcti_isect_pt(rect, x2, y2);
+       return BLI_rctf_isect_pt_v(rect, v1) && BLI_rctf_isect_pt_v(rect, v2);
 }
 
-static int edge_inside_rect(const rcti *rect, int x1, int y1, int x2, int y2)
+static int edge_inside_rect(const rctf *rect, const float v1[2], const float v2[2])
 {
        int d1, d2, d3, d4;
        
        /* check points in rect */
-       if (edge_fully_inside_rect(rect, x1, y1, x2, y2)) return 1;
+       if (edge_fully_inside_rect(rect, v1, v2)) return 1;
        
        /* check points completely out rect */
-       if (x1 < rect->xmin && x2 < rect->xmin) return 0;
-       if (x1 > rect->xmax && x2 > rect->xmax) return 0;
-       if (y1 < rect->ymin && y2 < rect->ymin) return 0;
-       if (y1 > rect->ymax && y2 > rect->ymax) return 0;
+       if (v1[0] < rect->xmin && v2[0] < rect->xmin) return 0;
+       if (v1[0] > rect->xmax && v2[0] > rect->xmax) return 0;
+       if (v1[1] < rect->ymin && v2[1] < rect->ymin) return 0;
+       if (v1[1] > rect->ymax && v2[1] > rect->ymax) return 0;
        
        /* simple check lines intersecting. */
-       d1 = (y1 - y2) * (x1 - rect->xmin) + (x2 - x1) * (y1 - rect->ymin);
-       d2 = (y1 - y2) * (x1 - rect->xmin) + (x2 - x1) * (y1 - rect->ymax);
-       d3 = (y1 - y2) * (x1 - rect->xmax) + (x2 - x1) * (y1 - rect->ymax);
-       d4 = (y1 - y2) * (x1 - rect->xmax) + (x2 - x1) * (y1 - rect->ymin);
+       d1 = (v1[1] - v2[1]) * (v1[0] - rect->xmin) + (v2[0] - v1[0]) * (v1[1] - rect->ymin);
+       d2 = (v1[1] - v2[1]) * (v1[0] - rect->xmin) + (v2[0] - v1[0]) * (v1[1] - rect->ymax);
+       d3 = (v1[1] - v2[1]) * (v1[0] - rect->xmax) + (v2[0] - v1[0]) * (v1[1] - rect->ymax);
+       d4 = (v1[1] - v2[1]) * (v1[0] - rect->xmax) + (v2[0] - v1[0]) * (v1[1] - rect->ymin);
        
        if (d1 < 0 && d2 < 0 && d3 < 0 && d4 < 0) return 0;
        if (d1 > 0 && d2 > 0 && d3 > 0 && d4 > 0) return 0;
@@ -344,7 +350,7 @@ static int edge_inside_rect(const rcti *rect, int x1, int y1, int x2, int y2)
        return 1;
 }
 
-static void do_lasso_select_pose__doSelectBone(void *userData, struct bPoseChannel *pchan, int x0, int y0, int x1, int y1)
+static void do_lasso_select_pose__doSelectBone(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2])
 {
        LassoSelectUserData *data = userData;
        bArmature *arm = data->vc->obact->data;
@@ -353,6 +359,11 @@ static void do_lasso_select_pose__doSelectBone(void *userData, struct bPoseChann
                int is_point_done = FALSE;
                int points_proj_tot = 0;
 
+               const int x0 = screen_co_a[0];
+               const int y0 = screen_co_a[1];
+               const int x1 = screen_co_b[0];
+               const int y1 = screen_co_b[1];
+
                /* project head location to screenspace */
                if (x0 != IS_CLIPPED) {
                        points_proj_tot++;
@@ -394,12 +405,12 @@ static void do_lasso_select_pose(ViewContext *vc, Object *ob, const int mcords[]
                return;
        }
 
+       BLI_lasso_boundbox(&rect, mcords, moves);
+
        view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        ED_view3d_init_mats_rv3d(vc->obact, vc->rv3d);
 
-       BLI_lasso_boundbox(&rect, mcords, moves);
-
        pose_foreachScreenBone(vc, do_lasso_select_pose__doSelectBone, &data);
 
        if (data.is_change) {
@@ -445,23 +456,28 @@ static void do_lasso_select_objects(ViewContext *vc, const int mcords[][2], cons
        }
 }
 
-static void do_lasso_select_mesh__doSelectVert(void *userData, BMVert *eve, int x, int y, int UNUSED(index))
+static void do_lasso_select_mesh__doSelectVert(void *userData, BMVert *eve, const float screen_co[2], int UNUSED(index))
 {
        LassoSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y) &&
-           BLI_lasso_is_point_inside(data->mcords, data->moves, x, y, IS_CLIPPED))
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+           BLI_lasso_is_point_inside(data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED))
        {
                BM_vert_select_set(data->vc->em->bm, eve, data->select);
        }
 }
-static void do_lasso_select_mesh__doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index)
+static void do_lasso_select_mesh__doSelectEdge(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index)
 {
        LassoSelectUserData *data = userData;
 
        if (EDBM_backbuf_check(bm_solidoffs + index)) {
+               const int x0 = screen_co_a[0];
+               const int y0 = screen_co_a[1];
+               const int x1 = screen_co_b[0];
+               const int y1 = screen_co_b[1];
+
                if (data->pass == 0) {
-                       if (edge_fully_inside_rect(data->rect, x0, y0, x1, y1)  &&
+                       if (edge_fully_inside_rect(data->rect_fl, screen_co_a, screen_co_b)  &&
                            BLI_lasso_is_point_inside(data->mcords, data->moves, x0, y0, IS_CLIPPED) &&
                            BLI_lasso_is_point_inside(data->mcords, data->moves, x1, y1, IS_CLIPPED))
                        {
@@ -476,12 +492,12 @@ static void do_lasso_select_mesh__doSelectEdge(void *userData, BMEdge *eed, int
                }
        }
 }
-static void do_lasso_select_mesh__doSelectFace(void *userData, BMFace *efa, int x, int y, int UNUSED(index))
+static void do_lasso_select_mesh__doSelectFace(void *userData, BMFace *efa, const float screen_co[2], int UNUSED(index))
 {
        LassoSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y) &&
-           BLI_lasso_is_point_inside(data->mcords, data->moves, x, y, IS_CLIPPED))
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+           BLI_lasso_is_point_inside(data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED))
        {
                BM_face_select_set(data->vc->em->bm, efa, data->select);
        }
@@ -494,11 +510,11 @@ static void do_lasso_select_mesh(ViewContext *vc, const int mcords[][2], short m
        rcti rect;
        int bbsel;
        
-       BLI_lasso_boundbox(&rect, mcords, moves);
-       
        /* set editmesh */
        vc->em = BMEdit_FromObject(vc->obedit);
 
+       BLI_lasso_boundbox(&rect, mcords, moves);
+
        view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        if (extend == 0 && select)
@@ -542,13 +558,13 @@ static void do_lasso_select_mesh(ViewContext *vc, const int mcords[][2], short m
        EDBM_selectmode_flush(vc->em);
 }
 
-static void do_lasso_select_curve__doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
+static void do_lasso_select_curve__doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co[2])
 {
        LassoSelectUserData *data = userData;
        Object *obedit = data->vc->obedit;
        Curve *cu = (Curve *)obedit->data;
 
-       if (BLI_lasso_is_point_inside(data->mcords, data->moves, x, y, IS_CLIPPED)) {
+       if (BLI_lasso_is_point_inside(data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)) {
                if (bp) {
                        bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
                        if (bp == cu->lastsel && !(bp->f1 & SELECT)) cu->lastsel = NULL;
@@ -578,8 +594,11 @@ static void do_lasso_select_curve__doSelect(void *userData, Nurb *UNUSED(nu), BP
 static void do_lasso_select_curve(ViewContext *vc, const int mcords[][2], short moves, short extend, short select)
 {
        LassoSelectUserData data;
+       rcti rect;
+
+       BLI_lasso_boundbox(&rect, mcords, moves);
 
-       view3d_userdata_lassoselect_init(&data, vc, NULL, mcords, moves, select);
+       view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        if (extend == 0 && select)
                CU_deselect_all(vc->obedit);
@@ -588,19 +607,23 @@ static void do_lasso_select_curve(ViewContext *vc, const int mcords[][2], short
        nurbs_foreachScreenVert(vc, do_lasso_select_curve__doSelect, &data);
 }
 
-static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, int x, int y)
+static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, const float screen_co[2])
 {
        LassoSelectUserData *data = userData;
 
-       if (BLI_lasso_is_point_inside(data->mcords, data->moves, x, y, IS_CLIPPED)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+           BLI_lasso_is_point_inside(data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)) {
                bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
        }
 }
 static void do_lasso_select_lattice(ViewContext *vc, const int mcords[][2], short moves, short extend, short select)
 {
        LassoSelectUserData data;
+       rcti rect;
 
-       view3d_userdata_lassoselect_init(&data, vc, NULL, mcords, moves, select);
+       BLI_lasso_boundbox(&rect, mcords, moves);
+
+       view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        if (extend == 0 && select)
                ED_setflagsLatt(vc->obedit, 0);
@@ -609,7 +632,7 @@ static void do_lasso_select_lattice(ViewContext *vc, const int mcords[][2], shor
        lattice_foreachScreenVert(vc, do_lasso_select_lattice__doSelect, &data);
 }
 
-static void do_lasso_select_armature__doSelectBone(void *userData, struct EditBone *ebone, int x0, int y0, int x1, int y1)
+static void do_lasso_select_armature__doSelectBone(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2])
 {
        LassoSelectUserData *data = userData;
        bArmature *arm = data->vc->obedit->data;
@@ -618,6 +641,11 @@ static void do_lasso_select_armature__doSelectBone(void *userData, struct EditBo
                int is_point_done = FALSE;
                int points_proj_tot = 0;
 
+               const int x0 = screen_co_a[0];
+               const int y0 = screen_co_a[1];
+               const int x1 = screen_co_b[0];
+               const int y1 = screen_co_b[1];
+
                /* project head location to screenspace */
                if (x0 != IS_CLIPPED) {
                        points_proj_tot++;
@@ -660,12 +688,12 @@ static void do_lasso_select_armature(ViewContext *vc, const int mcords[][2], sho
        LassoSelectUserData data;
        rcti rect;
 
+       BLI_lasso_boundbox(&rect, mcords, moves);
+
        view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-       BLI_lasso_boundbox(&rect, mcords, moves);
-
        if (extend == 0 && select)
                ED_armature_deselect_all_visible(vc->obedit);
 
@@ -679,12 +707,12 @@ static void do_lasso_select_armature(ViewContext *vc, const int mcords[][2], sho
        }
 }
 
-static void do_lasso_select_mball__doSelectElem(void *userData, struct MetaElem *ml, int x, int y)
+static void do_lasso_select_mball__doSelectElem(void *userData, struct MetaElem *ml, const float screen_co[2])
 {
        LassoSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y) &&
-           BLI_lasso_is_point_inside(data->mcords, data->moves, x, y, INT_MAX)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
+           BLI_lasso_is_point_inside(data->mcords, data->moves, screen_co[0], screen_co[1], INT_MAX)) {
                if (data->select) ml->flag |=  SELECT;
                else              ml->flag &= ~SELECT;
                data->is_change = TRUE;
@@ -700,12 +728,12 @@ static void do_lasso_select_meta(ViewContext *vc, const int mcords[][2], short m
        if (extend == 0 && select)
                 BKE_mball_deselect_all(mb);
 
+       BLI_lasso_boundbox(&rect, mcords, moves);
+
        view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, select);
 
        ED_view3d_init_mats_rv3d(vc->obedit, vc->rv3d);
 
-       BLI_lasso_boundbox(&rect, mcords, moves);
-
        mball_foreachScreenElem(vc, do_lasso_select_mball__doSelectElem, &data);
 }
 
@@ -1583,6 +1611,8 @@ static int mouse_select(bContext *C, const int mval[2], short extend, short dese
 typedef struct BoxSelectUserData {
        ViewContext *vc;
        const rcti *rect;
+       const rctf *rect_fl;
+       rctf       _rect_fl;
        int select;
 
        /* runtime */
@@ -1595,7 +1625,11 @@ static void view3d_userdata_boxselect_init(BoxSelectUserData *r_data,
                                            ViewContext *vc, const rcti *rect, const int select)
 {
        r_data->vc = vc;
+
        r_data->rect = rect;
+       r_data->rect_fl = &r_data->_rect_fl;
+       BLI_rctf_rcti_copy(&r_data->_rect_fl, rect);
+
        r_data->select = select;
 
        /* runtime */
@@ -1604,23 +1638,20 @@ static void view3d_userdata_boxselect_init(BoxSelectUserData *r_data,
        r_data->is_change = FALSE;
 }
 
-int edge_inside_circle(int centx, int centy, int radius, int x1, int y1, int x2, int y2)
+int edge_inside_circle(const float cent[2], float radius, const float screen_co_a[2], const float screen_co_b[2])
 {
        int radius_squared = radius * radius;
 
        /* check points in circle itself */
-       if ((x1 - centx) * (x1 - centx) + (y1 - centy) * (y1 - centy) <= radius_squared) {
+       if (len_squared_v2v2(cent, screen_co_a) <= radius_squared) {
                return TRUE;
        }
-       else if ((x2 - centx) * (x2 - centx) + (y2 - centy) * (y2 - centy) <= radius_squared) {
+       if (len_squared_v2v2(cent, screen_co_b) <= radius_squared) {
                return TRUE;
        }
        else {
-               const float cent[2] = {centx, centy};
-               const float v1[2] = {x1, y1};
-               const float v2[2] = {x2, y2};
                /* pointdistline */
-               if (dist_squared_to_line_segment_v2(cent, v1, v2) < (float)radius_squared) {
+               if (dist_squared_to_line_segment_v2(cent, screen_co_a, screen_co_b) < (float)radius_squared) {
                        return TRUE;
                }
        }
@@ -1628,13 +1659,13 @@ int edge_inside_circle(int centx, int centy, int radius, int x1, int y1, int x2,
        return FALSE;
 }
 
-static void do_nurbs_box_select__doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
+static void do_nurbs_box_select__doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co[2])
 {
        BoxSelectUserData *data = userData;
        Object *obedit = data->vc->obedit;
        Curve *cu = (Curve *)obedit->data;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co)) {
                if (bp) {
                        bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
                        if (bp == cu->lastsel && !(bp->f1 & SELECT)) cu->lastsel = NULL;
@@ -1675,11 +1706,11 @@ static int do_nurbs_box_select(ViewContext *vc, rcti *rect, int select, int exte
        return OPERATOR_FINISHED;
 }
 
-static void do_lattice_box_select__doSelect(void *userData, BPoint *bp, int x, int y)
+static void do_lattice_box_select__doSelect(void *userData, BPoint *bp, const float screen_co[2])
 {
        BoxSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co)) {
                bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
        }
 }
@@ -1698,37 +1729,37 @@ static int do_lattice_box_select(ViewContext *vc, rcti *rect, int select, int ex
        return OPERATOR_FINISHED;
 }
 
-static void do_mesh_box_select__doSelectVert(void *userData, BMVert *eve, int x, int y, int UNUSED(index))
+static void do_mesh_box_select__doSelectVert(void *userData, BMVert *eve, const float screen_co[2], int UNUSED(index))
 {
        BoxSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co)) {
                BM_vert_select_set(data->vc->em->bm, eve, data->select);
        }
 }
-static void do_mesh_box_select__doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int index)
+static void do_mesh_box_select__doSelectEdge(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int index)
 {
        BoxSelectUserData *data = userData;
 
        if (EDBM_backbuf_check(bm_solidoffs + index)) {
                if (data->pass == 0) {
-                       if (edge_fully_inside_rect(data->rect, x0, y0, x1, y1)) {
+                       if (edge_fully_inside_rect(data->rect_fl, screen_co_a, screen_co_b)) {
                                BM_edge_select_set(data->vc->em->bm, eed, data->select);
                                data->is_done = TRUE;
                        }
                }
                else {
-                       if (edge_inside_rect(data->rect, x0, y0, x1, y1)) {
+                       if (edge_inside_rect(data->rect_fl, screen_co_a, screen_co_b)) {
                                BM_edge_select_set(data->vc->em->bm, eed, data->select);
                        }
                }
        }
 }
-static void do_mesh_box_select__doSelectFace(void *userData, BMFace *efa, int x, int y, int UNUSED(index))
+static void do_mesh_box_select__doSelectFace(void *userData, BMFace *efa, const float screen_co[2], int UNUSED(index))
 {
        BoxSelectUserData *data = userData;
 
-       if (BLI_rcti_isect_pt(data->rect, x, y)) {
+       if (BLI_rctf_isect_pt_v(data->rect_fl, screen_co)) {
                BM_face_select_set(data->vc->em->bm, efa, data->select);
        }
 }
@@ -2216,7 +2247,8 @@ void VIEW3D_OT_select(wmOperatorType *ot)
 typedef struct CircleSelectUserData {
        ViewContext *vc;
        short select;
-       int mval[2];
+       int   mval[2];
+       float mval_fl[2];
        float radius;
        float radius_squared;
 
@@ -2230,6 +2262,9 @@ static void view3d_userdata_circleselect_init(CircleSelectUserData *r_data,
        r_data->vc = vc;
        r_data->select = select;
        copy_v2_v2_int(r_data->mval, mval);
+       r_data->mval_fl[0] = mval[0];
+       r_data->mval_fl[1] = mval[1];
+
        r_data->radius = rad;
        r_data->radius_squared = rad * rad;
 
@@ -2237,31 +2272,27 @@ static void view3d_userdata_circleselect_init(CircleSelectUserData *r_data,
        r_data->is_change = FALSE;
 }
 
-static void mesh_circle_doSelectVert(void *userData, BMVert *eve, int x, int y, int UNUSED(index))
+static void mesh_circle_doSelectVert(void *userData, BMVert *eve, const float screen_co[2], int UNUSED(index))
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
 
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                BM_vert_select_set(data->vc->em->bm, eve, data->select);
        }
 }
-static void mesh_circle_doSelectEdge(void *userData, BMEdge *eed, int x0, int y0, int x1, int y1, int UNUSED(index))
+static void mesh_circle_doSelectEdge(void *userData, BMEdge *eed, const float screen_co_a[2], const float screen_co_b[2], int UNUSED(index))
 {
        CircleSelectUserData *data = userData;
 
-       if (edge_inside_circle(data->mval[0], data->mval[1], (int)data->radius, x0, y0, x1, y1)) {
+       if (edge_inside_circle(data->mval_fl, (int)data->radius, screen_co_a, screen_co_b)) {
                BM_edge_select_set(data->vc->em->bm, eed, data->select);
        }
 }
-static void mesh_circle_doSelectFace(void *userData, BMFace *efa, int x, int y, int UNUSED(index))
+static void mesh_circle_doSelectFace(void *userData, BMFace *efa, const float screen_co[2], int UNUSED(index))
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
 
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                BM_face_select_set(data->vc->em->bm, efa, data->select);
        }
 }
@@ -2345,16 +2376,13 @@ static void paint_vertsel_circle_select(ViewContext *vc, int select, const int m
 }
 
 
-static void nurbscurve_circle_doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, int x, int y)
+static void nurbscurve_circle_doSelect(void *userData, Nurb *UNUSED(nu), BPoint *bp, BezTriple *bezt, int beztindex, const float screen_co[2])
 {
        CircleSelectUserData *data = userData;
        Object *obedit = data->vc->obedit;
        Curve *cu = (Curve *)obedit->data;
 
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
-
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                if (bp) {
                        bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
 
@@ -2392,13 +2420,11 @@ static void nurbscurve_circle_select(ViewContext *vc, int select, const int mval
 }
 
 
-static void latticecurve_circle_doSelect(void *userData, BPoint *bp, int x, int y)
+static void latticecurve_circle_doSelect(void *userData, BPoint *bp, const float screen_co[2])
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
 
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                bp->f1 = data->select ? (bp->f1 | SELECT) : (bp->f1 & ~SELECT);
        }
 }
@@ -2414,13 +2440,11 @@ static void lattice_circle_select(ViewContext *vc, int select, const int mval[2]
 
 
 /* NOTE: pose-bone case is copied from editbone case... */
-static short pchan_circle_doSelectJoint(void *userData, bPoseChannel *pchan, int x, int y)
+static short pchan_circle_doSelectJoint(void *userData, bPoseChannel *pchan, const float screen_co[2])
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
 
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                if (data->select)
                        pchan->bone->flag |= BONE_SELECTED;
                else
@@ -2429,7 +2453,7 @@ static short pchan_circle_doSelectJoint(void *userData, bPoseChannel *pchan, int
        }
        return 0;
 }
-static void do_circle_select_pose__doSelectBone(void *userData, struct bPoseChannel *pchan, int x0, int y0, int x1, int y1)
+static void do_circle_select_pose__doSelectBone(void *userData, struct bPoseChannel *pchan, const float screen_co_a[2], const float screen_co_b[2])
 {
        CircleSelectUserData *data = userData;
        bArmature *arm = data->vc->obact->data;
@@ -2439,17 +2463,17 @@ static void do_circle_select_pose__doSelectBone(void *userData, struct bPoseChan
                int points_proj_tot = 0;
 
                /* project head location to screenspace */
-               if (x0 != IS_CLIPPED) {
+               if (screen_co_a[0] != IS_CLIPPED) {
                        points_proj_tot++;
-                       if (pchan_circle_doSelectJoint(data, pchan, x0, y0)) {
+                       if (pchan_circle_doSelectJoint(data, pchan, screen_co_a)) {
                                is_point_done = TRUE;
                        }
                }
 
                /* project tail location to screenspace */
-               if (x1 != IS_CLIPPED) {
+               if (screen_co_b[0] != IS_CLIPPED) {
                        points_proj_tot++;
-                       if (pchan_circle_doSelectJoint(data, pchan, x1, y1)) {
+                       if (pchan_circle_doSelectJoint(data, pchan, screen_co_a)) {
                                is_point_done = TRUE;
                        }
                }
@@ -2462,7 +2486,7 @@ static void do_circle_select_pose__doSelectBone(void *userData, struct bPoseChan
                 * It works nicer to only do this if the head or tail are not in the circle,
                 * otherwise there is no way to circle select joints alone */
                if ((is_point_done == FALSE) && (points_proj_tot == 2) &&
-                   edge_inside_circle(data->mval[0], data->mval[1], data->radius, x0, y0, x1, y1))
+                   edge_inside_circle(data->mval_fl, data->radius, screen_co_a, screen_co_b))
                {
                        if (data->select) pchan->bone->flag |= BONE_SELECTED;
                        else              pchan->bone->flag &= ~BONE_SELECTED;
@@ -2494,13 +2518,11 @@ static void pose_circle_select(ViewContext *vc, int select, const int mval[2], f
        }
 }
 
-static short armature_circle_doSelectJoint(void *userData, EditBone *ebone, int x, int y, short head)
+static short armature_circle_doSelectJoint(void *userData, EditBone *ebone, const float screen_co[2], short head)
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
-       
-       if (len_squared_v2(delta) <= data->radius_squared) {
+
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                if (head) {
                        if (data->select)
                                ebone->flag |= BONE_ROOTSEL;
@@ -2517,7 +2539,7 @@ static short armature_circle_doSelectJoint(void *userData, EditBone *ebone, int
        }
        return 0;
 }
-static void do_circle_select_armature__doSelectBone(void *userData, struct EditBone *ebone, int x0, int y0, int x1, int y1)
+static void do_circle_select_armature__doSelectBone(void *userData, struct EditBone *ebone, const float screen_co_a[2], const float screen_co_b[2])
 {
        CircleSelectUserData *data = userData;
        bArmature *arm = data->vc->obedit->data;
@@ -2527,17 +2549,17 @@ static void do_circle_select_armature__doSelectBone(void *userData, struct EditB
                int points_proj_tot = 0;
 
                /* project head location to screenspace */
-               if (x0 != IS_CLIPPED) {
+               if (screen_co_a[0] != IS_CLIPPED) {
                        points_proj_tot++;
-                       if (armature_circle_doSelectJoint(data, ebone, x0, y0, TRUE)) {
+                       if (armature_circle_doSelectJoint(data, ebone, screen_co_a, TRUE)) {
                                is_point_done = TRUE;
                        }
                }
 
                /* project tail location to screenspace */
-               if (x1 != IS_CLIPPED) {
+               if (screen_co_b[0] != IS_CLIPPED) {
                        points_proj_tot++;
-                       if (armature_circle_doSelectJoint(data, ebone, x1, y1, FALSE)) {
+                       if (armature_circle_doSelectJoint(data, ebone, screen_co_b, FALSE)) {
                                is_point_done = TRUE;
                        }
                }
@@ -2550,7 +2572,7 @@ static void do_circle_select_armature__doSelectBone(void *userData, struct EditB
                 * It works nicer to only do this if the head or tail are not in the circle,
                 * otherwise there is no way to circle select joints alone */
                if ((is_point_done == FALSE) && (points_proj_tot == 2) &&
-                   edge_inside_circle(data->mval[0], data->mval[1], data->radius, x0, y0, x1, y1))
+                   edge_inside_circle(data->mval_fl, data->radius, screen_co_a, screen_co_b))
                {
                        if (data->select) ebone->flag |=  (BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
                        else              ebone->flag &= ~(BONE_SELECTED | BONE_TIPSEL | BONE_ROOTSEL);
@@ -2578,13 +2600,11 @@ static void armature_circle_select(ViewContext *vc, int select, const int mval[2
        }
 }
 
-static void do_circle_select_mball__doSelectElem(void *userData, struct MetaElem *ml, int x, int y)
+static void do_circle_select_mball__doSelectElem(void *userData, struct MetaElem *ml, const float screen_co[2])
 {
        CircleSelectUserData *data = userData;
-       const float delta[2] = {(float)(x - data->mval[0]),
-                               (float)(y - data->mval[1])};
 
-       if (len_squared_v2(delta) <= data->radius_squared) {
+       if (len_squared_v2v2(data->mval_fl, screen_co) <= data->radius_squared) {
                if (data->select) ml->flag |=  SELECT;
                else              ml->flag &= ~SELECT;
                data->is_change = TRUE;