Blender V5.3
view3d_gizmo_preselect_type.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
14
15#include "DNA_mesh_types.h"
16#include "DNA_view3d_types.h"
17
18#include "BKE_context.hh"
19#include "BKE_editmesh.hh"
20#include "BKE_global.hh"
21#include "BKE_layer.hh"
22#include "BKE_mesh.hh"
23#include "BKE_mesh_wrapper.hh"
24#include "BKE_object.hh"
25
26#include "BLI_math_matrix_c.hh"
27#include "BLI_math_vector_c.hh"
28
29#include "DEG_depsgraph.hh"
31
32#include "RNA_access.hh"
33#include "RNA_define.hh"
34
35#include "WM_api.hh"
36#include "WM_toolsystem.hh"
37#include "WM_types.hh"
38
39#include "bmesh.hh"
40
41#include "ED_gizmo_library.hh"
42#include "ED_mesh.hh"
43#include "ED_screen.hh"
44#include "ED_view3d.hh"
45
46namespace blender {
47
48/* -------------------------------------------------------------------- */
51
68{
69 if (G.moving == false) {
71 if (!(rv3d && (rv3d->rflag & RV3D_NAVIGATING))) {
72 return true;
73 }
74 }
76 return false;
77}
78
80
81/* -------------------------------------------------------------------- */
84
94
96{
98 return;
99 }
100
101 MeshElemGizmo3D *gz_ele = reinterpret_cast<MeshElemGizmo3D *>(gz);
102 if (gz_ele->base_index != -1) {
103 Object *ob = gz_ele->bases[gz_ele->base_index]->object;
104 EDBM_preselect_elem_draw(gz_ele->psel, ob->object_to_world().ptr());
105 }
106}
107
108static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int mval[2])
109{
111 MeshElemGizmo3D *gz_ele = reinterpret_cast<MeshElemGizmo3D *>(gz);
112
113 /* Hack: Switch action mode based on key input */
114 const bool is_ctrl_pressed = (event->modifier & KM_CTRL) != 0;
115 const bool is_shift_pressed = (event->modifier & KM_SHIFT) != 0;
117 if (is_ctrl_pressed && !is_shift_pressed) {
119 }
120 if (!is_ctrl_pressed && is_shift_pressed) {
122 }
123
124 struct Best {
125 Object *ob;
126 BMElem *ele;
127 float dist;
128 int base_index;
129 } best{};
130 best.dist = ED_view3d_select_dist_px();
131
132 {
133 const Main *bmain = CTX_data_main(C);
134 const Scene *scene = CTX_data_scene(C);
135 ViewLayer *view_layer = CTX_data_view_layer(C);
136 View3D *v3d = CTX_wm_view3d(C);
137 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
138 if (gz_ele->bases.is_empty() ||
139 (gz_ele->bases[0] != BKE_view_layer_active_base_get(view_layer)))
140 {
141 gz_ele->bases = BKE_view_layer_array_from_bases_in_edit_mode(*bmain, scene, view_layer, v3d);
142 }
143 }
144
146 copy_v2_v2_int(vc.mval, mval);
147
148 {
149 /* TODO: support faces. */
150 int base_index_vert = -1;
151 int base_index_edge = -1;
152 int base_index_face = -1;
153 BMVert *eve_test;
154 BMEdge *eed_test;
155 BMFace *efa_test;
156
158 gz_ele->bases,
159 false,
160 true,
161 &base_index_vert,
162 &base_index_edge,
163 &base_index_face,
164 &eve_test,
165 &eed_test,
166 &efa_test))
167 {
169 /* Delete action */
170 if (efa_test) {
171 best.ele = reinterpret_cast<BMElem *>(efa_test);
172 best.base_index = base_index_face;
173 }
174 }
175
176 else {
177 /* Transform and create action */
178 if (eed_test) {
179 best.ele = reinterpret_cast<BMElem *>(eed_test);
180 best.base_index = base_index_edge;
181 }
182 }
183
184 /* All actions use same vertex pre-selection. */
185 /* Re-topology should always prioritize edge pre-selection.
186 * Only pre-select a vertex when the cursor is really close to it. */
187 if (eve_test) {
188 BMVert *vert = eve_test;
189 float vert_p_co[2], vert_co[3];
190 const float mval_f[2] = {float(vc.mval[0]), float(vc.mval[1])};
192 vert_co, gz_ele->bases[base_index_vert]->object->object_to_world().ptr(), vert->co);
193 ED_view3d_project_v2(vc.region, vert_co, vert_p_co);
194 float len = len_v2v2(vert_p_co, mval_f);
195 if (len < 35) {
196 best.ele = reinterpret_cast<BMElem *>(eve_test);
197 best.base_index = base_index_vert;
198 }
199 if (!BM_vert_is_boundary(vert) &&
201 {
202 best.ele = reinterpret_cast<BMElem *>(eve_test);
203 best.base_index = base_index_vert;
204 }
205 }
206
207 /* Check above should never fail, if it does it's an internal error. */
208 BLI_assert(best.base_index != -1);
209
210 Base *base = gz_ele->bases[best.base_index];
211 best.ob = base->object;
212 }
213 }
214
215 BMesh *bm = nullptr;
216
217 gz_ele->base_index = -1;
218 gz_ele->vert_index = -1;
219 gz_ele->edge_index = -1;
220 gz_ele->face_index = -1;
221
222 if (best.ele) {
223 gz_ele->base_index = best.base_index;
224 bm = BKE_editmesh_bmesh_get_for_write(gz_ele->bases[gz_ele->base_index]->object);
225 BM_mesh_elem_index_ensure(bm, best.ele->head.htype);
226
227 if (best.ele->head.htype == BM_VERT) {
228 gz_ele->vert_index = BM_elem_index_get(best.ele);
229 }
230 else if (best.ele->head.htype == BM_EDGE) {
231 gz_ele->edge_index = BM_elem_index_get(best.ele);
232 }
233 else if (best.ele->head.htype == BM_FACE) {
234 gz_ele->face_index = BM_elem_index_get(best.ele);
235 }
236 }
237
238 if (best.ele) {
239 Span<float3> vert_positions;
240 {
241 Object *ob = gz_ele->bases[gz_ele->base_index]->object;
242 const Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
243 const Object *ob_eval = DEG_get_evaluated(depsgraph, ob);
244 const Mesh *mesh_eval = BKE_object_get_editmesh_eval_cage(ob_eval);
245 if (BKE_mesh_wrapper_vert_len(mesh_eval) == bm->totvert) {
246 vert_positions = BKE_mesh_wrapper_vert_coords(mesh_eval);
247 }
248 }
249 EDBM_preselect_elem_update_from_single(gz_ele->psel, bm, best.ele, vert_positions);
250 EDBM_preselect_elem_update_preview(gz_ele->psel, &vc, bm, best.ele, mval);
251 }
252 else {
255 }
256
257 RNA_int_set(gz->ptr, "object_index", gz_ele->base_index);
258 RNA_int_set(gz->ptr, "vert_index", gz_ele->vert_index);
259 RNA_int_set(gz->ptr, "edge_index", gz_ele->edge_index);
260 RNA_int_set(gz->ptr, "face_index", gz_ele->face_index);
261
262 if (best.ele) {
263 ARegion *region = CTX_wm_region(C);
265 }
266
267 return best.ele ? 0 : -1;
268}
269
271{
272 /* Needed so it's possible to "highlight" the gizmo without having the
273 * tweak operator attempting to handle it's input. */
275
276 MeshElemGizmo3D *gz_ele = reinterpret_cast<MeshElemGizmo3D *>(gz);
277 if (gz_ele->psel == nullptr) {
279 }
280 gz_ele->base_index = -1;
281 new (&gz_ele->bases) Vector<Base *>();
282}
283
285{
286 MeshElemGizmo3D *gz_ele = reinterpret_cast<MeshElemGizmo3D *>(gz);
288 gz_ele->psel = nullptr;
289 gz_ele->bases.~Vector();
290}
291
293 wmGizmo * /*gz*/,
294 const wmEvent * /*event*/)
295{
297}
298
300{
301 /* identifiers */
302 gzt->idname = "GIZMO_GT_mesh_preselect_elem_3d";
303
304 /* API callbacks. */
310
311 gzt->struct_size = sizeof(MeshElemGizmo3D);
312
313 RNA_def_int(gzt->srna, "object_index", -1, -1, INT_MAX, "Object Index", "", -1, INT_MAX);
314 RNA_def_int(gzt->srna, "vert_index", -1, -1, INT_MAX, "Vert Index", "", -1, INT_MAX);
315 RNA_def_int(gzt->srna, "edge_index", -1, -1, INT_MAX, "Edge Index", "", -1, INT_MAX);
316 RNA_def_int(gzt->srna, "face_index", -1, -1, INT_MAX, "Face Index", "", -1, INT_MAX);
317}
318
320
321/* -------------------------------------------------------------------- */
324
332
334{
336 return;
337 }
338
339 MeshEdgeRingGizmo3D *gz_ring = reinterpret_cast<MeshEdgeRingGizmo3D *>(gz);
340 if (gz_ring->base_index != -1) {
341 Object *ob = gz_ring->bases[gz_ring->base_index]->object;
342 EDBM_preselect_edgering_draw(gz_ring->psel, ob->object_to_world().ptr());
343 }
344}
345
347{
348 const int default_cuts = 1;
349
351 if (tref == nullptr) {
352 return default_cuts;
353 }
354
355 wmOperatorType *ot_slide = WM_operatortype_find("MESH_OT_loopcut_slide", false);
356 if (ot_slide == nullptr) {
357 return default_cuts;
358 }
359
360 PointerRNA tool_props;
361 if (!WM_toolsystem_ref_properties_get_from_operator(tref, ot_slide, &tool_props)) {
362 return default_cuts;
363 }
364
365 PointerRNA loopcut_ptr = RNA_pointer_get(&tool_props, "MESH_OT_loopcut");
366 if (!loopcut_ptr) {
367 return default_cuts;
368 }
369
370 return RNA_int_get(&loopcut_ptr, "number_cuts");
371}
372
373static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const int mval[2])
374{
375 MeshEdgeRingGizmo3D *gz_ring = reinterpret_cast<MeshEdgeRingGizmo3D *>(gz);
376 struct Best {
377 Object *ob;
378 BMEdge *eed;
379 float dist;
380 int base_index;
381 } best{};
382 best.dist = ED_view3d_select_dist_px();
383
384 struct Prev {
385 int base_index;
386 int edge_index;
387 } prev{};
388 prev.base_index = gz_ring->base_index;
389 prev.edge_index = gz_ring->edge_index;
390
391 {
392 const Main *bmain = CTX_data_main(C);
393 const Scene *scene = CTX_data_scene(C);
394 ViewLayer *view_layer = CTX_data_view_layer(C);
395 View3D *v3d = CTX_wm_view3d(C);
396 BKE_view_layer_synced_ensure(*bmain, scene, view_layer);
397 if (gz_ring->bases.is_empty() ||
398 (gz_ring->bases[0] != BKE_view_layer_active_base_get(view_layer)))
399 {
401 *bmain, scene, view_layer, v3d);
402 }
403 }
404
406 copy_v2_v2_int(vc.mval, mval);
407
408 uint base_index;
410 &vc, &best.dist, nullptr, false, false, nullptr, gz_ring->bases, &base_index);
411
412 if (eed_test) {
413 best.ob = gz_ring->bases[base_index]->object;
414 best.eed = eed_test;
415 best.base_index = base_index;
416 }
417
418 BMesh *bm = nullptr;
419 if (best.eed) {
420 gz_ring->base_index = best.base_index;
421 bm = BKE_editmesh_bmesh_get_for_write(gz_ring->bases[gz_ring->base_index]->object);
423 gz_ring->edge_index = BM_elem_index_get(best.eed);
424 }
425 else {
426 gz_ring->base_index = -1;
427 gz_ring->edge_index = -1;
428 }
429
430 if ((prev.base_index == gz_ring->base_index) && (prev.edge_index == gz_ring->edge_index)) {
431 /* pass (only recalculate on change) */
432 }
433 else {
434 if (best.eed) {
435 Object *ob = gz_ring->bases[gz_ring->base_index]->object;
436 Scene *scene_eval = DEG_get_evaluated(vc.depsgraph, vc.scene);
437 Object *ob_eval = DEG_get_evaluated(vc.depsgraph, ob);
438 /* Re-allocate coords each update isn't ideal, however we can't be sure
439 * the mesh hasn't been edited since last update. */
442 vc.depsgraph, scene_eval, ob_eval, storage);
443 const int preview_cuts = loopcut_tool_preview_cuts_from_toolsettings(C);
445 gz_ring->psel, bm, best.eed, preview_cuts, vert_positions);
446 }
447 else {
449 }
450
451 RNA_int_set(gz->ptr, "object_index", gz_ring->base_index);
452 RNA_int_set(gz->ptr, "edge_index", gz_ring->edge_index);
453
454 ARegion *region = CTX_wm_region(C);
456 }
457
458 return best.eed ? 0 : -1;
459}
460
462{
463 /* Needed so it's possible to "highlight" the gizmo without having the
464 * tweak operator attempting to handle it's input. */
466
467 MeshEdgeRingGizmo3D *gz_ring = reinterpret_cast<MeshEdgeRingGizmo3D *>(gz);
468 if (gz_ring->psel == nullptr) {
470 }
471 gz_ring->base_index = -1;
472 new (&gz_ring->bases) Vector<Base *>();
473}
474
476{
477 MeshEdgeRingGizmo3D *gz_ring = reinterpret_cast<MeshEdgeRingGizmo3D *>(gz);
479 gz_ring->psel = nullptr;
480 gz_ring->bases.~Vector();
481}
482
484 wmGizmo * /*gz*/,
485 const wmEvent * /*event*/)
486{
488}
489
491{
492 /* identifiers */
493 gzt->idname = "GIZMO_GT_mesh_preselect_edgering_3d";
494
495 /* API callbacks. */
501
502 gzt->struct_size = sizeof(MeshEdgeRingGizmo3D);
503
504 RNA_def_int(gzt->srna, "object_index", -1, -1, INT_MAX, "Object Index", "", -1, INT_MAX);
505 RNA_def_int(gzt->srna, "edge_index", -1, -1, INT_MAX, "Edge Index", "", -1, INT_MAX);
506}
507
509
510/* -------------------------------------------------------------------- */
513
519
521
522/* -------------------------------------------------------------------- */
528
530 const wmGizmo *gz,
531 Base **r_base,
532 BMElem **r_ele)
533{
534 const Main *bmain = CTX_data_main(C);
535 const Scene *scene = CTX_data_scene(C);
536 ViewLayer *view_layer = CTX_data_view_layer(C);
537
538 const int object_index = RNA_int_get(gz->ptr, "object_index");
539
540 /* weak, allocate an array just to access the index. */
541 Base *base = nullptr;
542 Object *obedit = nullptr;
543 if (object_index != -1) {
545 *bmain, scene, view_layer, CTX_wm_view3d(C));
546 if (object_index < bases.size()) {
547 base = bases[object_index];
548 obedit = base->object;
549 }
550 }
551
552 *r_base = base;
553 *r_ele = nullptr;
554
555 if (obedit) {
557 PropertyRNA *prop;
558
559 /* Ring select only defines edge, check properties exist first. */
560 prop = RNA_struct_find_property(gz->ptr, "vert_index");
561 const int vert_index = prop ? RNA_property_int_get(gz->ptr, prop) : -1;
562 prop = RNA_struct_find_property(gz->ptr, "edge_index");
563 const int edge_index = prop ? RNA_property_int_get(gz->ptr, prop) : -1;
564 prop = RNA_struct_find_property(gz->ptr, "face_index");
565 const int face_index = prop ? RNA_property_int_get(gz->ptr, prop) : -1;
566
567 if (vert_index != -1) {
568 *r_ele = reinterpret_cast<BMElem *>(BM_vert_at_index_find(bm, vert_index));
569 }
570 else if (edge_index != -1) {
571 *r_ele = reinterpret_cast<BMElem *>(BM_edge_at_index_find(bm, edge_index));
572 }
573 else if (face_index != -1) {
574 *r_ele = reinterpret_cast<BMElem *>(BM_face_at_index_find(bm, face_index));
575 }
576 }
577}
578
580{
581 if (STREQ(gz->type->idname, "GIZMO_GT_mesh_preselect_elem_3d")) {
582 MeshElemGizmo3D *gz_ele = reinterpret_cast<MeshElemGizmo3D *>(gz);
583 gz_ele->base_index = -1;
584 gz_ele->vert_index = -1;
585 gz_ele->edge_index = -1;
586 gz_ele->face_index = -1;
587 }
588 else if (STREQ(gz->type->idname, "GIZMO_GT_mesh_preselect_edgering_3d")) {
589 MeshEdgeRingGizmo3D *gz_ele = reinterpret_cast<MeshEdgeRingGizmo3D *>(gz);
590 gz_ele->base_index = -1;
591 gz_ele->edge_index = -1;
592 }
593 else {
595 }
596
597 const char *prop_ids[] = {"object_index", "vert_index", "edge_index", "face_index"};
598 for (int i = 0; i < ARRAY_SIZE(prop_ids); i++) {
599 PropertyRNA *prop = RNA_struct_find_property(gz->ptr, prop_ids[i]);
600 if (prop == nullptr) {
601 continue;
602 }
603 RNA_property_int_set(gz->ptr, prop, -1);
604 }
605}
606
608
609} // namespace blender
General operations, lookup, etc. for blender objects.
#define C
Definition RandGen.cpp:29
#define WM_toolsystem_ref_properties_get_from_operator(tref, ot, r_ptr)
#define BLI_assert_unreachable()
#define STREQ(a, b)
#define BM_elem_index_get(ele)
int64_t size() const
#define INT_MAX
#define storage(slot, qualifiers)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
const Mesh * BKE_object_get_editmesh_eval_cage(const Object *object)
Definition object.cc:4492
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
BMFace * BM_face_at_index_find(BMesh *bm, const int index)
EditMesh_PreSelEdgeRing * EDBM_preselect_edgering_create()
MINLINE void copy_v2_v2_int(int r[2], const int a[2])
static void gizmo_preselect_edgering_setup(wmGizmo *gz)
static void gizmo_preselect_elem_draw(const bContext *C, wmGizmo *gz)
static void GIZMO_GT_mesh_preselect_edgering_3d(wmGizmoType *gzt)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void ED_view3d_gizmo_mesh_preselect_get_active(const bContext *C, const wmGizmo *gz, Base **r_base, BMElem **r_ele)
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
static void gizmo_preselect_edgering_draw(const bContext *C, wmGizmo *gz)
Span< float3 > BKE_editmesh_vert_coords_when_deformed(Depsgraph *depsgraph, Scene *scene, Object *obedit, Array< float3 > &r_alloc)
Definition editmesh.cc:214
unsigned int uint
Definition BKE_text.h:55
EditMesh_PreSelElem * EDBM_preselect_elem_create()
void WM_gizmotype_append(void(*gtfunc)(wmGizmoType *))
@ PRESELECT_ACTION_CREATE
Definition ED_mesh.hh:419
@ PRESELECT_ACTION_TRANSFORM
Definition ED_mesh.hh:418
@ PRESELECT_ACTION_DELETE
Definition ED_mesh.hh:420
void EDBM_preselect_elem_update_from_single(EditMesh_PreSelElem *psel, BMesh *bm, BMElem *ele, Span< float3 > vert_positions)
void mul_v3_m4v3(float r[3], const float mat[4][4], const float vec[3])
static void gizmo_preselect_elem_free(wmGizmo *gz)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
static void gizmo_preselect_edgering_free(wmGizmo *gz)
static void gizmo_preselect_elem_setup(wmGizmo *gz)
static wmOperatorStatus gizmo_preselect_elem_invoke(bContext *, wmGizmo *, const wmEvent *)
int RNA_int_get(PointerRNA *ptr, const char *name)
wmWindow * CTX_wm_window(const bContext *C)
Base * BKE_view_layer_active_base_get(ViewLayer *view_layer)
void ED_view3d_project_v2(const ARegion *region, const float world[3], float r_region_co[2])
void ED_region_tag_redraw_editor_overlays(ARegion *region)
Definition area.cc:745
bool BM_vert_is_boundary(const BMVert *v)
void EDBM_preselect_edgering_update_from_edge(EditMesh_PreSelEdgeRing *psel, BMesh *bm, BMEdge *eed_start, int previewlines, Span< float3 > vert_positions)
ViewLayer * CTX_data_view_layer(const bContext *C)
static bool gizmo_preselect_poll_for_draw(const bContext *C, wmGizmo *gz)
void EDBM_preselect_elem_destroy(EditMesh_PreSelElem *psel)
Global G
Definition blender.cc:57
BMVert * BM_vert_at_index_find(BMesh *bm, const int index)
void RNA_property_int_set(PointerRNA *ptr, PropertyRNA *prop, int value)
void EDBM_preselect_edgering_clear(EditMesh_PreSelEdgeRing *psel)
static int gizmo_preselect_elem_test_select(bContext *C, wmGizmo *gz, const int mval[2])
BMEdge * BM_edge_at_index_find(BMesh *bm, const int index)
static void GIZMO_GT_mesh_preselect_elem_3d(wmGizmoType *gzt)
T * DEG_get_evaluated(const Depsgraph *depsgraph, T *id)
void EDBM_preselect_elem_draw(EditMesh_PreSelElem *psel, const float matrix[4][4])
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
eEditMesh_PreSelPreviewAction EDBM_preselect_action_get(EditMesh_PreSelElem *psel)
static int loopcut_tool_preview_cuts_from_toolsettings(const bContext *C)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
static int gizmo_preselect_edgering_test_select(bContext *C, wmGizmo *gz, const int mval[2])
RegionView3D * CTX_wm_region_view3d(const bContext *C)
int BKE_mesh_wrapper_vert_len(const Mesh *mesh)
void EDBM_preselect_action_set(EditMesh_PreSelElem *psel, eEditMesh_PreSelPreviewAction action)
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
@ WM_GIZMO_HIDDEN_KEYMAP
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
ViewContext em_setup_viewcontext(bContext *C)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, const int default_value, const int hardmin, const int hardmax, const char *ui_name, const char *ui_description, const int softmin, const int softmax)
void EDBM_preselect_elem_update_preview(EditMesh_PreSelElem *psel, ViewContext *vc, BMesh *bm, BMElem *ele, const int mval[2])
void EDBM_preselect_elem_clear(EditMesh_PreSelElem *psel)
Main * CTX_data_main(const bContext *C)
bToolRef * WM_toolsystem_ref_from_context(const bContext *C)
void EDBM_preselect_edgering_destroy(EditMesh_PreSelEdgeRing *psel)
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
BMEdge * EDBM_edge_find_nearest_ex(ViewContext *vc, float *dist_px_manhattan, float *r_dist_center, bool use_select_bias, bool use_cycle, BMEdge **r_eed_zbuf, Span< Base * > bases, uint *r_base_index)
Span< float3 > BKE_mesh_wrapper_vert_coords(const Mesh *mesh)
Scene * CTX_data_scene(const bContext *C)
void EDBM_preselect_edgering_draw(EditMesh_PreSelEdgeRing *psel, const float matrix[4][4])
float ED_view3d_select_dist_px()
Vector< Base * > BKE_view_layer_array_from_bases_in_edit_mode(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const View3D *v3d)
int RNA_property_int_get(PointerRNA *ptr, PropertyRNA *prop)
void EDBM_preselect_preview_clear(EditMesh_PreSelElem *psel)
bool EDBM_unified_findnearest_from_raycast(ViewContext *vc, Span< Base * > bases, bool use_boundary_vertices, bool use_boundary_edges, int *r_base_index_vert, int *r_base_index_edge, int *r_base_index_face, BMVert **r_eve, BMEdge **r_eed, BMFace **r_efa)
static wmOperatorStatus gizmo_preselect_edgering_invoke(bContext *, wmGizmo *, const wmEvent *)
ARegion * CTX_wm_region(const bContext *C)
View3D * CTX_wm_view3d(const bContext *C)
void ED_view3d_gizmo_mesh_preselect_clear(wmGizmo *gz)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Object * object
eRegionView3D_Flag rflag
Depsgraph * depsgraph
Definition ED_view3d.hh:78
wmGizmoFnInvoke invoke
wmGizmoFnTestSelect test_select
const wmGizmoType * type
eWM_GizmoFlag flag
bke::WindowRuntime * runtime