Blender  V3.3
editlattice_select.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2001-2002 NaN Holding BV. All rights reserved. */
3 
8 #include <stdlib.h>
9 
10 #include "MEM_guardedalloc.h"
11 
12 #include "BLI_bitmap.h"
13 #include "BLI_listbase.h"
14 #include "BLI_math.h"
15 #include "BLI_rand.h"
16 #include "BLI_utildefines.h"
17 
18 #include "DNA_curve_types.h"
19 #include "DNA_lattice_types.h"
20 #include "DNA_meshdata_types.h"
21 #include "DNA_object_types.h"
22 #include "DNA_scene_types.h"
23 
24 #include "RNA_access.h"
25 #include "RNA_define.h"
26 #include "RNA_enum_types.h"
27 
28 #include "BKE_context.h"
29 #include "BKE_lattice.h"
30 #include "BKE_layer.h"
31 #include "BKE_report.h"
32 
33 #include "ED_lattice.h"
34 #include "ED_object.h"
35 #include "ED_screen.h"
36 #include "ED_select_utils.h"
37 #include "ED_view3d.h"
38 
39 #include "WM_api.h"
40 #include "WM_types.h"
41 
42 #include "DEG_depsgraph.h"
43 
44 #include "lattice_intern.h"
45 
46 /* -------------------------------------------------------------------- */
50 static void bpoint_select_set(BPoint *bp, bool select)
51 {
52  if (select) {
53  if (!bp->hide) {
54  bp->f1 |= SELECT;
55  }
56  }
57  else {
58  bp->f1 &= ~SELECT;
59  }
60 }
61 
62 bool ED_lattice_deselect_all_multi_ex(struct Base **bases, const uint bases_len)
63 {
64  bool changed_multi = false;
65  for (uint base_index = 0; base_index < bases_len; base_index++) {
66  Base *base_iter = bases[base_index];
67  Object *ob_iter = base_iter->object;
68  changed_multi |= ED_lattice_flags_set(ob_iter, 0);
70  }
71  return changed_multi;
72 }
73 
75 {
77  ViewContext vc;
79  uint bases_len = 0;
81  vc.view_layer, vc.v3d, &bases_len);
82  bool changed_multi = ED_lattice_deselect_all_multi_ex(bases, bases_len);
83  MEM_freeN(bases);
84  return changed_multi;
85 }
86 
89 /* -------------------------------------------------------------------- */
94 {
95  const bool select = (RNA_enum_get(op->ptr, "action") == SEL_SELECT);
96  const float randfac = RNA_float_get(op->ptr, "ratio");
98 
99  ViewLayer *view_layer = CTX_data_view_layer(C);
100  uint objects_len = 0;
102  view_layer, CTX_wm_view3d(C), &objects_len);
103  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
104  Object *obedit = objects[ob_index];
105  Lattice *lt = ((Lattice *)obedit->data)->editlatt->latt;
106  int seed_iter = seed;
107 
108  /* This gives a consistent result regardless of object order. */
109  if (ob_index) {
110  seed_iter += BLI_ghashutil_strhash_p(obedit->id.name);
111  }
112 
113  int a = lt->pntsu * lt->pntsv * lt->pntsw;
114  int elem_map_len = 0;
115  BPoint **elem_map = MEM_mallocN(sizeof(*elem_map) * a, __func__);
116  BPoint *bp = lt->def;
117 
118  while (a--) {
119  if (!bp->hide) {
120  elem_map[elem_map_len++] = bp;
121  }
122  bp++;
123  }
124 
125  BLI_array_randomize(elem_map, sizeof(*elem_map), elem_map_len, seed_iter);
126  const int count_select = elem_map_len * randfac;
127  for (int i = 0; i < count_select; i++) {
128  bpoint_select_set(elem_map[i], select);
129  }
130  MEM_freeN(elem_map);
131 
132  if (select == false) {
133  lt->actbp = LT_ACTBP_NONE;
134  }
135 
138  }
139  MEM_freeN(objects);
140 
141  return OPERATOR_FINISHED;
142 }
143 
145 {
146  /* identifiers */
147  ot->name = "Select Random";
148  ot->description = "Randomly select UVW control points";
149  ot->idname = "LATTICE_OT_select_random";
150 
151  /* api callbacks */
154 
155  /* flags */
157 
158  /* props */
160 }
161 
164 /* -------------------------------------------------------------------- */
168 static void ed_lattice_select_mirrored(Lattice *lt, const int axis, const bool extend)
169 {
170  const int tot = lt->pntsu * lt->pntsv * lt->pntsw;
171 
172  bool flip_uvw[3] = {false};
173  flip_uvw[axis] = true;
174 
175  /* we could flip this too */
176  if (!extend) {
177  lt->actbp = LT_ACTBP_NONE;
178  }
179 
180  /* store "original" selection */
181  BLI_bitmap *selpoints = BLI_BITMAP_NEW(tot, __func__);
182  BKE_lattice_bitmap_from_flag(lt, selpoints, SELECT, false, false);
183 
184  /* actual (de)selection */
185  for (int i = 0; i < tot; i++) {
186  const int i_flip = BKE_lattice_index_flip(lt, i, flip_uvw[0], flip_uvw[1], flip_uvw[2]);
187  BPoint *bp = &lt->def[i];
188  if (!bp->hide) {
189  if (BLI_BITMAP_TEST(selpoints, i_flip)) {
190  bp->f1 |= SELECT;
191  }
192  else {
193  if (!extend) {
194  bp->f1 &= ~SELECT;
195  }
196  }
197  }
198  }
199 
200  MEM_freeN(selpoints);
201 }
202 
204 {
205  const int axis_flag = RNA_enum_get(op->ptr, "axis");
206  const bool extend = RNA_boolean_get(op->ptr, "extend");
207 
208  ViewLayer *view_layer = CTX_data_view_layer(C);
209  uint objects_len = 0;
211  view_layer, CTX_wm_view3d(C), &objects_len);
212 
213  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
214  Object *obedit = objects[ob_index];
215  Lattice *lt = ((Lattice *)obedit->data)->editlatt->latt;
216 
217  for (int axis = 0; axis < 3; axis++) {
218  if ((1 << axis) & axis_flag) {
219  ed_lattice_select_mirrored(lt, axis, extend);
220  }
221  }
222 
223  /* TODO: only notify changes. */
226  }
227  MEM_freeN(objects);
228 
229  return OPERATOR_FINISHED;
230 }
231 
233 {
234  /* identifiers */
235  ot->name = "Select Mirror";
236  ot->description = "Select mirrored lattice points";
237  ot->idname = "LATTICE_OT_select_mirror";
238 
239  /* api callbacks */
242 
243  /* flags */
245 
246  /* props */
247  RNA_def_enum_flag(ot->srna, "axis", rna_enum_axis_flag_xyz_items, (1 << 0), "Axis", "");
248 
249  RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
250 }
251 
254 /* -------------------------------------------------------------------- */
259  Lattice *lt, const BLI_bitmap *selpoints, int u, int v, int w, const bool selected)
260 {
261  if ((u < 0 || u >= lt->pntsu) || (v < 0 || v >= lt->pntsv) || (w < 0 || w >= lt->pntsw)) {
262  return false;
263  }
264 
265  int i = BKE_lattice_index_from_uvw(lt, u, v, w);
266  if (lt->def[i].hide == 0) {
267  return (BLI_BITMAP_TEST(selpoints, i) != 0) == selected;
268  }
269  return false;
270 }
271 
272 static int lattice_select_more_less(bContext *C, const bool select)
273 {
274  ViewLayer *view_layer = CTX_data_view_layer(C);
275  uint objects_len;
276  bool changed = false;
277 
279  view_layer, CTX_wm_view3d(C), &objects_len);
280  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
281  Object *obedit = objects[ob_index];
282  Lattice *lt = ((Lattice *)obedit->data)->editlatt->latt;
283  BPoint *bp;
284  const int tot = lt->pntsu * lt->pntsv * lt->pntsw;
285  int u, v, w;
286  BLI_bitmap *selpoints;
287 
288  lt->actbp = LT_ACTBP_NONE;
289 
290  selpoints = BLI_BITMAP_NEW(tot, __func__);
291  BKE_lattice_bitmap_from_flag(lt, selpoints, SELECT, false, false);
292 
293  bp = lt->def;
294  for (w = 0; w < lt->pntsw; w++) {
295  for (v = 0; v < lt->pntsv; v++) {
296  for (u = 0; u < lt->pntsu; u++) {
297  if ((bp->hide == 0) && (((bp->f1 & SELECT) == 0) == select)) {
298  if (lattice_test_bitmap_uvw(lt, selpoints, u + 1, v, w, select) ||
299  lattice_test_bitmap_uvw(lt, selpoints, u - 1, v, w, select) ||
300  lattice_test_bitmap_uvw(lt, selpoints, u, v + 1, w, select) ||
301  lattice_test_bitmap_uvw(lt, selpoints, u, v - 1, w, select) ||
302  lattice_test_bitmap_uvw(lt, selpoints, u, v, w + 1, select) ||
303  lattice_test_bitmap_uvw(lt, selpoints, u, v, w - 1, select)) {
305  }
306  }
307  bp++;
308  }
309  }
310  }
311 
312  MEM_freeN(selpoints);
313 
314  changed = true;
317  }
318  MEM_freeN(objects);
319 
320  return changed ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
321 }
322 
324 {
325  return lattice_select_more_less(C, true);
326 }
327 
329 {
330  return lattice_select_more_less(C, false);
331 }
332 
334 {
335  /* identifiers */
336  ot->name = "Select More";
337  ot->description = "Select vertex directly linked to already selected ones";
338  ot->idname = "LATTICE_OT_select_more";
339 
340  /* api callbacks */
343 
344  /* flags */
346 }
347 
349 {
350  /* identifiers */
351  ot->name = "Select Less";
352  ot->description = "Deselect vertices at the boundary of each selection region";
353  ot->idname = "LATTICE_OT_select_less";
354 
355  /* api callbacks */
358 
359  /* flags */
361 }
362 
365 /* -------------------------------------------------------------------- */
369 bool ED_lattice_flags_set(Object *obedit, int flag)
370 {
371  Lattice *lt = obedit->data;
372  BPoint *bp;
373  int a;
374  bool changed = false;
375 
376  bp = lt->editlatt->latt->def;
377 
378  a = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
379 
380  if (lt->editlatt->latt->actbp != LT_ACTBP_NONE) {
382  changed = true;
383  }
384 
385  while (a--) {
386  if (bp->hide == 0) {
387  if (bp->f1 != flag) {
388  bp->f1 = flag;
389  changed = true;
390  }
391  }
392  bp++;
393  }
394  return changed;
395 }
396 
398 {
399  ViewLayer *view_layer = CTX_data_view_layer(C);
400  int action = RNA_enum_get(op->ptr, "action");
401 
402  uint objects_len = 0;
404  view_layer, CTX_wm_view3d(C), &objects_len);
405 
406  if (action == SEL_TOGGLE) {
407  action = SEL_SELECT;
408  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
409  Object *obedit = objects[ob_index];
410  Lattice *lt = obedit->data;
412  action = SEL_DESELECT;
413  break;
414  }
415  }
416  }
417 
418  bool changed_multi = false;
419  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
420  Object *obedit = objects[ob_index];
421  Lattice *lt;
422  BPoint *bp;
423  int a;
424  bool changed = false;
425 
426  switch (action) {
427  case SEL_SELECT:
428  changed = ED_lattice_flags_set(obedit, 1);
429  break;
430  case SEL_DESELECT:
431  changed = ED_lattice_flags_set(obedit, 0);
432  break;
433  case SEL_INVERT:
434  lt = obedit->data;
435  bp = lt->editlatt->latt->def;
436  a = lt->editlatt->latt->pntsu * lt->editlatt->latt->pntsv * lt->editlatt->latt->pntsw;
438 
439  while (a--) {
440  if (bp->hide == 0) {
441  bp->f1 ^= SELECT;
442  changed = true;
443  }
444  bp++;
445  }
446  break;
447  }
448  if (changed) {
449  changed_multi = true;
452  }
453  }
454  MEM_freeN(objects);
455 
456  if (changed_multi) {
457  return OPERATOR_FINISHED;
458  }
459  return OPERATOR_CANCELLED;
460 }
461 
463 {
464  /* identifiers */
465  ot->name = "(De)select All";
466  ot->description = "Change selection of all UVW control points";
467  ot->idname = "LATTICE_OT_select_all";
468 
469  /* api callbacks */
472 
473  /* flags */
475 
477 }
478 
481 /* -------------------------------------------------------------------- */
486 {
487  ViewLayer *view_layer = CTX_data_view_layer(C);
488  uint objects_len;
489  const bool is_extend = RNA_boolean_get(op->ptr, "extend");
490  bool changed = false;
491 
493  view_layer, CTX_wm_view3d(C), &objects_len);
494  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
495  Object *obedit = objects[ob_index];
496  Lattice *lt = ((Lattice *)obedit->data)->editlatt->latt;
497  MDeformVert *dv;
498  BPoint *bp;
499  int a, tot;
500 
501  if (BLI_listbase_is_empty(&lt->vertex_group_names) || lt->dvert == NULL) {
502  continue;
503  }
504 
505  if (!is_extend) {
506  ED_lattice_flags_set(obedit, 0);
507  }
508 
509  dv = lt->dvert;
510  tot = lt->pntsu * lt->pntsv * lt->pntsw;
511 
512  for (a = 0, bp = lt->def; a < tot; a++, bp++, dv++) {
513  if (bp->hide == 0) {
514  if (dv->dw == NULL) {
515  bp->f1 |= SELECT;
516  }
517  }
518  }
519 
520  changed = true;
523  }
524  MEM_freeN(objects);
525 
526  if (!changed) {
527  BKE_report(op->reports, RPT_ERROR, "No weights/vertex groups on object(s)");
528  return OPERATOR_CANCELLED;
529  }
530  return OPERATOR_FINISHED;
531 }
532 
534 {
535  /* identifiers */
536  ot->name = "Select Ungrouped";
537  ot->idname = "LATTICE_OT_select_ungrouped";
538  ot->description = "Select vertices without a group";
539 
540  /* api callbacks */
543 
544  /* flags */
546 
547  RNA_def_boolean(ot->srna, "extend", false, "Extend", "Extend the selection");
548 }
549 
552 /* -------------------------------------------------------------------- */
561  float dist;
563  bool select;
564  float mval_fl[2];
566 };
567 
568 static void findnearestLattvert__doClosest(void *user_data, BPoint *bp, const float screen_co[2])
569 {
571  float dist_test = len_manhattan_v2v2(data->mval_fl, screen_co);
572 
573  if ((bp->f1 & SELECT) && data->select) {
574  dist_test += 5.0f;
575  }
576 
577  if (dist_test < data->dist) {
578  data->dist = dist_test;
579  data->bp = bp;
580  data->is_changed = true;
581  }
582 }
583 
584 static BPoint *findnearestLattvert(ViewContext *vc, bool select, Base **r_base)
585 {
587 
589  data.select = select;
590  data.mval_fl[0] = vc->mval[0];
591  data.mval_fl[1] = vc->mval[1];
592 
593  uint bases_len;
595  vc->view_layer, vc->v3d, &bases_len);
596  for (uint base_index = 0; base_index < bases_len; base_index++) {
597  Base *base = bases[base_index];
598  data.is_changed = false;
599 
604 
605  if (data.is_changed) {
606  *r_base = base;
607  }
608  }
609  MEM_freeN(bases);
610  return data.bp;
611 }
612 
613 bool ED_lattice_select_pick(bContext *C, const int mval[2], const struct SelectPick_Params *params)
614 {
616  ViewContext vc;
617  BPoint *bp = NULL;
618  Base *basact = NULL;
619  bool changed = false;
620 
622  vc.mval[0] = mval[0];
623  vc.mval[1] = mval[1];
624 
625  bp = findnearestLattvert(&vc, true, &basact);
626  bool found = (bp != NULL);
627 
628  if (params->sel_op == SEL_OP_SET) {
629  if ((found && params->select_passthrough) && (bp->f1 & SELECT)) {
630  found = false;
631  }
632  else if (found || params->deselect_all) {
633  /* Deselect everything. */
634  uint objects_len = 0;
636  vc.view_layer, vc.v3d, &objects_len);
637  for (uint ob_index = 0; ob_index < objects_len; ob_index++) {
638  Object *ob = objects[ob_index];
639  if (ED_lattice_flags_set(ob, 0)) {
642  }
643  }
644  MEM_freeN(objects);
645  changed = true;
646  }
647  }
648 
649  if (found) {
651  Lattice *lt = ((Lattice *)vc.obedit->data)->editlatt->latt;
652 
653  switch (params->sel_op) {
654  case SEL_OP_ADD: {
655  bp->f1 |= SELECT;
656  break;
657  }
658  case SEL_OP_SUB: {
659  bp->f1 &= ~SELECT;
660  break;
661  }
662  case SEL_OP_XOR: {
663  bp->f1 ^= SELECT; /* swap */
664  break;
665  }
666  case SEL_OP_SET: {
667  bp->f1 |= SELECT;
668  break;
669  }
670  case SEL_OP_AND: {
671  BLI_assert_unreachable(); /* Doesn't make sense for picking. */
672  break;
673  }
674  }
675 
676  if (bp->f1 & SELECT) {
677  lt->actbp = bp - lt->def;
678  }
679  else {
680  lt->actbp = LT_ACTBP_NONE;
681  }
682 
683  if (vc.view_layer->basact != basact) {
684  ED_object_base_activate(C, basact);
685  }
686 
689 
690  changed = true;
691  }
692 
693  return changed || found;
694 }
695 
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
struct Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C)
Definition: context.c:1528
struct View3D * CTX_wm_view3d(const bContext *C)
Definition: context.c:784
void BKE_lattice_bitmap_from_flag(struct Lattice *lt, unsigned int *bitmap, uint8_t flag, bool clear, bool respecthide)
Definition: lattice.c:245
int BKE_lattice_index_flip(struct Lattice *lt, int index, bool flip_u, bool flip_v, bool flip_w)
Definition: lattice.c:223
int BKE_lattice_index_from_uvw(struct Lattice *lt, int u, int v, int w)
Definition: lattice.c:205
bool BKE_lattice_is_any_selected(const struct Lattice *lt)
#define BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, v3d, r_len)
Definition: BKE_layer.h:542
#define BKE_view_layer_array_from_bases_in_edit_mode_unique_data(view_layer, v3d, r_len)
Definition: BKE_layer.h:546
void BKE_report(ReportList *reports, eReportType type, const char *message)
Definition: report.c:83
#define BLI_assert_unreachable()
Definition: BLI_assert.h:93
#define BLI_BITMAP_NEW(_num, _alloc_string)
Definition: BLI_bitmap.h:40
#define BLI_BITMAP_TEST(_bitmap, _index)
Definition: BLI_bitmap.h:64
unsigned int BLI_bitmap
Definition: BLI_bitmap.h:16
unsigned int BLI_ghashutil_strhash_p(const void *ptr)
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
Definition: BLI_listbase.h:269
MINLINE float len_manhattan_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
Random number functions.
void BLI_array_randomize(void *data, unsigned int elem_size, unsigned int elem_num, unsigned int seed)
Definition: rand.cc:188
unsigned int uint
Definition: BLI_sys_types.h:67
#define UNUSED(x)
#define SET_FLAG_FROM_TEST(value, test, flag)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
void DEG_id_tag_update(struct ID *id, int flag)
@ ID_RECALC_SELECT
Definition: DNA_ID.h:818
#define LT_ACTBP_NONE
Object is a sort of wrapper for general info.
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
void ED_object_base_activate(struct bContext *C, struct Base *base)
bool ED_operator_editlattice(struct bContext *C)
Definition: screen_ops.c:644
@ SEL_SELECT
@ SEL_INVERT
@ SEL_DESELECT
@ SEL_TOGGLE
@ SEL_OP_ADD
@ SEL_OP_SUB
@ SEL_OP_SET
@ SEL_OP_AND
@ SEL_OP_XOR
void ED_view3d_viewcontext_init(struct bContext *C, struct ViewContext *vc, struct Depsgraph *depsgraph)
void ED_view3d_viewcontext_init_object(struct ViewContext *vc, struct Object *obact)
void lattice_foreachScreenVert(struct ViewContext *vc, void(*func)(void *userData, struct BPoint *bp, const float screen_co[2]), void *userData, eV3DProjTest clip_flag)
#define V3D_PROJ_TEST_CLIP_DEFAULT
Definition: ED_view3d.h:264
void ED_view3d_init_mats_rv3d(const struct Object *ob, struct RegionView3D *rv3d)
Definition: space_view3d.c:166
float ED_view3d_select_dist_px(void)
Read Guarded memory(de)allocation.
#define C
Definition: RandGen.cpp:25
@ OPTYPE_UNDO
Definition: WM_types.h:148
@ OPTYPE_REGISTER
Definition: WM_types.h:146
#define NC_GEOM
Definition: WM_types.h:343
#define ND_SELECT
Definition: WM_types.h:455
__forceinline const avxb select(const avxb &m, const avxb &t, const avxb &f)
Definition: avxb.h:154
ATTR_WARN_UNUSED_RESULT const BMVert * v
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition: btQuadWord.h:119
static unsigned long seed
Definition: btSoftBody.h:39
#define SELECT
const Depsgraph * depsgraph
void * user_data
bool ED_lattice_deselect_all_multi_ex(struct Base **bases, const uint bases_len)
bool ED_lattice_deselect_all_multi(struct bContext *C)
static int lattice_select_less_exec(bContext *C, wmOperator *UNUSED(op))
static void findnearestLattvert__doClosest(void *user_data, BPoint *bp, const float screen_co[2])
void LATTICE_OT_select_all(wmOperatorType *ot)
static void bpoint_select_set(BPoint *bp, bool select)
void LATTICE_OT_select_random(wmOperatorType *ot)
static int lattice_select_random_exec(bContext *C, wmOperator *op)
void LATTICE_OT_select_more(wmOperatorType *ot)
static int lattice_select_more_less(bContext *C, const bool select)
void LATTICE_OT_select_ungrouped(wmOperatorType *ot)
bool ED_lattice_select_pick(bContext *C, const int mval[2], const struct SelectPick_Params *params)
static bool lattice_test_bitmap_uvw(Lattice *lt, const BLI_bitmap *selpoints, int u, int v, int w, const bool selected)
static int lattice_select_all_exec(bContext *C, wmOperator *op)
void LATTICE_OT_select_mirror(wmOperatorType *ot)
static int lattice_select_more_exec(bContext *C, wmOperator *UNUSED(op))
static int lattice_select_ungrouped_exec(bContext *C, wmOperator *op)
bool ED_lattice_flags_set(Object *obedit, int flag)
static void ed_lattice_select_mirrored(Lattice *lt, const int axis, const bool extend)
static BPoint * findnearestLattvert(ViewContext *vc, bool select, Base **r_base)
void LATTICE_OT_select_less(wmOperatorType *ot)
static int lattice_select_mirror_exec(bContext *C, wmOperator *op)
uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH]
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static unsigned a[3]
Definition: RandGen.cpp:78
float RNA_float_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4957
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4863
int RNA_enum_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:5004
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3493
PropertyRNA * RNA_def_enum_flag(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description)
Definition: rna_define.c:3806
const EnumPropertyItem rna_enum_axis_flag_xyz_items[]
Definition: rna_modifier.c:622
short hide
uint8_t f1
struct Object * object
struct Lattice * latt
char name[66]
Definition: DNA_ID.h:378
ListBase vertex_group_names
struct MDeformVert * dvert
struct EditLatt * editlatt
struct BPoint * def
struct MDeformWeight * dw
void * data
int mval[2]
Definition: ED_view3d.h:74
struct ViewLayer * view_layer
Definition: ED_view3d.h:66
struct Object * obedit
Definition: ED_view3d.h:68
struct View3D * v3d
Definition: ED_view3d.h:70
struct RegionView3D * rv3d
Definition: ED_view3d.h:72
struct Base * basact
const char * name
Definition: WM_types.h:888
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
struct StructRNA * srna
Definition: WM_types.h:969
const char * description
Definition: WM_types.h:893
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:903
struct ReportList * reports
struct PointerRNA * ptr
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmOperatorType * ot
Definition: wm_files.c:3479
int WM_operator_properties_select_random_seed_increment_get(wmOperator *op)
void WM_operator_properties_select_random(wmOperatorType *ot)
void WM_operator_properties_select_all(wmOperatorType *ot)