Blender  V3.3
editmesh_inset.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 
7 #include "MEM_guardedalloc.h"
8 
9 #include "DNA_object_types.h"
10 
11 #include "BLI_math.h"
12 #include "BLI_string.h"
13 
14 #include "BLT_translation.h"
15 
16 #include "BKE_context.h"
17 #include "BKE_editmesh.h"
18 #include "BKE_global.h"
19 #include "BKE_layer.h"
20 #include "BKE_unit.h"
21 
22 #include "RNA_access.h"
23 #include "RNA_define.h"
24 
25 #include "WM_api.h"
26 #include "WM_types.h"
27 
28 #include "UI_interface.h"
29 
30 #include "ED_mesh.h"
31 #include "ED_numinput.h"
32 #include "ED_screen.h"
33 #include "ED_space_api.h"
34 #include "ED_transform.h"
35 #include "ED_util.h"
36 #include "ED_view3d.h"
37 
38 #include "mesh_intern.h" /* own include */
39 
40 typedef struct {
45 
46 typedef struct {
48  float old_depth;
51  float pixel_size; /* use when mouse input is interpreted as spatial distance */
52  bool is_modal;
53  bool shift;
54  float shift_amount;
57 
60 
61  /* modal only */
63  float mcenter[2];
65 } InsetData;
66 
68 {
69  InsetData *opdata = op->customdata;
70 
71  const char *str = TIP_(
72  "Confirm: Enter/LClick, Cancel: (Esc/RClick), Thickness: %s, "
73  "Depth (Ctrl to tweak): %s (%s), Outset (O): (%s), Boundary (B): (%s), Individual (I): "
74  "(%s)");
75 
76  char msg[UI_MAX_DRAW_STR];
78  Scene *sce = CTX_data_scene(C);
79 
80  if (area) {
81  char flts_str[NUM_STR_REP_LEN * 2];
82  if (hasNumInput(&opdata->num_input)) {
83  outputNumInput(&opdata->num_input, flts_str, &sce->unit);
84  }
85  else {
86  BKE_unit_value_as_string(flts_str,
88  RNA_float_get(op->ptr, "thickness"),
89  4,
91  &sce->unit,
92  true);
95  RNA_float_get(op->ptr, "depth"),
96  4,
98  &sce->unit,
99  true);
100  }
101  BLI_snprintf(msg,
102  sizeof(msg),
103  str,
104  flts_str,
105  flts_str + NUM_STR_REP_LEN,
107  WM_bool_as_string(RNA_boolean_get(op->ptr, "use_outset")),
108  WM_bool_as_string(RNA_boolean_get(op->ptr, "use_boundary")),
109  WM_bool_as_string(RNA_boolean_get(op->ptr, "use_individual")));
110 
112  }
113 }
114 
115 static bool edbm_inset_init(bContext *C, wmOperator *op, const bool is_modal)
116 {
117  InsetData *opdata;
119  ViewLayer *view_layer = CTX_data_view_layer(C);
120 
121  if (is_modal) {
122  RNA_float_set(op->ptr, "thickness", 0.0f);
123  RNA_float_set(op->ptr, "depth", 0.0f);
124  }
125 
126  op->customdata = opdata = MEM_mallocN(sizeof(InsetData), "inset_operator_data");
127 
128  uint objects_used_len = 0;
129 
130  opdata->max_obj_scale = FLT_MIN;
131 
132  {
133  uint ob_store_len = 0;
135  view_layer, CTX_wm_view3d(C), &ob_store_len);
136  opdata->ob_store = MEM_malloc_arrayN(ob_store_len, sizeof(*opdata->ob_store), __func__);
137  for (uint ob_index = 0; ob_index < ob_store_len; ob_index++) {
138  Object *obedit = objects[ob_index];
139  float scale = mat4_to_scale(obedit->obmat);
140  opdata->max_obj_scale = max_ff(opdata->max_obj_scale, scale);
141  BMEditMesh *em = BKE_editmesh_from_object(obedit);
142  if (em->bm->totvertsel > 0) {
143  opdata->ob_store[objects_used_len].ob = obedit;
144  objects_used_len++;
145  }
146  }
147  MEM_freeN(objects);
148  opdata->ob_store_len = objects_used_len;
149  }
150 
151  opdata->old_thickness = 0.0;
152  opdata->old_depth = 0.0;
153  opdata->modify_depth = false;
154  opdata->shift = false;
155  opdata->shift_amount = 0.0f;
156  opdata->is_modal = is_modal;
157 
158  initNumInput(&opdata->num_input);
159  opdata->num_input.idx_max = 1; /* Two elements. */
160  opdata->num_input.unit_sys = scene->unit.system;
161  opdata->num_input.unit_type[0] = B_UNIT_LENGTH;
162  opdata->num_input.unit_type[1] = B_UNIT_LENGTH;
163 
164  if (is_modal) {
165  ARegion *region = CTX_wm_region(C);
166 
167  for (uint ob_index = 0; ob_index < opdata->ob_store_len; ob_index++) {
168  Object *obedit = opdata->ob_store[ob_index].ob;
169  BMEditMesh *em = BKE_editmesh_from_object(obedit);
170  opdata->ob_store[ob_index].mesh_backup = EDBM_redo_state_store(em);
171  }
172 
175  G.moving = G_TRANSFORM_EDIT;
176  }
177 
178  return true;
179 }
180 
182 {
183  InsetData *opdata;
185 
186  opdata = op->customdata;
187 
188  if (opdata->is_modal) {
189  ARegion *region = CTX_wm_region(C);
190  for (uint ob_index = 0; ob_index < opdata->ob_store_len; ob_index++) {
191  EDBM_redo_state_free(&opdata->ob_store[ob_index].mesh_backup);
192  }
194  G.moving = 0;
195  }
196 
197  if (area) {
199  }
200 
201  MEM_SAFE_FREE(opdata->ob_store);
203 }
204 
206 {
207  InsetData *opdata;
208 
209  opdata = op->customdata;
210  if (opdata->is_modal) {
211  for (uint ob_index = 0; ob_index < opdata->ob_store_len; ob_index++) {
212  Object *obedit = opdata->ob_store[ob_index].ob;
213  BMEditMesh *em = BKE_editmesh_from_object(obedit);
214  EDBM_redo_state_restore_and_free(&opdata->ob_store[ob_index].mesh_backup, em, true);
215  EDBM_update(obedit->data,
216  &(const struct EDBMUpdate_Params){
217  .calc_looptri = false,
218  .calc_normals = false,
219  .is_destructive = true,
220  });
221  }
222  }
223 
224  edbm_inset_exit(C, op);
225 
226  /* need to force redisplay or we may still view the modified result */
228 }
229 
230 static bool edbm_inset_calc(wmOperator *op)
231 {
232  InsetData *opdata;
233  BMOperator bmop;
234  bool changed = false;
235 
236  const bool use_boundary = RNA_boolean_get(op->ptr, "use_boundary");
237  const bool use_even_offset = RNA_boolean_get(op->ptr, "use_even_offset");
238  const bool use_relative_offset = RNA_boolean_get(op->ptr, "use_relative_offset");
239  const bool use_edge_rail = RNA_boolean_get(op->ptr, "use_edge_rail");
240  const float thickness = RNA_float_get(op->ptr, "thickness");
241  const float depth = RNA_float_get(op->ptr, "depth");
242  const bool use_outset = RNA_boolean_get(op->ptr, "use_outset");
243  /* not passed onto the BMO */
244  const bool use_select_inset = RNA_boolean_get(op->ptr, "use_select_inset");
245  const bool use_individual = RNA_boolean_get(op->ptr, "use_individual");
246  const bool use_interpolate = RNA_boolean_get(op->ptr, "use_interpolate");
247 
248  opdata = op->customdata;
249 
250  for (uint ob_index = 0; ob_index < opdata->ob_store_len; ob_index++) {
251  Object *obedit = opdata->ob_store[ob_index].ob;
252  BMEditMesh *em = BKE_editmesh_from_object(obedit);
253 
254  if (opdata->is_modal) {
255  EDBM_redo_state_restore(&opdata->ob_store[ob_index].mesh_backup, em, false);
256  }
257 
258  if (use_individual) {
259  EDBM_op_init(em,
260  &bmop,
261  op,
262  "inset_individual faces=%hf use_even_offset=%b use_relative_offset=%b "
263  "use_interpolate=%b thickness=%f depth=%f",
265  use_even_offset,
266  use_relative_offset,
267  use_interpolate,
268  thickness,
269  depth);
270  }
271  else {
272  EDBM_op_init(
273  em,
274  &bmop,
275  op,
276  "inset_region faces=%hf use_boundary=%b use_even_offset=%b use_relative_offset=%b "
277  "use_interpolate=%b thickness=%f depth=%f use_outset=%b use_edge_rail=%b",
279  use_boundary,
280  use_even_offset,
281  use_relative_offset,
282  use_interpolate,
283  thickness,
284  depth,
285  use_outset,
286  use_edge_rail);
287 
288  if (use_outset) {
290  em->bm, &bmop, bmop.slots_in, "faces_exclude", BM_FACE, BM_ELEM_HIDDEN);
291  }
292  }
293  BMO_op_exec(em->bm, &bmop);
294 
295  if (use_select_inset) {
296  /* deselect original faces/verts */
299  em->bm, bmop.slots_out, "faces.out", BM_FACE, BM_ELEM_SELECT, true);
300  }
301  else {
303  BMO_slot_buffer_hflag_enable(em->bm, bmop.slots_in, "faces", BM_FACE, BM_ELEM_SELECT, true);
304  }
305 
306  if (!EDBM_op_finish(em, &bmop, op, true)) {
307  continue;
308  }
309 
310  EDBM_update(obedit->data,
311  &(const struct EDBMUpdate_Params){
312  .calc_looptri = true,
313  .calc_normals = false,
314  .is_destructive = true,
315  });
316  changed = true;
317  }
318  return changed;
319 }
320 
322 {
323  if (!edbm_inset_init(C, op, false)) {
324  return OPERATOR_CANCELLED;
325  }
326 
327  if (!edbm_inset_calc(op)) {
328  edbm_inset_exit(C, op);
329  return OPERATOR_CANCELLED;
330  }
331 
332  edbm_inset_exit(C, op);
333  return OPERATOR_FINISHED;
334 }
335 
336 static int edbm_inset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
337 {
339  InsetData *opdata;
340  float mlen[2];
341  float center_3d[3];
342 
343  if (!edbm_inset_init(C, op, true)) {
344  return OPERATOR_CANCELLED;
345  }
346 
347  opdata = op->customdata;
348 
350 
351  /* initialize mouse values */
352  if (!calculateTransformCenter(C, V3D_AROUND_CENTER_MEDIAN, center_3d, opdata->mcenter)) {
353  /* in this case the tool will likely do nothing,
354  * ideally this will never happen and should be checked for above */
355  opdata->mcenter[0] = opdata->mcenter[1] = 0;
356  }
357  mlen[0] = opdata->mcenter[0] - event->mval[0];
358  mlen[1] = opdata->mcenter[1] - event->mval[1];
359  opdata->initial_length = len_v2(mlen);
360  opdata->pixel_size = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
361 
362  edbm_inset_calc(op);
363 
365 
367  return OPERATOR_RUNNING_MODAL;
368 }
369 
370 static int edbm_inset_modal(bContext *C, wmOperator *op, const wmEvent *event)
371 {
372  InsetData *opdata = op->customdata;
373  const bool has_numinput = hasNumInput(&opdata->num_input);
374 
375  /* Modal numinput active, try to handle numeric inputs first... */
376  if (event->val == KM_PRESS && has_numinput && handleNumInput(C, &opdata->num_input, event)) {
377  float amounts[2] = {RNA_float_get(op->ptr, "thickness"), RNA_float_get(op->ptr, "depth")};
378  applyNumInput(&opdata->num_input, amounts);
379  amounts[0] = max_ff(amounts[0], 0.0f);
380  RNA_float_set(op->ptr, "thickness", amounts[0]);
381  RNA_float_set(op->ptr, "depth", amounts[1]);
382 
383  if (edbm_inset_calc(op)) {
385  return OPERATOR_RUNNING_MODAL;
386  }
387  edbm_inset_cancel(C, op);
388  return OPERATOR_CANCELLED;
389  }
390  if ((event->type == opdata->launch_event) && (event->val == KM_RELEASE) &&
391  RNA_boolean_get(op->ptr, "release_confirm")) {
392  edbm_inset_calc(op);
393  edbm_inset_exit(C, op);
394  return OPERATOR_FINISHED;
395  }
396 
397  bool handled = false;
398  switch (event->type) {
399  case EVT_ESCKEY:
400  case RIGHTMOUSE:
401  edbm_inset_cancel(C, op);
402  return OPERATOR_CANCELLED;
403 
404  case MOUSEMOVE:
405  if (!has_numinput) {
406  float mdiff[2];
407  float amount;
408 
409  mdiff[0] = opdata->mcenter[0] - event->mval[0];
410  mdiff[1] = opdata->mcenter[1] - event->mval[1];
411 
412  if (opdata->modify_depth) {
413  amount = opdata->old_depth +
414  ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size) /
415  opdata->max_obj_scale;
416  }
417  else {
418  amount = opdata->old_thickness -
419  ((len_v2(mdiff) - opdata->initial_length) * opdata->pixel_size) /
420  opdata->max_obj_scale;
421  }
422 
423  /* Fake shift-transform... */
424  if (opdata->shift) {
425  amount = (amount - opdata->shift_amount) * 0.1f + opdata->shift_amount;
426  }
427 
428  if (opdata->modify_depth) {
429  RNA_float_set(op->ptr, "depth", amount);
430  }
431  else {
432  amount = max_ff(amount, 0.0f);
433  RNA_float_set(op->ptr, "thickness", amount);
434  }
435 
436  if (edbm_inset_calc(op)) {
438  }
439  else {
440  edbm_inset_cancel(C, op);
441  return OPERATOR_CANCELLED;
442  }
443  handled = true;
444  }
445  break;
446 
447  case LEFTMOUSE:
448  case EVT_PADENTER:
449  case EVT_RETKEY:
450  if ((event->val == KM_PRESS) ||
451  ((event->val == KM_RELEASE) && RNA_boolean_get(op->ptr, "release_confirm"))) {
452  edbm_inset_calc(op);
453  edbm_inset_exit(C, op);
454  return OPERATOR_FINISHED;
455  }
456  break;
457  case EVT_LEFTSHIFTKEY:
458  case EVT_RIGHTSHIFTKEY:
459  if (event->val == KM_PRESS) {
460  if (opdata->modify_depth) {
461  opdata->shift_amount = RNA_float_get(op->ptr, "depth");
462  }
463  else {
464  opdata->shift_amount = RNA_float_get(op->ptr, "thickness");
465  }
466  opdata->shift = true;
467  handled = true;
468  }
469  else {
470  opdata->shift_amount = 0.0f;
471  opdata->shift = false;
472  handled = true;
473  }
474  break;
475 
476  case EVT_LEFTCTRLKEY:
477  case EVT_RIGHTCTRLKEY: {
478  float mlen[2];
479 
480  mlen[0] = opdata->mcenter[0] - event->mval[0];
481  mlen[1] = opdata->mcenter[1] - event->mval[1];
482 
483  if (event->val == KM_PRESS) {
484  opdata->old_thickness = RNA_float_get(op->ptr, "thickness");
485  if (opdata->shift) {
486  opdata->shift_amount = opdata->old_thickness;
487  }
488  opdata->modify_depth = true;
489  }
490  else {
491  opdata->old_depth = RNA_float_get(op->ptr, "depth");
492  if (opdata->shift) {
493  opdata->shift_amount = opdata->old_depth;
494  }
495  opdata->modify_depth = false;
496  }
497  opdata->initial_length = len_v2(mlen);
498 
500  handled = true;
501  break;
502  }
503 
504  case EVT_OKEY:
505  if (event->val == KM_PRESS) {
506  const bool use_outset = RNA_boolean_get(op->ptr, "use_outset");
507  RNA_boolean_set(op->ptr, "use_outset", !use_outset);
508  if (edbm_inset_calc(op)) {
510  }
511  else {
512  edbm_inset_cancel(C, op);
513  return OPERATOR_CANCELLED;
514  }
515  handled = true;
516  }
517  break;
518  case EVT_BKEY:
519  if (event->val == KM_PRESS) {
520  const bool use_boundary = RNA_boolean_get(op->ptr, "use_boundary");
521  RNA_boolean_set(op->ptr, "use_boundary", !use_boundary);
522  if (edbm_inset_calc(op)) {
524  }
525  else {
526  edbm_inset_cancel(C, op);
527  return OPERATOR_CANCELLED;
528  }
529  handled = true;
530  }
531  break;
532  case EVT_IKEY:
533  if (event->val == KM_PRESS) {
534  const bool use_individual = RNA_boolean_get(op->ptr, "use_individual");
535  RNA_boolean_set(op->ptr, "use_individual", !use_individual);
536  if (edbm_inset_calc(op)) {
538  }
539  else {
540  edbm_inset_cancel(C, op);
541  return OPERATOR_CANCELLED;
542  }
543  handled = true;
544  }
545  break;
546  }
547 
548  /* Modal numinput inactive, try to handle numeric inputs last... */
549  if (!handled && event->val == KM_PRESS && handleNumInput(C, &opdata->num_input, event)) {
550  float amounts[2] = {RNA_float_get(op->ptr, "thickness"), RNA_float_get(op->ptr, "depth")};
551  applyNumInput(&opdata->num_input, amounts);
552  amounts[0] = max_ff(amounts[0], 0.0f);
553  RNA_float_set(op->ptr, "thickness", amounts[0]);
554  RNA_float_set(op->ptr, "depth", amounts[1]);
555 
556  if (edbm_inset_calc(op)) {
558  return OPERATOR_RUNNING_MODAL;
559  }
560  edbm_inset_cancel(C, op);
561  return OPERATOR_CANCELLED;
562  }
563 
564  return OPERATOR_RUNNING_MODAL;
565 }
566 
568 {
569  PropertyRNA *prop;
570 
571  /* identifiers */
572  ot->name = "Inset Faces";
573  ot->idname = "MESH_OT_inset";
574  ot->description = "Inset new faces into selected faces";
575 
576  /* api callbacks */
582 
583  /* flags */
585 
586  /* properties */
587  RNA_def_boolean(ot->srna, "use_boundary", true, "Boundary", "Inset face boundaries");
589  "use_even_offset",
590  true,
591  "Offset Even",
592  "Scale the offset to give more even thickness");
594  "use_relative_offset",
595  false,
596  "Offset Relative",
597  "Scale the offset by surrounding geometry");
599  ot->srna, "use_edge_rail", false, "Edge Rail", "Inset the region along existing edges");
600 
601  prop = RNA_def_float_distance(
602  ot->srna, "thickness", 0.0f, 0.0f, 1e12f, "Thickness", "", 0.0f, 10.0f);
603  /* use 1 rather than 10 for max else dragging the button moves too far */
604  RNA_def_property_ui_range(prop, 0.0, 1.0, 0.01, 4);
605 
606  prop = RNA_def_float_distance(
607  ot->srna, "depth", 0.0f, -1e12f, 1e12f, "Depth", "", -10.0f, 10.0f);
608  RNA_def_property_ui_range(prop, -10.0f, 10.0f, 0.01, 4);
609 
610  RNA_def_boolean(ot->srna, "use_outset", false, "Outset", "Outset rather than inset");
612  ot->srna, "use_select_inset", false, "Select Outer", "Select the new inset faces");
613  RNA_def_boolean(ot->srna, "use_individual", false, "Individual", "Individual face inset");
615  ot->srna, "use_interpolate", true, "Interpolate", "Blend face data across the inset");
616 
617  prop = RNA_def_boolean(ot->srna, "release_confirm", 0, "Confirm on Release", "");
619 }
struct ScrArea * CTX_wm_area(const bContext *C)
Definition: context.c:738
struct Scene * CTX_data_scene(const bContext *C)
Definition: context.c:1090
struct ViewLayer * CTX_data_view_layer(const bContext *C)
Definition: context.c:1100
struct View3D * CTX_wm_view3d(const bContext *C)
Definition: context.c:784
struct ARegion * CTX_wm_region(const bContext *C)
Definition: context.c:749
struct RegionView3D * CTX_wm_region_view3d(const bContext *C)
Definition: context.c:793
BMEditMesh * BKE_editmesh_from_object(struct Object *ob)
Return the BMEditMesh for a given object.
Definition: editmesh.c:58
@ G_TRANSFORM_EDIT
Definition: BKE_global.h:248
#define BKE_view_layer_array_from_objects_in_edit_mode_unique_data(view_layer, v3d, r_len)
Definition: BKE_layer.h:542
@ B_UNIT_LENGTH
Definition: BKE_unit.h:101
size_t BKE_unit_value_as_string(char *str, int len_max, double value, int prec, int type, const struct UnitSettings *settings, bool pad)
MINLINE float max_ff(float a, float b)
float mat4_to_scale(const float M[4][4])
Definition: math_matrix.c:2185
MINLINE float len_v2(const float a[2]) ATTR_WARN_UNUSED_RESULT
size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
unsigned int uint
Definition: BLI_sys_types.h:67
#define TIP_(msgid)
Object is a sort of wrapper for general info.
@ V3D_AROUND_CENTER_MEDIAN
@ OPERATOR_CANCELLED
@ OPERATOR_FINISHED
@ OPERATOR_RUNNING_MODAL
void void EDBM_redo_state_restore_and_free(struct BMBackup *backup, struct BMEditMesh *em, bool recalc_looptri) ATTR_NONNULL(1
void EDBM_update(struct Mesh *me, const struct EDBMUpdate_Params *params)
void EDBM_redo_state_restore(struct BMBackup *backup, struct BMEditMesh *em, bool recalc_looptri) ATTR_NONNULL(1
struct BMBackup EDBM_redo_state_store(struct BMEditMesh *em)
void EDBM_flag_disable_all(struct BMEditMesh *em, char hflag)
void void void EDBM_redo_state_free(struct BMBackup *backup) ATTR_NONNULL(1)
void outputNumInput(NumInput *n, char *str, struct UnitSettings *unit_settings)
Definition: numinput.c:87
void initNumInput(NumInput *n)
Definition: numinput.c:69
#define NUM_STR_REP_LEN
Definition: ED_numinput.h:13
bool applyNumInput(NumInput *n, float *vec)
Definition: numinput.c:189
bool hasNumInput(const NumInput *n)
Definition: numinput.c:170
bool handleNumInput(struct bContext *C, NumInput *n, const struct wmEvent *event)
void ED_area_status_text(ScrArea *area, const char *str)
Definition: area.c:792
void ED_region_tag_redraw(struct ARegion *region)
Definition: area.c:655
bool ED_operator_editmesh(struct bContext *C)
Definition: screen_ops.c:433
void * ED_region_draw_cb_activate(struct ARegionType *art, void(*draw)(const struct bContext *, struct ARegion *, void *), void *customdata, int type)
Definition: spacetypes.c:226
#define REGION_DRAW_POST_PIXEL
Definition: ED_space_api.h:63
bool ED_region_draw_cb_exit(struct ARegionType *art, void *handle)
Definition: spacetypes.c:241
bool calculateTransformCenter(struct bContext *C, int centerMode, float cent3d[3], float cent2d[2])
Definition: transform.c:1341
void ED_region_draw_mouse_line_cb(const struct bContext *C, struct ARegion *region, void *arg_info)
float ED_view3d_pixel_size(const struct RegionView3D *rv3d, const float co[3])
Read Guarded memory(de)allocation.
#define MEM_SAFE_FREE(v)
@ PROP_SKIP_SAVE
Definition: RNA_types.h:218
@ PROP_HIDDEN
Definition: RNA_types.h:216
#define C
Definition: RandGen.cpp:25
#define UI_MAX_DRAW_STR
Definition: UI_interface.h:91
@ KM_PRESS
Definition: WM_types.h:267
@ KM_RELEASE
Definition: WM_types.h:268
@ OPTYPE_BLOCKING
Definition: WM_types.h:150
@ OPTYPE_UNDO
Definition: WM_types.h:148
@ OPTYPE_GRAB_CURSOR_XY
Definition: WM_types.h:154
@ OPTYPE_REGISTER
Definition: WM_types.h:146
@ BM_FACE
Definition: bmesh_class.h:386
@ BM_ELEM_HIDDEN
Definition: bmesh_class.h:472
@ BM_ELEM_SELECT
Definition: bmesh_class.h:471
void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag, bool do_flush)
BMO_FLAG_BUFFER.
void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag)
void BMO_op_exec(BMesh *bm, BMOperator *op)
BMESH OPSTACK EXEC OP.
Scene scene
static int edbm_inset_invoke(bContext *C, wmOperator *op, const wmEvent *event)
static bool edbm_inset_init(bContext *C, wmOperator *op, const bool is_modal)
static int edbm_inset_exec(bContext *C, wmOperator *op)
static void edbm_inset_cancel(bContext *C, wmOperator *op)
static void edbm_inset_exit(bContext *C, wmOperator *op)
void MESH_OT_inset(wmOperatorType *ot)
static void edbm_inset_update_header(wmOperator *op, bContext *C)
static int edbm_inset_modal(bContext *C, wmOperator *op, const wmEvent *event)
static bool edbm_inset_calc(wmOperator *op)
bool EDBM_op_init(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const char *fmt,...)
bool EDBM_op_finish(BMEditMesh *em, BMOperator *bmop, wmOperator *op, const bool do_report)
#define str(s)
void *(* MEM_malloc_arrayN)(size_t len, size_t size, const char *str)
Definition: mallocn.c:34
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
#define G(x, y, z)
static void area(int d1, int d2, int e1, int e2, float weights[2])
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
Definition: rna_access.c:4874
float RNA_float_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4957
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
Definition: rna_access.c:4968
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
Definition: rna_access.c:4863
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_float_distance(StructOrFunctionRNA *cont_, const char *identifier, float default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
Definition: rna_define.c:4052
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
Definition: rna_define.c:1490
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
Definition: rna_define.c:1664
struct ARegionType * type
struct BMesh * bm
Definition: BKE_editmesh.h:40
struct BMOpSlot slots_out[BMO_OP_MAX_SLOTS]
struct BMOpSlot slots_in[BMO_OP_MAX_SLOTS]
int totvertsel
Definition: bmesh_class.h:298
float initial_length
float shift_amount
int launch_event
float mcenter[2]
uint ob_store_len
float old_thickness
float pixel_size
NumInput num_input
float max_obj_scale
bool modify_depth
InsetObjectStore * ob_store
float old_depth
void * draw_handle_pixel
BMBackup mesh_backup
short idx_max
Definition: ED_numinput.h:20
int unit_sys
Definition: ED_numinput.h:21
int unit_type[NUM_MAX_ELEMENTS]
Definition: ED_numinput.h:23
float obmat[4][4]
void * data
struct UnitSettings unit
short val
Definition: WM_types.h:680
short type
Definition: WM_types.h:678
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:919
const char * name
Definition: WM_types.h:888
int(* modal)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:935
const char * idname
Definition: WM_types.h:890
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
Definition: WM_types.h:943
void(* cancel)(struct bContext *, struct wmOperator *)
Definition: WM_types.h:927
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 PointerRNA * ptr
int WM_userdef_event_type_from_keymap_type(int kmitype)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
@ RIGHTMOUSE
@ EVT_OKEY
@ EVT_RIGHTCTRLKEY
@ EVT_IKEY
@ EVT_LEFTCTRLKEY
@ EVT_PADENTER
@ MOUSEMOVE
@ LEFTMOUSE
@ EVT_ESCKEY
@ EVT_RIGHTSHIFTKEY
@ EVT_LEFTSHIFTKEY
@ EVT_BKEY
@ EVT_RETKEY
wmOperatorType * ot
Definition: wm_files.c:3479
const char * WM_bool_as_string(bool test)
Definition: wm_keymap.c:2052