archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Cleanup: rename mcords to mcoords

Browse Source 
- 'coords' is an abbreviation for coordinates, not 'cords'.
- Rename 'moves' to 'coords_len'.
This commit is contained in:
Campbell Barton
2020-05-04 19:50:06 +10:00
parent 2addc868de
commit 9eb46d6c29
19 changed files with 249 additions and 218 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
source/blender/blenlib/BLI_lasso_2d.h
View File

@@ -30,14 +30,14 @@ extern "C" {
struct rcti; struct rcti;
void BLI_lasso_boundbox(struct rcti *rect, const int mcords[][2], const unsigned int moves); void BLI_lasso_boundbox(struct rcti *rect, const int mcoords[][2], const unsigned int mcoords_len);
bool BLI_lasso_is_point_inside(const int mcords[][2], bool BLI_lasso_is_point_inside(const int mcoords[][2],
const unsigned int moves, const unsigned int mcoords_len,
const int sx, const int sx,
const int sy, const int sy,
const int error_value); const int error_value);
bool BLI_lasso_is_edge_inside(const int mcords[][2], bool BLI_lasso_is_edge_inside(const int mcoords[][2],
const unsigned int moves, const unsigned int mcoords_len,
int x0, int x0,
int y0, int y0,
int x1, int x1,

48
source/blender/blenlib/intern/lasso_2d.c
View File

@@ -28,47 +28,47 @@
#include "BLI_lasso_2d.h" /* own include */ #include "BLI_lasso_2d.h" /* own include */
void BLI_lasso_boundbox(rcti *rect, const int mcords[][2], const unsigned int moves) void BLI_lasso_boundbox(rcti *rect, const int mcoords[][2], const unsigned int mcoords_len)
{ {
unsigned int a; unsigned int a;
rect->xmin = rect->xmax = mcords[0][0]; rect->xmin = rect->xmax = mcoords[0][0];
rect->ymin = rect->ymax = mcords[0][1]; rect->ymin = rect->ymax = mcoords[0][1];
for (a = 1; a < moves; a++) { for (a = 1; a < mcoords_len; a++) {
if (mcords[a][0] < rect->xmin) { if (mcoords[a][0] < rect->xmin) {
rect->xmin = mcords[a][0]; rect->xmin = mcoords[a][0];
} }
else if (mcords[a][0] > rect->xmax) { else if (mcoords[a][0] > rect->xmax) {
rect->xmax = mcords[a][0]; rect->xmax = mcoords[a][0];
} }
if (mcords[a][1] < rect->ymin) { if (mcoords[a][1] < rect->ymin) {
rect->ymin = mcords[a][1]; rect->ymin = mcoords[a][1];
} }
else if (mcords[a][1] > rect->ymax) { else if (mcoords[a][1] > rect->ymax) {
rect->ymax = mcords[a][1]; rect->ymax = mcoords[a][1];
} }
} }
} }
bool BLI_lasso_is_point_inside(const int mcords[][2], bool BLI_lasso_is_point_inside(const int mcoords[][2],
const unsigned int moves, const unsigned int mcoords_len,
const int sx, const int sx,
const int sy, const int sy,
const int error_value) const int error_value)
{ {
if (sx == error_value || moves == 0) { if (sx == error_value || mcoords_len == 0) {
return false; return false;
} }
else { else {
int pt[2] = {sx, sy}; int pt[2] = {sx, sy};
return isect_point_poly_v2_int(pt, mcords, moves, true); return isect_point_poly_v2_int(pt, mcoords, mcoords_len, true);
} }
} }
/* edge version for lasso select. we assume boundbox check was done */ /* edge version for lasso select. we assume boundbox check was done */
bool BLI_lasso_is_edge_inside(const int mcords[][2], bool BLI_lasso_is_edge_inside(const int mcoords[][2],
const unsigned int moves, const unsigned int mcoords_len,
int x0, int x0,
int y0, int y0,
int x1, int x1,
@@ -76,27 +76,27 @@ bool BLI_lasso_is_edge_inside(const int mcords[][2],
const int error_value) const int error_value)
{ {
if (x0 == error_value || x1 == error_value || moves == 0) { if (x0 == error_value || x1 == error_value || mcoords_len == 0) {
return false; return false;
} }
const int v1[2] = {x0, y0}, v2[2] = {x1, y1}; const int v1[2] = {x0, y0}, v2[2] = {x1, y1};
/* check points in lasso */ /* check points in lasso */
if (BLI_lasso_is_point_inside(mcords, moves, v1[0], v1[1], error_value)) { if (BLI_lasso_is_point_inside(mcoords, mcoords_len, v1[0], v1[1], error_value)) {
return true; return true;
} }
if (BLI_lasso_is_point_inside(mcords, moves, v2[0], v2[1], error_value)) { if (BLI_lasso_is_point_inside(mcoords, mcoords_len, v2[0], v2[1], error_value)) {
return true; return true;
} }
/* no points in lasso, so we have to intersect with lasso edge */ /* no points in lasso, so we have to intersect with lasso edge */
if (isect_seg_seg_v2_int(mcords[0], mcords[moves - 1], v1, v2) > 0) { if (isect_seg_seg_v2_int(mcoords[0], mcoords[mcoords_len - 1], v1, v2) > 0) {
return true; return true;
} }
for (unsigned int a = 0; a < moves - 1; a++) { for (unsigned int a = 0; a < mcoords_len - 1; a++) {
if (isect_seg_seg_v2_int(mcords[a], mcords[a + 1], v1, v2) > 0) { if (isect_seg_seg_v2_int(mcoords[a], mcoords[a + 1], v1, v2) > 0) {
return true; return true;
} }
} }

2
source/blender/editors/animation/keyframes_edit.c
View File

@@ -633,7 +633,7 @@ bool keyframe_region_lasso_test(const KeyframeEdit_LassoData *data_lasso, const
BLI_rctf_transform_pt_v(data_lasso->rectf_view, data_lasso->rectf_scaled, xy_view, xy); BLI_rctf_transform_pt_v(data_lasso->rectf_view, data_lasso->rectf_scaled, xy_view, xy);
if (BLI_lasso_is_point_inside( if (BLI_lasso_is_point_inside(
data_lasso->mcords, data_lasso->mcords_tot, xy_view[0], xy_view[1], INT_MAX)) { data_lasso->mcoords, data_lasso->mcoords_len, xy_view[0], xy_view[1], INT_MAX)) {
return true; return true;
} }
} }

14
source/blender/editors/gpencil/gpencil_edit.c
View File

@@ -4547,8 +4547,8 @@ void GPENCIL_OT_stroke_smooth(wmOperatorType *ot)
/* smart stroke cutter for trimming stroke ends */ /* smart stroke cutter for trimming stroke ends */
struct GP_SelectLassoUserData { struct GP_SelectLassoUserData {
rcti rect; rcti rect;
const int (*mcords)[2]; const int (*mcoords)[2];
int mcords_len; int mcoords_len;
}; };
static bool gpencil_test_lasso(bGPDstroke *gps, static bool gpencil_test_lasso(bGPDstroke *gps,
@@ -4564,7 +4564,7 @@ static bool gpencil_test_lasso(bGPDstroke *gps,
gp_point_to_xy(gsc, gps, &pt2, &x0, &y0); gp_point_to_xy(gsc, gps, &pt2, &x0, &y0);
/* test if in lasso */ /* test if in lasso */
return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) && return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) &&
BLI_lasso_is_point_inside(data->mcords, data->mcords_len, x0, y0, INT_MAX)); BLI_lasso_is_point_inside(data->mcoords, data->mcoords_len, x0, y0, INT_MAX));
} }
typedef bool (*GPencilTestFn)(bGPDstroke *gps, typedef bool (*GPencilTestFn)(bGPDstroke *gps,
@@ -4742,19 +4742,19 @@ static int gpencil_cutter_exec(bContext *C, wmOperator *op)
} }
struct GP_SelectLassoUserData data = {0}; struct GP_SelectLassoUserData data = {0};
data.mcords = WM_gesture_lasso_path_to_array(C, op, &data.mcords_len); data.mcoords = WM_gesture_lasso_path_to_array(C, op, &data.mcoords_len);
/* Sanity check. */ /* Sanity check. */
if (data.mcords == NULL) { if (data.mcoords == NULL) {
return OPERATOR_PASS_THROUGH; return OPERATOR_PASS_THROUGH;
} }
/* Compute boundbox of lasso (for faster testing later). */ /* Compute boundbox of lasso (for faster testing later). */
BLI_lasso_boundbox(&data.rect, data.mcords, data.mcords_len); BLI_lasso_boundbox(&data.rect, data.mcoords, data.mcoords_len);
gpencil_cutter_lasso_select(C, op, gpencil_test_lasso, &data); gpencil_cutter_lasso_select(C, op, gpencil_test_lasso, &data);
MEM_freeN((void *)data.mcords); MEM_freeN((void *)data.mcoords);
return OPERATOR_FINISHED; return OPERATOR_FINISHED;
} }

14
source/blender/editors/gpencil/gpencil_select.c
View File

@@ -1327,8 +1327,8 @@ void GPENCIL_OT_select_box(wmOperatorType *ot)
struct GP_SelectLassoUserData { struct GP_SelectLassoUserData {
rcti rect; rcti rect;
const int (*mcords)[2]; const int (*mcoords)[2];
int mcords_len; int mcoords_len;
}; };
static bool gpencil_test_lasso(bGPDstroke *gps, static bool gpencil_test_lasso(bGPDstroke *gps,
@@ -1344,25 +1344,25 @@ static bool gpencil_test_lasso(bGPDstroke *gps,
gp_point_to_xy(gsc, gps, &pt2, &x0, &y0); gp_point_to_xy(gsc, gps, &pt2, &x0, &y0);
/* test if in lasso boundbox + within the lasso noose */ /* test if in lasso boundbox + within the lasso noose */
return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) && return ((!ELEM(V2D_IS_CLIPPED, x0, y0)) && BLI_rcti_isect_pt(&data->rect, x0, y0) &&
BLI_lasso_is_point_inside(data->mcords, data->mcords_len, x0, y0, INT_MAX)); BLI_lasso_is_point_inside(data->mcoords, data->mcoords_len, x0, y0, INT_MAX));
} }
static int gpencil_lasso_select_exec(bContext *C, wmOperator *op) static int gpencil_lasso_select_exec(bContext *C, wmOperator *op)
{ {
struct GP_SelectLassoUserData data = {0}; struct GP_SelectLassoUserData data = {0};
data.mcords = WM_gesture_lasso_path_to_array(C, op, &data.mcords_len); data.mcoords = WM_gesture_lasso_path_to_array(C, op, &data.mcoords_len);
/* Sanity check. */ /* Sanity check. */
if (data.mcords == NULL) { if (data.mcoords == NULL) {
return OPERATOR_PASS_THROUGH; return OPERATOR_PASS_THROUGH;
} }
/* Compute boundbox of lasso (for faster testing later). */ /* Compute boundbox of lasso (for faster testing later). */
BLI_lasso_boundbox(&data.rect, data.mcords, data.mcords_len); BLI_lasso_boundbox(&data.rect, data.mcoords, data.mcoords_len);
int ret = gpencil_generic_select_exec(C, op, gpencil_test_lasso, &data); int ret = gpencil_generic_select_exec(C, op, gpencil_test_lasso, &data);
MEM_freeN((void *)data.mcords); MEM_freeN((void *)data.mcoords);
return ret; return ret;
} }

4
source/blender/editors/include/ED_keyframes_edit.h
View File

@@ -106,8 +106,8 @@ typedef enum eEditKeyframes_Mirror {
typedef struct KeyframeEdit_LassoData { typedef struct KeyframeEdit_LassoData {
rctf *rectf_scaled; rctf *rectf_scaled;
const rctf *rectf_view; const rctf *rectf_view;
const int (*mcords)[2]; const int (*mcoords)[2];
int mcords_tot; int mcoords_len;
} KeyframeEdit_LassoData; } KeyframeEdit_LassoData;
/* use with BEZT_OK_REGION_CIRCLE */ /* use with BEZT_OK_REGION_CIRCLE */

2
source/blender/editors/include/ED_particle.h
View File

@@ -71,7 +71,7 @@ bool PE_mouse_particles(
bool PE_box_select(struct bContext *C, const struct rcti *rect, const int sel_op); bool PE_box_select(struct bContext *C, const struct rcti *rect, const int sel_op);
bool PE_circle_select(struct bContext *C, const int sel_op, const int mval[2], float rad); bool PE_circle_select(struct bContext *C, const int sel_op, const int mval[2], float rad);
int PE_lasso_select(struct bContext *C, int PE_lasso_select(struct bContext *C,
const int mcords[][2], const int mcoords[][2],
const short moves, const short moves,
const int sel_op); const int sel_op);
bool PE_deselect_all_visible_ex(struct PTCacheEdit *edit); bool PE_deselect_all_visible_ex(struct PTCacheEdit *edit);

18
source/blender/editors/mask/mask_select.c
View File

@@ -521,8 +521,8 @@ void MASK_OT_select_box(wmOperatorType *ot)
* \{ */ * \{ */
static bool do_lasso_select_mask(bContext *C, static bool do_lasso_select_mask(bContext *C,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
ScrArea *area = CTX_wm_area(C); ScrArea *area = CTX_wm_area(C);
@@ -540,7 +540,7 @@ static bool do_lasso_select_mask(bContext *C,
} }
/* get rectangle from operator */ /* get rectangle from operator */
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
/* do actual selection */ /* do actual selection */
LISTBASE_FOREACH (MaskLayer *, mask_layer, &mask->masklayers) { LISTBASE_FOREACH (MaskLayer *, mask_layer, &mask->masklayers) {
@@ -573,7 +573,7 @@ static bool do_lasso_select_mask(bContext *C,
&screen_co[1]); &screen_co[1]);
if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) && if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX)) { BLI_lasso_is_point_inside(mcoords, mcoords_len, screen_co[0], screen_co[1], INT_MAX)) {
BKE_mask_point_select_set(point, select); BKE_mask_point_select_set(point, select);
BKE_mask_point_select_set_handle(point, MASK_WHICH_HANDLE_BOTH, select); BKE_mask_point_select_set_handle(point, MASK_WHICH_HANDLE_BOTH, select);
changed = true; changed = true;
@@ -594,14 +594,14 @@ static bool do_lasso_select_mask(bContext *C,
static int clip_lasso_select_exec(bContext *C, wmOperator *op) static int clip_lasso_select_exec(bContext *C, wmOperator *op)
{ {
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode"); const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
do_lasso_select_mask(C, mcords, mcords_tot, sel_op); do_lasso_select_mask(C, mcoords, mcoords_len, sel_op);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
return OPERATOR_FINISHED; return OPERATOR_FINISHED;
} }

8
source/blender/editors/physics/particle_edit.c
View File

@@ -2252,7 +2252,7 @@ bool PE_circle_select(bContext *C, const int sel_op, const int mval[2], float ra
/************************ lasso select operator ************************/ /************************ lasso select operator ************************/
int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const int sel_op) int PE_lasso_select(bContext *C, const int mcoords[][2], const short mcoords_len, const int sel_op)
{ {
Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C); Depsgraph *depsgraph = CTX_data_depsgraph_pointer(C);
Scene *scene = CTX_data_scene(C); Scene *scene = CTX_data_scene(C);
@@ -2296,7 +2296,8 @@ int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const
const bool is_inside = const bool is_inside =
((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) == ((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) ==
V3D_PROJ_RET_OK) && V3D_PROJ_RET_OK) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], IS_CLIPPED) && BLI_lasso_is_point_inside(
mcoords, mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED) &&
key_test_depth(&data, co, screen_co)); key_test_depth(&data, co, screen_co));
const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
@@ -2315,7 +2316,8 @@ int PE_lasso_select(bContext *C, const int mcords[][2], const short moves, const
const bool is_inside = const bool is_inside =
((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) == ((ED_view3d_project_int_global(region, co, screen_co, V3D_PROJ_TEST_CLIP_WIN) ==
V3D_PROJ_RET_OK) && V3D_PROJ_RET_OK) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], IS_CLIPPED) && BLI_lasso_is_point_inside(
mcoords, mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED) &&
key_test_depth(&data, co, screen_co)); key_test_depth(&data, co, screen_co));
const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {

14
source/blender/editors/sculpt_paint/paint_mask.c
View File

@@ -456,10 +456,10 @@ static void mask_gesture_lasso_task_cb(void *__restrict userdata,
static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op) static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
{ {
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C); Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
float clip_planes[4][4], clip_planes_final[4][4]; float clip_planes[4][4], clip_planes_final[4][4];
BoundBox bb; BoundBox bb;
@@ -485,7 +485,7 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
ob = vc.obact; ob = vc.obact;
ED_view3d_ob_project_mat_get(vc.rv3d, ob, data.projviewobjmat); ED_view3d_ob_project_mat_get(vc.rv3d, ob, data.projviewobjmat);
BLI_lasso_boundbox(&data.rect, mcords, mcords_tot); BLI_lasso_boundbox(&data.rect, mcoords, mcoords_len);
data.width = data.rect.xmax - data.rect.xmin; data.width = data.rect.xmax - data.rect.xmin;
data.px = BLI_BITMAP_NEW(data.width * (data.rect.ymax - data.rect.ymin), __func__); data.px = BLI_BITMAP_NEW(data.width * (data.rect.ymax - data.rect.ymin), __func__);
@@ -493,8 +493,8 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
data.rect.ymin, data.rect.ymin,
data.rect.xmax, data.rect.xmax,
data.rect.ymax, data.rect.ymax,
mcords, mcoords,
mcords_tot, mcoords_len,
mask_lasso_px_cb, mask_lasso_px_cb,
&data); &data);
@@ -551,7 +551,7 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
SCULPT_undo_push_end(); SCULPT_undo_push_end();
ED_region_tag_redraw(vc.region); ED_region_tag_redraw(vc.region);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
MEM_freeN(data.px); MEM_freeN(data.px);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob); WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);

8
source/blender/editors/space_action/action_select.c
View File

@@ -793,8 +793,8 @@ static int actkeys_lassoselect_exec(bContext *C, wmOperator *op)
} }
data_lasso.rectf_view = &rect_fl; data_lasso.rectf_view = &rect_fl;
data_lasso.mcords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcords_tot); data_lasso.mcoords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcoords_len);
if (data_lasso.mcords == NULL) { if (data_lasso.mcoords == NULL) {
return OPERATOR_CANCELLED; return OPERATOR_CANCELLED;
} }
@@ -805,13 +805,13 @@ static int actkeys_lassoselect_exec(bContext *C, wmOperator *op)
} }
/* get settings from operator */ /* get settings from operator */
BLI_lasso_boundbox(&rect, data_lasso.mcords, data_lasso.mcords_tot); BLI_lasso_boundbox(&rect, data_lasso.mcoords, data_lasso.mcoords_len);
BLI_rctf_rcti_copy(&rect_fl, &rect); BLI_rctf_rcti_copy(&rect_fl, &rect);
/* apply box_select action */ /* apply box_select action */
region_select_action_keys(&ac, &rect_fl, BEZT_OK_CHANNEL_LASSO, selectmode, &data_lasso); region_select_action_keys(&ac, &rect_fl, BEZT_OK_CHANNEL_LASSO, selectmode, &data_lasso);
MEM_freeN((void *)data_lasso.mcords); MEM_freeN((void *)data_lasso.mcoords);
/* send notifier that keyframe selection has changed */ /* send notifier that keyframe selection has changed */
WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL); WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);

22
source/blender/editors/space_clip/tracking_select.c
View File

@@ -598,8 +598,8 @@ void CLIP_OT_select_box(wmOperatorType *ot)
/********************** lasso select operator *********************/ /********************** lasso select operator *********************/
static int do_lasso_select_marker(bContext *C, static int do_lasso_select_marker(bContext *C,
const int mcords[][2], const int mcoords[][2],
const short moves, const short mcoords_len,
bool select) bool select)
{ {
SpaceClip *sc = CTX_wm_space_clip(C); SpaceClip *sc = CTX_wm_space_clip(C);
@@ -616,7 +616,7 @@ static int do_lasso_select_marker(bContext *C,
int framenr = ED_space_clip_get_clip_frame_number(sc); int framenr = ED_space_clip_get_clip_frame_number(sc);
/* get rectangle from operator */ /* get rectangle from operator */
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
/* do actual selection */ /* do actual selection */
track = tracksbase->first; track = tracksbase->first;
@@ -631,7 +631,8 @@ static int do_lasso_select_marker(bContext *C,
ED_clip_point_stable_pos__reverse(sc, region, marker->pos, screen_co); ED_clip_point_stable_pos__reverse(sc, region, marker->pos, screen_co);
if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) && if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) { BLI_lasso_is_point_inside(
mcoords, mcoords_len, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
if (select) { if (select) {
BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT); BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
} }
@@ -659,7 +660,8 @@ static int do_lasso_select_marker(bContext *C,
ED_clip_point_stable_pos__reverse(sc, region, plane_marker->corners[i], screen_co); ED_clip_point_stable_pos__reverse(sc, region, plane_marker->corners[i], screen_co);
if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) && if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) { BLI_lasso_is_point_inside(
mcoords, mcoords_len, screen_co[0], screen_co[1], V2D_IS_CLIPPED)) {
if (select) { if (select) {
plane_track->flag |= SELECT; plane_track->flag |= SELECT;
} }
@@ -685,10 +687,10 @@ static int do_lasso_select_marker(bContext *C,
static int clip_lasso_select_exec(bContext *C, wmOperator *op) static int clip_lasso_select_exec(bContext *C, wmOperator *op)
{ {
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode"); const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
const bool select = (sel_op != SEL_OP_SUB); const bool select = (sel_op != SEL_OP_SUB);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
@@ -696,9 +698,9 @@ static int clip_lasso_select_exec(bContext *C, wmOperator *op)
ED_clip_select_all(sc, SEL_DESELECT, NULL); ED_clip_select_all(sc, SEL_DESELECT, NULL);
} }
do_lasso_select_marker(C, mcords, mcords_tot, select); do_lasso_select_marker(C, mcoords, mcoords_len, select);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
return OPERATOR_FINISHED; return OPERATOR_FINISHED;
} }

8
source/blender/editors/space_graph/graph_select.c
View File

@@ -760,8 +760,8 @@ static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
} }
data_lasso.rectf_view = &rect_fl; data_lasso.rectf_view = &rect_fl;
data_lasso.mcords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcords_tot); data_lasso.mcoords = WM_gesture_lasso_path_to_array(C, op, &data_lasso.mcoords_len);
if (data_lasso.mcords == NULL) { if (data_lasso.mcoords == NULL) {
return OPERATOR_CANCELLED; return OPERATOR_CANCELLED;
} }
@@ -782,13 +782,13 @@ static int graphkeys_lassoselect_exec(bContext *C, wmOperator *op)
} }
/* get settings from operator */ /* get settings from operator */
BLI_lasso_boundbox(&rect, data_lasso.mcords, data_lasso.mcords_tot); BLI_lasso_boundbox(&rect, data_lasso.mcoords, data_lasso.mcoords_len);
BLI_rctf_rcti_copy(&rect_fl, &rect); BLI_rctf_rcti_copy(&rect_fl, &rect);
/* apply box_select action */ /* apply box_select action */
box_select_graphkeys(&ac, &rect_fl, BEZT_OK_REGION_LASSO, selectmode, incl_handles, &data_lasso); box_select_graphkeys(&ac, &rect_fl, BEZT_OK_REGION_LASSO, selectmode, incl_handles, &data_lasso);
MEM_freeN((void *)data_lasso.mcords); MEM_freeN((void *)data_lasso.mcoords);
/* send notifier that keyframe selection has changed */ /* send notifier that keyframe selection has changed */
WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL); WM_event_add_notifier(C, NC_ANIMATION | ND_KEYFRAME | NA_SELECTED, NULL);

19
source/blender/editors/space_node/node_select.c
View File

@@ -766,7 +766,10 @@ static int node_lasso_select_invoke(bContext *C, wmOperator *op, const wmEvent *
return WM_gesture_lasso_invoke(C, op, event); return WM_gesture_lasso_invoke(C, op, event);
} }
static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves, eSelectOp sel_op) static bool do_lasso_select_node(bContext *C,
const int mcoords[][2],
short mcoords_len,
eSelectOp sel_op)
{ {
SpaceNode *snode = CTX_wm_space_node(C); SpaceNode *snode = CTX_wm_space_node(C);
bNode *node; bNode *node;
@@ -783,7 +786,7 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
} }
/* get rectangle from operator */ /* get rectangle from operator */
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
/* do actual selection */ /* do actual selection */
for (node = snode->edittree->nodes.first; node; node = node->next) { for (node = snode->edittree->nodes.first; node; node = node->next) {
@@ -799,7 +802,7 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
if (UI_view2d_view_to_region_clip( if (UI_view2d_view_to_region_clip(
&region->v2d, cent[0], cent[1], &screen_co[0], &screen_co[1]) && &region->v2d, cent[0], cent[1], &screen_co[0], &screen_co[1]) &&
BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) && BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&
BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX)) { BLI_lasso_is_point_inside(mcoords, mcoords_len, screen_co[0], screen_co[1], INT_MAX)) {
nodeSetSelected(node, select); nodeSetSelected(node, select);
changed = true; changed = true;
} }
@@ -814,15 +817,15 @@ static bool do_lasso_select_node(bContext *C, const int mcords[][2], short moves
static int node_lasso_select_exec(bContext *C, wmOperator *op) static int node_lasso_select_exec(bContext *C, wmOperator *op)
{ {
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode"); const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
do_lasso_select_node(C, mcords, mcords_tot, sel_op); do_lasso_select_node(C, mcoords, mcoords_len, sel_op);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
return OPERATOR_FINISHED; return OPERATOR_FINISHED;
} }

212
source/blender/editors/space_view3d/view3d_select.c
View File

@@ -408,8 +408,8 @@ typedef struct LassoSelectUserData {
const rcti *rect; const rcti *rect;
const rctf *rect_fl; const rctf *rect_fl;
rctf _rect_fl; rctf _rect_fl;
const int (*mcords)[2]; const int (*mcoords)[2];
int moves; int mcoords_len;
eSelectOp sel_op; eSelectOp sel_op;
/* runtime */ /* runtime */
@@ -421,8 +421,8 @@ typedef struct LassoSelectUserData {
static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data, static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data,
ViewContext *vc, ViewContext *vc,
const rcti *rect, const rcti *rect,
const int (*mcords)[2], const int (*mcoords)[2],
const int moves, const int mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
r_data->vc = vc; r_data->vc = vc;
@@ -431,8 +431,8 @@ static void view3d_userdata_lassoselect_init(LassoSelectUserData *r_data,
r_data->rect_fl = &r_data->_rect_fl; r_data->rect_fl = &r_data->_rect_fl;
BLI_rctf_rcti_copy(&r_data->_rect_fl, rect); BLI_rctf_rcti_copy(&r_data->_rect_fl, rect);
r_data->mcords = mcords; r_data->mcoords = mcoords;
r_data->moves = moves; r_data->mcoords_len = mcoords_len;
r_data->sel_op = sel_op; r_data->sel_op = sel_op;
/* runtime */ /* runtime */
@@ -527,7 +527,8 @@ static void do_lasso_select_pose__do_tag(void *userData,
if (screen_co_a[0] != IS_CLIPPED) { if (screen_co_a[0] != IS_CLIPPED) {
points_proj_tot++; points_proj_tot++;
if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) && if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) &&
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), INT_MAX)) { BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), INT_MAX)) {
is_point_done = true; is_point_done = true;
} }
} }
@@ -536,22 +537,28 @@ static void do_lasso_select_pose__do_tag(void *userData,
if (screen_co_b[0] != IS_CLIPPED) { if (screen_co_b[0] != IS_CLIPPED) {
points_proj_tot++; points_proj_tot++;
if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) && if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) &&
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), INT_MAX)) { BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), INT_MAX)) {
is_point_done = true; is_point_done = true;
} }
} }
/* if one of points selected, we skip the bone itself */ /* if one of points selected, we skip the bone itself */
if ((is_point_done == true) || if ((is_point_done == true) || ((is_point_done == false) && (points_proj_tot == 2) &&
((is_point_done == false) && (points_proj_tot == 2) && BLI_lasso_is_edge_inside(data->mcoords,
BLI_lasso_is_edge_inside( data->mcoords_len,
data->mcords, data->moves, UNPACK2(screen_co_a), UNPACK2(screen_co_b), INT_MAX))) { UNPACK2(screen_co_a),
UNPACK2(screen_co_b),
INT_MAX))) {
pchan->bone->flag |= BONE_DONE; pchan->bone->flag |= BONE_DONE;
} }
data->is_changed |= is_point_done; data->is_changed |= is_point_done;
} }
} }
static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2], short moves) static void do_lasso_tag_pose(ViewContext *vc,
Object *ob,
const int mcoords[][2],
short mcoords_len)
{ {
ViewContext vc_tmp; ViewContext vc_tmp;
LassoSelectUserData data; LassoSelectUserData data;
@@ -564,9 +571,9 @@ static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2]
vc_tmp = *vc; vc_tmp = *vc;
vc_tmp.obact = ob; vc_tmp.obact = ob;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, 0); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, 0);
ED_view3d_init_mats_rv3d(vc_tmp.obact, vc->rv3d); ED_view3d_init_mats_rv3d(vc_tmp.obact, vc->rv3d);
@@ -574,8 +581,8 @@ static void do_lasso_tag_pose(ViewContext *vc, Object *ob, const int mcords[][2]
} }
static bool do_lasso_select_objects(ViewContext *vc, static bool do_lasso_select_objects(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
const short moves, const short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
View3D *v3d = vc->v3d; View3D *v3d = vc->v3d;
@@ -591,7 +598,7 @@ static bool do_lasso_select_objects(ViewContext *vc,
const bool is_select = base->flag & BASE_SELECTED; const bool is_select = base->flag & BASE_SELECTED;
const bool is_inside = ((ED_view3d_project_base(vc->region, base) == V3D_PROJ_RET_OK) && const bool is_inside = ((ED_view3d_project_base(vc->region, base) == V3D_PROJ_RET_OK) &&
BLI_lasso_is_point_inside( BLI_lasso_is_point_inside(
mcords, moves, base->sx, base->sy, IS_CLIPPED)); mcoords, mcoords_len, base->sx, base->sy, IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
ED_object_base_select(base, sel_op_result ? BA_SELECT : BA_DESELECT); ED_object_base_select(base, sel_op_result ? BA_SELECT : BA_DESELECT);
@@ -685,8 +692,8 @@ static bool do_pose_tag_select_op_exec(Base **bases, const uint bases_len, const
} }
static bool do_lasso_select_pose(ViewContext *vc, static bool do_lasso_select_pose(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
const short moves, const short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
uint bases_len; uint bases_len;
@@ -695,7 +702,7 @@ static bool do_lasso_select_pose(ViewContext *vc,
for (int i = 0; i < bases_len; i++) { for (int i = 0; i < bases_len; i++) {
Base *base_iter = bases[i]; Base *base_iter = bases[i];
Object *ob_iter = base_iter->object; Object *ob_iter = base_iter->object;
do_lasso_tag_pose(vc, ob_iter, mcords, moves); do_lasso_tag_pose(vc, ob_iter, mcoords, mcoords_len);
} }
const bool changed_multi = do_pose_tag_select_op_exec(bases, bases_len, sel_op); const bool changed_multi = do_pose_tag_select_op_exec(bases, bases_len, sel_op);
@@ -715,9 +722,10 @@ static void do_lasso_select_mesh__doSelectVert(void *userData,
{ {
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_select = BM_elem_flag_test(eve, BM_ELEM_SELECT); const bool is_select = BM_elem_flag_test(eve, BM_ELEM_SELECT);
const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) && const bool is_inside =
BLI_lasso_is_point_inside( (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)); BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
BM_vert_select_set(data->vc->em->bm, eve, sel_op_result); BM_vert_select_set(data->vc->em->bm, eve, sel_op_result);
@@ -746,8 +754,10 @@ static void do_lasso_select_mesh__doSelectEdge_pass0(void *user_data,
const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT); const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT);
const bool is_inside = const bool is_inside =
(is_visible && edge_fully_inside_rect(data->rect_fl, screen_co_a, screen_co_b) && (is_visible && edge_fully_inside_rect(data->rect_fl, screen_co_a, screen_co_b) &&
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), IS_CLIPPED) && BLI_lasso_is_point_inside(
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), IS_CLIPPED)); data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), IS_CLIPPED) &&
BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
BM_edge_select_set(data->vc->em->bm, eed, sel_op_result); BM_edge_select_set(data->vc->em->bm, eed, sel_op_result);
@@ -770,8 +780,8 @@ static void do_lasso_select_mesh__doSelectEdge_pass1(void *user_data,
} }
const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT); const bool is_select = BM_elem_flag_test(eed, BM_ELEM_SELECT);
const bool is_inside = (is_visible && BLI_lasso_is_edge_inside(data->mcords, const bool is_inside = (is_visible && BLI_lasso_is_edge_inside(data->mcoords,
data->moves, data->mcoords_len,
UNPACK2(screen_co_a), UNPACK2(screen_co_a),
UNPACK2(screen_co_b), UNPACK2(screen_co_b),
IS_CLIPPED)); IS_CLIPPED));
@@ -789,9 +799,10 @@ static void do_lasso_select_mesh__doSelectFace(void *userData,
{ {
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_select = BM_elem_flag_test(efa, BM_ELEM_SELECT); const bool is_select = BM_elem_flag_test(efa, BM_ELEM_SELECT);
const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) && const bool is_inside =
BLI_lasso_is_point_inside( (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)); BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
BM_face_select_set(data->vc->em->bm, efa, sel_op_result); BM_face_select_set(data->vc->em->bm, efa, sel_op_result);
@@ -801,8 +812,8 @@ static void do_lasso_select_mesh__doSelectFace(void *userData,
static bool do_lasso_select_mesh(ViewContext *vc, static bool do_lasso_select_mesh(ViewContext *vc,
wmGenericUserData *wm_userdata, wmGenericUserData *wm_userdata,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
LassoSelectUserData data; LassoSelectUserData data;
@@ -812,9 +823,9 @@ static bool do_lasso_select_mesh(ViewContext *vc,
/* set editmesh */ /* set editmesh */
vc->em = BKE_editmesh_from_object(vc->obedit); vc->em = BKE_editmesh_from_object(vc->obedit);
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
if (vc->em->bm->totvertsel) { if (vc->em->bm->totvertsel) {
@@ -836,7 +847,7 @@ static bool do_lasso_select_mesh(ViewContext *vc,
editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, ts->selectmode); editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, ts->selectmode);
esel = wm_userdata->data; esel = wm_userdata->data;
esel->select_bitmap = DRW_select_buffer_bitmap_from_poly( esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL); vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
} }
} }
@@ -897,7 +908,7 @@ static void do_lasso_select_curve__doSelect(void *userData,
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_inside = BLI_lasso_is_point_inside( const bool is_inside = BLI_lasso_is_point_inside(
data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED); data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED);
if (bp) { if (bp) {
const bool is_select = bp->f1 & SELECT; const bool is_select = bp->f1 & SELECT;
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
@@ -930,16 +941,16 @@ static void do_lasso_select_curve__doSelect(void *userData,
} }
static bool do_lasso_select_curve(ViewContext *vc, static bool do_lasso_select_curve(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
LassoSelectUserData data; LassoSelectUserData data;
rcti rect; rcti rect;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
Curve *curve = (Curve *)vc->obedit->data; Curve *curve = (Curve *)vc->obedit->data;
@@ -958,9 +969,10 @@ static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, const
{ {
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_select = bp->f1 & SELECT; const bool is_select = bp->f1 & SELECT;
const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) && const bool is_inside =
BLI_lasso_is_point_inside( (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)); BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
SET_FLAG_FROM_TEST(bp->f1, sel_op_result, SELECT); SET_FLAG_FROM_TEST(bp->f1, sel_op_result, SELECT);
@@ -968,16 +980,16 @@ static void do_lasso_select_lattice__doSelect(void *userData, BPoint *bp, const
} }
} }
static bool do_lasso_select_lattice(ViewContext *vc, static bool do_lasso_select_lattice(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
LassoSelectUserData data; LassoSelectUserData data;
rcti rect; rcti rect;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
data.is_changed |= ED_lattice_flags_set(vc->obedit, 0); data.is_changed |= ED_lattice_flags_set(vc->obedit, 0);
@@ -1002,7 +1014,8 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
if (screen_co_a[0] != IS_CLIPPED) { if (screen_co_a[0] != IS_CLIPPED) {
if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) && if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_a)) &&
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_a), INT_MAX)) { BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, UNPACK2(screen_co_a), INT_MAX)) {
is_inside_flag |= BONESEL_ROOT; is_inside_flag |= BONESEL_ROOT;
} }
} }
@@ -1012,7 +1025,8 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
if (screen_co_b[0] != IS_CLIPPED) { if (screen_co_b[0] != IS_CLIPPED) {
if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) && if (BLI_rcti_isect_pt(data->rect, UNPACK2(screen_co_b)) &&
BLI_lasso_is_point_inside(data->mcords, data->moves, UNPACK2(screen_co_b), INT_MAX)) { BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, UNPACK2(screen_co_b), INT_MAX)) {
is_inside_flag |= BONESEL_TIP; is_inside_flag |= BONESEL_TIP;
} }
} }
@@ -1022,8 +1036,11 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
if (is_ignore_flag == 0) { if (is_ignore_flag == 0) {
if (is_inside_flag == (BONE_ROOTSEL | BONE_TIPSEL) || if (is_inside_flag == (BONE_ROOTSEL | BONE_TIPSEL) ||
BLI_lasso_is_edge_inside( BLI_lasso_is_edge_inside(data->mcoords,
data->mcords, data->moves, UNPACK2(screen_co_a), UNPACK2(screen_co_b), INT_MAX)) { data->mcoords_len,
UNPACK2(screen_co_a),
UNPACK2(screen_co_b),
INT_MAX)) {
is_inside_flag |= BONESEL_BONE; is_inside_flag |= BONESEL_BONE;
} }
} }
@@ -1033,16 +1050,16 @@ static void do_lasso_select_armature__doSelectBone(void *userData,
} }
static bool do_lasso_select_armature(ViewContext *vc, static bool do_lasso_select_armature(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
LassoSelectUserData data; LassoSelectUserData data;
rcti rect; rcti rect;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
data.is_changed |= ED_armature_edit_deselect_all_visible(vc->obedit); data.is_changed |= ED_armature_edit_deselect_all_visible(vc->obedit);
@@ -1071,9 +1088,10 @@ static void do_lasso_select_mball__doSelectElem(void *userData,
{ {
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_select = ml->flag & SELECT; const bool is_select = ml->flag & SELECT;
const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) && const bool is_inside =
BLI_lasso_is_point_inside( (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
data->mcords, data->moves, screen_co[0], screen_co[1], INT_MAX)); BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], INT_MAX));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
SET_FLAG_FROM_TEST(ml->flag, sel_op_result, SELECT); SET_FLAG_FROM_TEST(ml->flag, sel_op_result, SELECT);
@@ -1081,8 +1099,8 @@ static void do_lasso_select_mball__doSelectElem(void *userData,
} }
} }
static bool do_lasso_select_meta(ViewContext *vc, static bool do_lasso_select_meta(ViewContext *vc,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
LassoSelectUserData data; LassoSelectUserData data;
@@ -1090,9 +1108,9 @@ static bool do_lasso_select_meta(ViewContext *vc,
MetaBall *mb = (MetaBall *)vc->obedit->data; MetaBall *mb = (MetaBall *)vc->obedit->data;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
if (SEL_OP_USE_PRE_DESELECT(sel_op)) { if (SEL_OP_USE_PRE_DESELECT(sel_op)) {
data.is_changed |= BKE_mball_deselect_all(mb); data.is_changed |= BKE_mball_deselect_all(mb);
@@ -1113,9 +1131,10 @@ static void do_lasso_select_meshobject__doSelectVert(void *userData,
{ {
LassoSelectUserData *data = userData; LassoSelectUserData *data = userData;
const bool is_select = mv->flag & SELECT; const bool is_select = mv->flag & SELECT;
const bool is_inside = (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) && const bool is_inside =
BLI_lasso_is_point_inside( (BLI_rctf_isect_pt_v(data->rect_fl, screen_co) &&
data->mcords, data->moves, screen_co[0], screen_co[1], IS_CLIPPED)); BLI_lasso_is_point_inside(
data->mcoords, data->mcoords_len, screen_co[0], screen_co[1], IS_CLIPPED));
const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(data->sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
SET_FLAG_FROM_TEST(mv->flag, sel_op_result, SELECT); SET_FLAG_FROM_TEST(mv->flag, sel_op_result, SELECT);
@@ -1124,8 +1143,8 @@ static void do_lasso_select_meshobject__doSelectVert(void *userData,
} }
static bool do_lasso_select_paintvert(ViewContext *vc, static bool do_lasso_select_paintvert(ViewContext *vc,
wmGenericUserData *wm_userdata, wmGenericUserData *wm_userdata,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
const bool use_zbuf = !XRAY_ENABLED(vc->v3d); const bool use_zbuf = !XRAY_ENABLED(vc->v3d);
@@ -1143,7 +1162,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
changed |= paintvert_deselect_all_visible(ob, SEL_DESELECT, false); changed |= paintvert_deselect_all_visible(ob, SEL_DESELECT, false);
} }
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
struct EditSelectBuf_Cache *esel = wm_userdata->data; struct EditSelectBuf_Cache *esel = wm_userdata->data;
if (use_zbuf) { if (use_zbuf) {
@@ -1151,7 +1170,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_VERTEX); editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_VERTEX);
esel = wm_userdata->data; esel = wm_userdata->data;
esel->select_bitmap = DRW_select_buffer_bitmap_from_poly( esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL); vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
} }
} }
@@ -1163,7 +1182,7 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
else { else {
LassoSelectUserData data; LassoSelectUserData data;
view3d_userdata_lassoselect_init(&data, vc, &rect, mcords, moves, sel_op); view3d_userdata_lassoselect_init(&data, vc, &rect, mcoords, mcoords_len, sel_op);
ED_view3d_init_mats_rv3d(vc->obact, vc->rv3d); ED_view3d_init_mats_rv3d(vc->obact, vc->rv3d);
@@ -1185,8 +1204,8 @@ static bool do_lasso_select_paintvert(ViewContext *vc,
} }
static bool do_lasso_select_paintface(ViewContext *vc, static bool do_lasso_select_paintface(ViewContext *vc,
wmGenericUserData *wm_userdata, wmGenericUserData *wm_userdata,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
Object *ob = vc->obact; Object *ob = vc->obact;
@@ -1203,14 +1222,14 @@ static bool do_lasso_select_paintface(ViewContext *vc,
changed |= paintface_deselect_all_visible(vc->C, ob, SEL_DESELECT, false); changed |= paintface_deselect_all_visible(vc->C, ob, SEL_DESELECT, false);
} }
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
struct EditSelectBuf_Cache *esel = wm_userdata->data; struct EditSelectBuf_Cache *esel = wm_userdata->data;
if (esel == NULL) { if (esel == NULL) {
editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_FACE); editselect_buf_cache_init_with_generic_userdata(wm_userdata, vc, SCE_SELECT_FACE);
esel = wm_userdata->data; esel = wm_userdata->data;
esel->select_bitmap = DRW_select_buffer_bitmap_from_poly( esel->select_bitmap = DRW_select_buffer_bitmap_from_poly(
vc->depsgraph, vc->region, vc->v3d, mcords, moves, &rect, NULL); vc->depsgraph, vc->region, vc->v3d, mcoords, mcoords_len, &rect, NULL);
} }
if (esel->select_bitmap) { if (esel->select_bitmap) {
@@ -1224,7 +1243,7 @@ static bool do_lasso_select_paintface(ViewContext *vc,
} }
#if 0 #if 0
static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp sel_op) static void do_lasso_select_node(int mcoords[][2], short mcoords_len, const eSelectOp sel_op)
{ {
SpaceNode *snode = area->spacedata.first; SpaceNode *snode = area->spacedata.first;
@@ -1234,7 +1253,7 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
float node_centf[2]; float node_centf[2];
bool changed = false; bool changed = false;
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
/* store selection in temp test flag */ /* store selection in temp test flag */
for (node = snode->edittree->nodes.first; node; node = node->next) { for (node = snode->edittree->nodes.first; node; node = node->next) {
@@ -1244,7 +1263,7 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
ipoco_to_areaco_noclip(G.v2d, node_centf, node_cent); ipoco_to_areaco_noclip(G.v2d, node_centf, node_cent);
const bool is_select = node->flag & SELECT; const bool is_select = node->flag & SELECT;
const bool is_inside = (BLI_rcti_isect_pt_v(&rect, node_cent) && const bool is_inside = (BLI_rcti_isect_pt_v(&rect, node_cent) &&
BLI_lasso_is_point_inside(mcords, moves, node_cent[0], node_cent[1])); BLI_lasso_is_point_inside(mcoords, mcoords_len, node_cent[0], node_cent[1]));
const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside); const int sel_op_result = ED_select_op_action_deselected(sel_op, is_select, is_inside);
if (sel_op_result != -1) { if (sel_op_result != -1) {
SET_FLAG_FROM_TEST(node->flag, sel_op_result, SELECT); SET_FLAG_FROM_TEST(node->flag, sel_op_result, SELECT);
@@ -1257,8 +1276,11 @@ static void do_lasso_select_node(int mcords[][2], short moves, const eSelectOp s
} }
#endif #endif
static bool view3d_lasso_select( static bool view3d_lasso_select(bContext *C,
bContext *C, ViewContext *vc, const int mcords[][2], short moves, const eSelectOp sel_op) ViewContext *vc,
const int mcoords[][2],
short mcoords_len,
const eSelectOp sel_op)
{ {
Object *ob = CTX_data_active_object(C); Object *ob = CTX_data_active_object(C);
bool changed_multi = false; bool changed_multi = false;
@@ -1268,26 +1290,26 @@ static bool view3d_lasso_select(
if (vc->obedit == NULL) { /* Object Mode */ if (vc->obedit == NULL) { /* Object Mode */
if (BKE_paint_select_face_test(ob)) { if (BKE_paint_select_face_test(ob)) {
changed_multi |= do_lasso_select_paintface(vc, wm_userdata, mcords, moves, sel_op); changed_multi |= do_lasso_select_paintface(vc, wm_userdata, mcoords, mcoords_len, sel_op);
} }
else if (BKE_paint_select_vert_test(ob)) { else if (BKE_paint_select_vert_test(ob)) {
changed_multi |= do_lasso_select_paintvert(vc, wm_userdata, mcords, moves, sel_op); changed_multi |= do_lasso_select_paintvert(vc, wm_userdata, mcoords, mcoords_len, sel_op);
} }
else if (ob && else if (ob &&
(ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT))) { (ob->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT))) {
/* pass */ /* pass */
} }
else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT)) { else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
changed_multi |= PE_lasso_select(C, mcords, moves, sel_op); changed_multi |= PE_lasso_select(C, mcoords, mcoords_len, sel_op);
} }
else if (ob && (ob->mode & OB_MODE_POSE)) { else if (ob && (ob->mode & OB_MODE_POSE)) {
changed_multi |= do_lasso_select_pose(vc, mcords, moves, sel_op); changed_multi |= do_lasso_select_pose(vc, mcoords, mcoords_len, sel_op);
if (changed_multi) { if (changed_multi) {
ED_outliner_select_sync_from_pose_bone_tag(C); ED_outliner_select_sync_from_pose_bone_tag(C);
} }
} }
else { else {
changed_multi |= do_lasso_select_objects(vc, mcords, moves, sel_op); changed_multi |= do_lasso_select_objects(vc, mcoords, mcoords_len, sel_op);
if (changed_multi) { if (changed_multi) {
ED_outliner_select_sync_from_object_tag(C); ED_outliner_select_sync_from_object_tag(C);
} }
@@ -1300,23 +1322,23 @@ static bool view3d_lasso_select(
switch (vc->obedit->type) { switch (vc->obedit->type) {
case OB_MESH: case OB_MESH:
changed = do_lasso_select_mesh(vc, wm_userdata, mcords, moves, sel_op); changed = do_lasso_select_mesh(vc, wm_userdata, mcoords, mcoords_len, sel_op);
break; break;
case OB_CURVE: case OB_CURVE:
case OB_SURF: case OB_SURF:
changed = do_lasso_select_curve(vc, mcords, moves, sel_op); changed = do_lasso_select_curve(vc, mcoords, mcoords_len, sel_op);
break; break;
case OB_LATTICE: case OB_LATTICE:
changed = do_lasso_select_lattice(vc, mcords, moves, sel_op); changed = do_lasso_select_lattice(vc, mcoords, mcoords_len, sel_op);
break; break;
case OB_ARMATURE: case OB_ARMATURE:
changed = do_lasso_select_armature(vc, mcords, moves, sel_op); changed = do_lasso_select_armature(vc, mcoords, mcoords_len, sel_op);
if (changed) { if (changed) {
ED_outliner_select_sync_from_edit_bone_tag(C); ED_outliner_select_sync_from_edit_bone_tag(C);
} }
break; break;
case OB_MBALL: case OB_MBALL:
changed = do_lasso_select_meta(vc, mcords, moves, sel_op); changed = do_lasso_select_meta(vc, mcoords, mcoords_len, sel_op);
break; break;
default: default:
BLI_assert(!"lasso select on incorrect object type"); BLI_assert(!"lasso select on incorrect object type");
@@ -1342,10 +1364,10 @@ static bool view3d_lasso_select(
static int view3d_lasso_select_exec(bContext *C, wmOperator *op) static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
{ {
ViewContext vc; ViewContext vc;
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C); Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
view3d_operator_needs_opengl(C); view3d_operator_needs_opengl(C);
BKE_object_update_select_id(CTX_data_main(C)); BKE_object_update_select_id(CTX_data_main(C));
@@ -1354,9 +1376,9 @@ static int view3d_lasso_select_exec(bContext *C, wmOperator *op)
ED_view3d_viewcontext_init(C, &vc, depsgraph); ED_view3d_viewcontext_init(C, &vc, depsgraph);
eSelectOp sel_op = RNA_enum_get(op->ptr, "mode"); eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
bool changed_multi = view3d_lasso_select(C, &vc, mcords, mcords_tot, sel_op); bool changed_multi = view3d_lasso_select(C, &vc, mcoords, mcoords_len, sel_op);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
if (changed_multi) { if (changed_multi) {
return OPERATOR_FINISHED; return OPERATOR_FINISHED;

26
source/blender/editors/uvedit/uvedit_select.c
View File

@@ -2914,8 +2914,8 @@ static bool do_lasso_select_mesh_uv_is_point_inside(const ARegion *region,
} }
static bool do_lasso_select_mesh_uv(bContext *C, static bool do_lasso_select_mesh_uv(bContext *C,
const int mcords[][2], const int mcoords[][2],
short moves, short mcoords_len,
const eSelectOp sel_op) const eSelectOp sel_op)
{ {
Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C); Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
@@ -2945,7 +2945,7 @@ static bool do_lasso_select_mesh_uv(bContext *C,
uv_select_island_limit_default(sima, limit); uv_select_island_limit_default(sima, limit);
BLI_lasso_boundbox(&rect, mcords, moves); BLI_lasso_boundbox(&rect, mcoords, mcoords_len);
uint objects_len = 0; uint objects_len = 0;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs( Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
@@ -2972,7 +2972,7 @@ static bool do_lasso_select_mesh_uv(bContext *C,
if (select != uvedit_face_select_test(scene, efa, cd_loop_uv_offset)) { if (select != uvedit_face_select_test(scene, efa, cd_loop_uv_offset)) {
float cent[2]; float cent[2];
uv_poly_center(efa, cent, cd_loop_uv_offset); uv_poly_center(efa, cent, cd_loop_uv_offset);
if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, cent)) { if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcoords, mcoords_len, cent)) {
BM_elem_flag_enable(efa, BM_ELEM_TAG); BM_elem_flag_enable(efa, BM_ELEM_TAG);
changed = true; changed = true;
} }
@@ -3000,9 +3000,10 @@ static bool do_lasso_select_mesh_uv(bContext *C,
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset); MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
const bool luv_select = uvedit_uv_select_test(scene, l, cd_loop_uv_offset); const bool luv_select = uvedit_uv_select_test(scene, l, cd_loop_uv_offset);
if ((select != luv_select) || (select != luv_select_prev)) { if ((select != luv_select) || (select != luv_select_prev)) {
if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, luv->uv) && if (do_lasso_select_mesh_uv_is_point_inside(
region, &rect, mcoords, mcoords_len, luv->uv) &&
do_lasso_select_mesh_uv_is_point_inside( do_lasso_select_mesh_uv_is_point_inside(
region, &rect, mcords, moves, luv_prev->uv)) { region, &rect, mcoords, mcoords_len, luv_prev->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset); uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
uvedit_uv_select_set(em, scene, l_prev, select, false, cd_loop_uv_offset); uvedit_uv_select_set(em, scene, l_prev, select, false, cd_loop_uv_offset);
changed = true; changed = true;
@@ -3031,7 +3032,8 @@ static bool do_lasso_select_mesh_uv(bContext *C,
BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) { BM_ITER_ELEM (l, &liter, efa, BM_LOOPS_OF_FACE) {
if ((select) != (uvedit_uv_select_test(scene, l, cd_loop_uv_offset))) { if ((select) != (uvedit_uv_select_test(scene, l, cd_loop_uv_offset))) {
MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset); MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset);
if (do_lasso_select_mesh_uv_is_point_inside(region, &rect, mcords, moves, luv->uv)) { if (do_lasso_select_mesh_uv_is_point_inside(
region, &rect, mcoords, mcoords_len, luv->uv)) {
uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset); uvedit_uv_select_set(em, scene, l, select, false, cd_loop_uv_offset);
changed = true; changed = true;
BM_elem_flag_enable(l->v, BM_ELEM_TAG); BM_elem_flag_enable(l->v, BM_ELEM_TAG);
@@ -3068,13 +3070,13 @@ static bool do_lasso_select_mesh_uv(bContext *C,
static int uv_lasso_select_exec(bContext *C, wmOperator *op) static int uv_lasso_select_exec(bContext *C, wmOperator *op)
{ {
int mcords_tot; int mcoords_len;
const int(*mcords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcords_tot); const int(*mcoords)[2] = WM_gesture_lasso_path_to_array(C, op, &mcoords_len);
if (mcords) { if (mcoords) {
const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode"); const eSelectOp sel_op = RNA_enum_get(op->ptr, "mode");
bool changed = do_lasso_select_mesh_uv(C, mcords, mcords_tot, sel_op); bool changed = do_lasso_select_mesh_uv(C, mcoords, mcoords_len, sel_op);
MEM_freeN((void *)mcords); MEM_freeN((void *)mcoords);
return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED; return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
} }

2
source/blender/windowmanager/WM_api.h
View File

@@ -617,7 +617,7 @@ int WM_gesture_lasso_modal(struct bContext *C, struct wmOperator *op, const stru
void WM_gesture_lasso_cancel(struct bContext *C, struct wmOperator *op); void WM_gesture_lasso_cancel(struct bContext *C, struct wmOperator *op);
const int (*WM_gesture_lasso_path_to_array(struct bContext *C, const int (*WM_gesture_lasso_path_to_array(struct bContext *C,
struct wmOperator *op, struct wmOperator *op,
int *mcords_tot))[2]; int *mcoords_len))[2];
int WM_gesture_straightline_invoke(struct bContext *C, int WM_gesture_straightline_invoke(struct bContext *C,
struct wmOperator *op, struct wmOperator *op,
const struct wmEvent *event); const struct wmEvent *event);

20
source/blender/windowmanager/intern/wm_gesture.c
View File

@@ -320,24 +320,24 @@ static void draw_filled_lasso_px_cb(int x, int x_end, int y, void *user_data)
static void draw_filled_lasso(wmGesture *gt) static void draw_filled_lasso(wmGesture *gt)
{ {
const short *lasso = (short *)gt->customdata; const short *lasso = (short *)gt->customdata;
const int tot = gt->points; const int mcoords_len = gt->points;
int(*moves)[2] = MEM_mallocN(sizeof(*moves) * (tot + 1), __func__); int(*mcoords)[2] = MEM_mallocN(sizeof(*mcoords) * (mcoords_len + 1), __func__);
int i; int i;
rcti rect; rcti rect;
float red[4] = {1.0f, 0.0f, 0.0f, 0.0f}; float red[4] = {1.0f, 0.0f, 0.0f, 0.0f};
for (i = 0; i < tot; i++, lasso += 2) { for (i = 0; i < mcoords_len; i++, lasso += 2) {
moves[i][0] = lasso[0]; mcoords[i][0] = lasso[0];
moves[i][1] = lasso[1]; mcoords[i][1] = lasso[1];
} }
BLI_lasso_boundbox(&rect, (const int(*)[2])moves, tot); BLI_lasso_boundbox(&rect, (const int(*)[2])mcoords, mcoords_len);
BLI_rcti_translate(&rect, gt->winrct.xmin, gt->winrct.ymin); BLI_rcti_translate(&rect, gt->winrct.xmin, gt->winrct.ymin);
BLI_rcti_isect(&gt->winrct, &rect, &rect); BLI_rcti_isect(&gt->winrct, &rect, &rect);
BLI_rcti_translate(&rect, -gt->winrct.xmin, -gt->winrct.ymin); BLI_rcti_translate(&rect, -gt->winrct.xmin, -gt->winrct.ymin);
/* highly unlikely this will fail, but could crash if (tot == 0) */ /* Highly unlikely this will fail, but could crash if (mcoords_len == 0). */
if (BLI_rcti_is_empty(&rect) == false) { if (BLI_rcti_is_empty(&rect) == false) {
const int w = BLI_rcti_size_x(&rect); const int w = BLI_rcti_size_x(&rect);
const int h = BLI_rcti_size_y(&rect); const int h = BLI_rcti_size_y(&rect);
@@ -348,8 +348,8 @@ static void draw_filled_lasso(wmGesture *gt)
rect.ymin, rect.ymin,
rect.xmax, rect.xmax,
rect.ymax, rect.ymax,
(const int(*)[2])moves, (const int(*)[2])mcoords,
tot, mcoords_len,
draw_filled_lasso_px_cb, draw_filled_lasso_px_cb,
&lasso_fill_data); &lasso_fill_data);
@@ -390,7 +390,7 @@ static void draw_filled_lasso(wmGesture *gt)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
} }
MEM_freeN(moves); MEM_freeN(mcoords);
} }
static void wm_gesture_draw_lasso(wmGesture *gt, bool filled) static void wm_gesture_draw_lasso(wmGesture *gt, bool filled)

16
source/blender/windowmanager/intern/wm_gesture_ops.c
View File

@@ -718,10 +718,10 @@ void WM_gesture_lines_cancel(bContext *C, wmOperator *op)
*/ */
const int (*WM_gesture_lasso_path_to_array(bContext *UNUSED(C), const int (*WM_gesture_lasso_path_to_array(bContext *UNUSED(C),
wmOperator *op, wmOperator *op,
int *mcords_tot))[2] int *r_mcoords_len))[2]
{ {
PropertyRNA *prop = RNA_struct_find_property(op->ptr, "path"); PropertyRNA *prop = RNA_struct_find_property(op->ptr, "path");
int(*mcords)[2] = NULL; int(*mcoords)[2] = NULL;
BLI_assert(prop != NULL); BLI_assert(prop != NULL);
if (prop) { if (prop) {
@@ -729,26 +729,26 @@ const int (*WM_gesture_lasso_path_to_array(bContext *UNUSED(C),
if (len) { if (len) {
int i = 0; int i = 0;
mcords = MEM_mallocN(sizeof(int) * 2 * len, __func__); mcoords = MEM_mallocN(sizeof(int[2]) * len, __func__);
RNA_PROP_BEGIN (op->ptr, itemptr, prop) { RNA_PROP_BEGIN (op->ptr, itemptr, prop) {
float loc[2]; float loc[2];
RNA_float_get_array(&itemptr, "loc", loc); RNA_float_get_array(&itemptr, "loc", loc);
mcords[i][0] = (int)loc[0]; mcoords[i][0] = (int)loc[0];
mcords[i][1] = (int)loc[1]; mcoords[i][1] = (int)loc[1];
i++; i++;
} }
RNA_PROP_END; RNA_PROP_END;
} }
*mcords_tot = len; *r_mcoords_len = len;
} }
else { else {
*mcords_tot = 0; *r_mcoords_len = 0;
} }
/* cast for 'const' */ /* cast for 'const' */
return (const int(*)[2])mcords; return mcoords;
} }
#if 0 #if 0