Blender V5.3
editmesh_bevel.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
8
9#include <fmt/format.h>
10
11#include "BKE_mesh_types.hh"
12#include "MEM_guardedalloc.h"
13
14#include "DNA_mesh_types.h"
15#include "DNA_object_types.h"
16
17#include "BLI_math_matrix_c.hh"
18#include "BLI_math_vector_c.hh"
19#include "BLI_string_utf8.hh"
20
21#include "BLT_translation.hh"
22
23#include "BKE_context.hh"
24#include "BKE_editmesh.hh"
25#include "BKE_global.hh"
26#include "BKE_layer.hh"
27#include "BKE_screen.hh"
28#include "BKE_unit.hh"
29
30#include "RNA_access.hh"
31#include "RNA_define.hh"
32#include "RNA_prototypes.hh"
33
34#include "WM_api.hh"
35#include "WM_types.hh"
36
37#include "UI_interface.hh"
39#include "UI_resources.hh"
40
41#include "ED_mesh.hh"
42#include "ED_numinput.hh"
43#include "ED_screen.hh"
44#include "ED_space_api.hh"
45#include "ED_transform.hh"
46#include "ED_util.hh"
47#include "ED_view3d.hh"
48
49#include "mesh_intern.hh" /* own include */
50
51namespace blender {
52
53#define MVAL_PIXEL_MARGIN 5.0f
54
55#define PROFILE_HARD_MIN 0.0f
56
57#define SEGMENTS_HARD_MAX 1000
58
59/* which value is mouse movement and numeric input controlling? */
60#define OFFSET_VALUE 0
61#define OFFSET_VALUE_PERCENT 1
62#define PROFILE_VALUE 2
63#define SEGMENTS_VALUE 3
64#define NUM_VALUE_KINDS 4
65
66static const char *value_rna_name[NUM_VALUE_KINDS] = {
67 "offset", "offset_pct", "profile", "segments"};
68static const float value_snap_increments[NUM_VALUE_KINDS] = {0.1f, 5.0f, 0.0f, 0.0f};
69static const float value_increments_precision_factors[NUM_VALUE_KINDS] = {0.1f, 0.2f, 0.0f, 0.0f};
70static const float value_clamp_min[NUM_VALUE_KINDS] = {0.0f, 0.0f, PROFILE_HARD_MIN, 1.0f};
71static const float value_clamp_max[NUM_VALUE_KINDS] = {1e6, 100.0f, 1.0f, SEGMENTS_HARD_MAX};
72static const float value_start[NUM_VALUE_KINDS] = {0.0f, 0.0f, 0.5f, 1.0f};
73static const float value_scale_per_inch[NUM_VALUE_KINDS] = {0.0f, 100.0f, 1.0f, 4.0f};
74
80
81struct BevelData {
89
93
94 /* modal only */
96 float mcenter[2];
98 short value_mode; /* Which value does mouse movement and numeric input affect? */
99 float segments; /* Segments as float so smooth mouse pan works in small increments */
100
102
105};
106
107enum {
129};
130
132{
133 if (RNA_enum_get(op->ptr, "offset_type") == BEVEL_AMT_PERCENT) {
134 return RNA_float_get(op->ptr, "offset_pct");
135 }
136 return RNA_float_get(op->ptr, "offset");
137}
138
140{
141 Scene *sce = CTX_data_scene(C);
142 BevelData *opdata = static_cast<BevelData *>(op->customdata);
143
144 char offset_str[NUM_STR_REP_LEN];
145 if (RNA_enum_get(op->ptr, "offset_type") == BEVEL_AMT_PERCENT) {
146 SNPRINTF_UTF8(offset_str, "%.1f%%", RNA_float_get(op->ptr, "offset_pct"));
147 }
148 else {
149 double offset_val = double(RNA_float_get(op->ptr, "offset"));
150 const int precision = opdata->shift_value[opdata->value_mode] == -1.0f ? 4 : 7;
153 offset_val,
154 precision * -1,
156 sce->unit,
157 true,
158 true);
159 }
160
161 PropertyRNA *prop;
162 const char *mode_str, *omiter_str, *imiter_str, *vmesh_str, *profile_type_str, *affect_str;
163 prop = RNA_struct_find_property(op->ptr, "offset_type");
165 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &mode_str);
166
167 /* Shown in area header. */
168
169 const std::string header_status = fmt::format("{}: {}, {}: {}, {}: {}",
170 mode_str,
171 offset_str,
172 IFACE_("Segments"),
173 RNA_int_get(op->ptr, "segments"),
174 IFACE_("Profile Shape"),
175 RNA_float_get(op->ptr, "profile"));
176
177 ED_area_status_text(CTX_wm_area(C), header_status.c_str());
178
179 /* Shown on Status Bar. */
180
181 prop = RNA_struct_find_property(op->ptr, "profile_type");
183 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &profile_type_str);
184 prop = RNA_struct_find_property(op->ptr, "miter_outer");
186 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &omiter_str);
187 prop = RNA_struct_find_property(op->ptr, "miter_inner");
189 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &imiter_str);
190 prop = RNA_struct_find_property(op->ptr, "vmesh_method");
192 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &vmesh_str);
193 prop = RNA_struct_find_property(op->ptr, "affect");
195 C, op->ptr, prop, RNA_property_enum_get(op->ptr, prop), &affect_str);
196
197 WorkspaceStatus status(C);
198 status.opmodal(IFACE_("Confirm"), op->type, BEV_MODAL_CONFIRM);
199 status.opmodal(IFACE_("Cancel"), op->type, BEV_MODAL_CANCEL);
200 status.opmodal(
201 IFACE_("Precision mode"), op->type, BEV_MODAL_PRECISION_ON, opdata->use_precision);
202 status.opmodal(IFACE_("Snap"), op->type, BEV_MODAL_SNAP_ON, opdata->use_snap);
203 status.opmodal(IFACE_("Width Type"), op->type, BEV_MODAL_OFFSET_MODE_CHANGE);
204
205 status.opmodal(
206 IFACE_("Width"), op->type, BEV_MODAL_VALUE_OFFSET, opdata->value_mode == OFFSET_VALUE);
207 status.opmodal(IFACE_("Segments"),
208 op->type,
210 opdata->value_mode == SEGMENTS_VALUE);
211 status.opmodal(IFACE_("Profile Shape"),
212 op->type,
214 opdata->value_mode == PROFILE_VALUE);
215
216 status.opmodal(IFACE_("Clamp"),
217 op->type,
219 RNA_boolean_get(op->ptr, "clamp_overlap"));
220 status.opmodal(IFACE_("Harden"),
221 op->type,
223 RNA_boolean_get(op->ptr, "harden_normals"));
224 status.opmodal(
225 IFACE_("Seam"), op->type, BEV_MODAL_MARK_SEAM_TOGGLE, RNA_boolean_get(op->ptr, "mark_seam"));
226 status.opmodal(IFACE_("Sharp"),
227 op->type,
229 RNA_boolean_get(op->ptr, "mark_sharp"));
230
231 std::string desc;
232
233 desc = fmt::format("{} ({}) ", IFACE_("Affect"), affect_str);
234 status.opmodal(desc, op->type, BEV_MODAL_AFFECT_CHANGE);
235
236 desc = fmt::format("{} ({}) ", IFACE_("Outer"), omiter_str);
237 status.opmodal(desc, op->type, BEV_MODAL_OUTER_MITER_CHANGE);
238
239 desc = fmt::format("{} ({}) ", IFACE_("Inner"), imiter_str);
240 status.opmodal(desc, op->type, BEV_MODAL_INNER_MITER_CHANGE);
241
242 desc = fmt::format("{} ({}) ", IFACE_("Profile Type"), profile_type_str);
243 status.opmodal(desc, op->type, BEV_MODAL_PROFILE_TYPE_CHANGE);
244
245 desc = fmt::format("{} ({}) ", IFACE_("Intersection"), vmesh_str);
246 status.opmodal(desc, op->type, BEV_MODAL_VERTEX_MESH_CHANGE);
247}
248
249static bool edbm_bevel_init(bContext *C, wmOperator *op, const bool is_modal)
250{
251 const Main *bmain = CTX_data_main(C);
252 Scene *scene = CTX_data_scene(C);
253 View3D *v3d = CTX_wm_view3d(C);
255 ViewLayer *view_layer = CTX_data_view_layer(C);
256
257 if (is_modal) {
258 RNA_float_set(op->ptr, "offset", 0.0f);
259 RNA_float_set(op->ptr, "offset_pct", 0.0f);
260 }
261
262 op->customdata = MEM_new<BevelData>(__func__);
263 BevelData *opdata = static_cast<BevelData *>(op->customdata);
264 opdata->max_obj_scale = FLT_MIN;
265
266 /* Put the Curve Profile from the toolsettings into the opdata struct */
268
271
272 {
274 *bmain, scene, view_layer, v3d);
275 for (Object *obedit : objects) {
276 float scale = mat4_to_scale(obedit->object_to_world().ptr());
277 opdata->max_obj_scale = max_ff(opdata->max_obj_scale, scale);
278 const BMesh *bm = BKE_editmesh_bmesh_get(obedit);
279 if (bm->totvertsel > 0) {
280 opdata->ob_store.append(BevelObjectStore{obedit, {}});
281 }
282 }
283 }
284
285 opdata->is_modal = is_modal;
286 int otype = RNA_enum_get(op->ptr, "offset_type");
288 opdata->segments = float(RNA_int_get(op->ptr, "segments"));
289 float pixels_per_inch = U.dpi;
290
291 for (int i = 0; i < NUM_VALUE_KINDS; i++) {
292 opdata->shift_value[i] = -1.0f;
293 opdata->initial_length[i] = -1.0f;
294 /* NOTE: scale for #OFFSET_VALUE will get overwritten in #edbm_bevel_invoke. */
295 opdata->scale[i] = value_scale_per_inch[i] / pixels_per_inch;
296
297 initNumInput(&opdata->num_input[i]);
298 opdata->num_input[i].idx_max = 0;
299 opdata->num_input[i].val_flag[0] |= NUM_NO_NEGATIVE;
300 opdata->num_input[i].unit_type[0] = B_UNIT_NONE;
301 if (i == SEGMENTS_VALUE) {
303 }
304 if (i == OFFSET_VALUE) {
305 opdata->num_input[i].unit_sys = scene->unit.system;
306 opdata->num_input[i].unit_type[0] = B_UNIT_LENGTH;
307 }
308 }
309
310 /* avoid the cost of allocating a bm copy */
311 if (is_modal) {
312 ARegion *region = CTX_wm_region(C);
313
314 for (BevelObjectStore &ob_store : opdata->ob_store) {
315 Object *obedit = ob_store.ob;
318 }
321 opdata->mcenter,
323 G.moving = G_TRANSFORM_EDIT;
324 }
325
326 return true;
327}
328
330{
331 BevelData *opdata = static_cast<BevelData *>(op->customdata);
332 BMOperator bmop;
333 bool changed_multi = false;
334
335 const float offset = get_bevel_offset(op);
336 const int offset_type = RNA_enum_get(op->ptr, "offset_type");
337 const int profile_type = RNA_enum_get(op->ptr, "profile_type");
338 const int segments = RNA_int_get(op->ptr, "segments");
339 const float profile = RNA_float_get(op->ptr, "profile");
340 const bool affect = RNA_enum_get(op->ptr, "affect");
341 const bool clamp_overlap = RNA_boolean_get(op->ptr, "clamp_overlap");
342 const int material_init = RNA_int_get(op->ptr, "material");
343 const bool loop_slide = RNA_boolean_get(op->ptr, "loop_slide");
344 const bool mark_seam = RNA_boolean_get(op->ptr, "mark_seam");
345 const bool mark_sharp = RNA_boolean_get(op->ptr, "mark_sharp");
346 const bool harden_normals = RNA_boolean_get(op->ptr, "harden_normals");
347 const int face_strength_mode = RNA_enum_get(op->ptr, "face_strength_mode");
348 const int miter_outer = RNA_enum_get(op->ptr, "miter_outer");
349 const int miter_inner = RNA_enum_get(op->ptr, "miter_inner");
350 const float spread = RNA_float_get(op->ptr, "spread");
351 const int vmesh_method = RNA_enum_get(op->ptr, "vmesh_method");
352
353 for (BevelObjectStore &ob_store : opdata->ob_store) {
354 Object *obedit = ob_store.ob;
355 Mesh *mesh = id_cast<Mesh *>(obedit->data);
356 BMEditMesh *em = mesh->runtime->edit_mesh.get();
358
359 /* revert to original mesh */
360 if (opdata->is_modal) {
361 EDBM_redo_state_restore(&ob_store.mesh_backup, em, bm, false);
362 }
363
364 const int material = std::clamp(material_init, -1, obedit->totcol - 1);
365
367 &bmop,
368 op,
369 "bevel geom=%hev offset=%f segments=%i affect=%i offset_type=%i "
370 "profile_type=%i profile=%f clamp_overlap=%b material=%i loop_slide=%b "
371 "mark_seam=%b mark_sharp=%b harden_normals=%b face_strength_mode=%i "
372 "miter_outer=%i miter_inner=%i spread=%f custom_profile=%p "
373 "vmesh_method=%i",
375 offset,
376 segments,
377 affect,
378 offset_type,
379 profile_type,
380 profile,
381 clamp_overlap,
382 material,
383 loop_slide,
384 mark_seam,
385 mark_sharp,
386 harden_normals,
387 face_strength_mode,
388 miter_outer,
389 miter_inner,
390 spread,
391 opdata->custom_profile,
392 vmesh_method);
393
394 BMO_op_exec(bm, &bmop);
395
396 if (offset != 0.0f) {
397 /* Not essential, but we may have some loose geometry that
398 * won't get beveled and better not leave it selected. */
401 if (affect == BEVEL_AFFECT_VERTICES) {
403 bm, bmop.slots_out, "verts.out", BM_VERT, BM_ELEM_SELECT, true);
405 bm, bmop.slots_out, "edges.out", BM_EDGE, BM_ELEM_SELECT, true);
406
407 if ((bm->selectmode & SCE_SELECT_VERTEX) == 0) {
409 }
410 }
411 }
412
413 bool changed = false;
414
415 if (opdata->use_automerge) {
416 changed |= EDBM_automerge_connected(
417 obedit, false, BM_ELEM_SELECT, opdata->automerge_threshold);
418 }
419
420 changed |= EDBM_op_finish(bm, &bmop, op, true);
421
422 /* no need to de-select existing geometry */
423 if (changed) {
424 EDBMUpdate_Params params{};
425 params.calc_looptris = true;
426 params.calc_normals = true;
427 params.is_destructive = true;
428 EDBM_update(id_cast<Mesh *>(obedit->data), &params);
429 }
430
431 changed_multi |= changed;
432 }
433 return changed_multi;
434}
435
437{
438 BevelData *opdata = static_cast<BevelData *>(op->customdata);
439 ScrArea *area = CTX_wm_area(C);
440
441 if (area) {
442 ED_area_status_text(area, nullptr);
443 }
444
445 for (BevelObjectStore &ob_store : opdata->ob_store) {
446 BMEditMesh *em = BKE_editmesh_from_object(ob_store.ob);
448 /* Without this, faces surrounded by selected edges/verts will be unselected. */
449 if ((em->selectmode & SCE_SELECT_FACE) == 0) {
451 }
453 }
454
455 if (opdata->is_modal) {
456 ARegion *region = CTX_wm_region(C);
457 for (BevelObjectStore &ob_store : opdata->ob_store) {
459 }
461 G.moving = 0;
462 }
463 MEM_delete(opdata);
464 op->customdata = nullptr;
465}
466
468{
469 BevelData *opdata = static_cast<BevelData *>(op->customdata);
470 if (opdata->is_modal) {
471 for (BevelObjectStore &ob_store : opdata->ob_store) {
472 Object *obedit = ob_store.ob;
475 EDBM_redo_state_restore_and_free(&ob_store.mesh_backup, em, bm, true);
476
477 EDBMUpdate_Params params{};
478 params.calc_looptris = false;
479 params.calc_normals = true;
480 params.is_destructive = true;
481 EDBM_update(id_cast<Mesh *>(obedit->data), &params);
482 }
483 }
484
485 edbm_bevel_exit(C, op);
486
487 /* Need to force re-display or we may still view the modified result. */
489}
490
491/* bevel! yay!! */
493{
494 if (!edbm_bevel_init(C, op, false)) {
495 return OPERATOR_CANCELLED;
496 }
497
498 if (!edbm_bevel_calc(op)) {
499 edbm_bevel_cancel(C, op);
500 return OPERATOR_CANCELLED;
501 }
502
503 edbm_bevel_exit(C, op);
504
505 return OPERATOR_FINISHED;
506}
507
508static void edbm_bevel_calc_initial_length(wmOperator *op, const wmEvent *event, bool mode_changed)
509{
510 BevelData *opdata = static_cast<BevelData *>(op->customdata);
511 const float mlen[2] = {
512 opdata->mcenter[0] - event->mval[0],
513 opdata->mcenter[1] - event->mval[1],
514 };
515 float len = len_v2(mlen);
516 int vmode = opdata->value_mode;
517 if (mode_changed || opdata->initial_length[vmode] == -1.0f) {
518 /* If current value is not default start value, adjust len so that
519 * the scaling and offset in edbm_bevel_mouse_set_value will
520 * start at current value */
521 float value = (vmode == SEGMENTS_VALUE) ? opdata->segments :
522 RNA_float_get(op->ptr, value_rna_name[vmode]);
523 float sc = opdata->scale[vmode];
524 float st = value_start[vmode];
525 if (value != value_start[vmode]) {
526 len = (st + sc * (len - MVAL_PIXEL_MARGIN) - value) / sc;
527 }
528 }
529 opdata->initial_length[opdata->value_mode] = len;
530}
531
533{
535
536 if (!edbm_bevel_init(C, op, true)) {
537 return OPERATOR_CANCELLED;
538 }
539
540 BevelData *opdata = static_cast<BevelData *>(op->customdata);
541
543
544 /* initialize mouse values */
545 float center_3d[3];
547 C, V3D_AROUND_CENTER_MEDIAN, center_3d, opdata->mcenter))
548 {
549 /* in this case the tool will likely do nothing,
550 * ideally this will never happen and should be checked for above */
551 opdata->mcenter[0] = opdata->mcenter[1] = 0;
552 }
553
554 /* for OFFSET_VALUE only, the scale is the size of a pixel under the mouse in 3d space */
555 opdata->scale[OFFSET_VALUE] = rv3d ? ED_view3d_pixel_size(rv3d, center_3d) : 1.0f;
556 /* since we are affecting untransformed object but seeing in transformed space,
557 * compensate for that */
558 opdata->scale[OFFSET_VALUE] /= opdata->max_obj_scale;
559
560 edbm_bevel_calc_initial_length(op, event, false);
561
563
564 if (!edbm_bevel_calc(op)) {
565 edbm_bevel_cancel(C, op);
566 ED_workspace_status_text(C, nullptr);
567 return OPERATOR_CANCELLED;
568 }
569
571
573}
574
575static void edbm_bevel_mouse_set_value(wmOperator *op, const wmEvent *event)
576{
577 BevelData *opdata = static_cast<BevelData *>(op->customdata);
578 int vmode = opdata->value_mode;
579
580 const float mdiff[2] = {
581 opdata->mcenter[0] - event->mval[0],
582 opdata->mcenter[1] - event->mval[1],
583 };
584
585 float value = ((len_v2(mdiff) - MVAL_PIXEL_MARGIN) - opdata->initial_length[vmode]);
586
587 /* Scale according to value mode */
588 value = value_start[vmode] + value * opdata->scale[vmode];
589
590 /* Fake shift-transform... */
591 if (opdata->use_precision) {
592 if (opdata->shift_value[vmode] < 0.0f) {
593 opdata->shift_value[vmode] = (vmode == SEGMENTS_VALUE) ?
594 opdata->segments :
595 RNA_float_get(op->ptr, value_rna_name[vmode]);
596 }
597 value = (value - opdata->shift_value[vmode]) * 0.1f + opdata->shift_value[vmode];
598 }
599 else if (opdata->shift_value[vmode] >= 0.0f) {
600 opdata->shift_value[vmode] = -1.0f;
601 }
602
603 if (opdata->use_snap) {
604 const float increment_factor = opdata->use_precision ?
605 (value_snap_increments[vmode] *
608 if (increment_factor != 0.0f) {
609 value = increment_factor * roundf(value / increment_factor);
610 }
611 }
612
613 /* Clamp according to value mode, and store value back. */
614 CLAMP(value, value_clamp_min[vmode], value_clamp_max[vmode]);
615 if (vmode == SEGMENTS_VALUE) {
616 opdata->segments = value;
617 RNA_int_set(op->ptr, "segments", int(value + 0.5f));
618 }
619 else {
620 RNA_float_set(op->ptr, value_rna_name[vmode], value);
621 }
622}
623
625{
626 BevelData *opdata = static_cast<BevelData *>(op->customdata);
627
628 int vmode = opdata->value_mode;
629 float value = (vmode == SEGMENTS_VALUE) ? opdata->segments :
630 RNA_float_get(op->ptr, value_rna_name[vmode]);
631 applyNumInput(&opdata->num_input[vmode], &value);
632 CLAMP(value, value_clamp_min[vmode], value_clamp_max[vmode]);
633 if (vmode == SEGMENTS_VALUE) {
634 opdata->segments = value;
635 RNA_int_set(op->ptr, "segments", int(value));
636 }
637 else {
638 RNA_float_set(op->ptr, value_rna_name[vmode], value);
639 }
640}
641
643{
644 static const EnumPropertyItem modal_items[] = {
645 {BEV_MODAL_CANCEL, "CANCEL", 0, "Cancel", "Cancel bevel"},
646 {BEV_MODAL_CONFIRM, "CONFIRM", 0, "Confirm", "Confirm bevel"},
647 {BEV_MODAL_VALUE_OFFSET, "VALUE_OFFSET", 0, "Change Offset", "Value changes offset"},
648 {BEV_MODAL_VALUE_PROFILE, "VALUE_PROFILE", 0, "Change Profile", "Value changes profile"},
649 {BEV_MODAL_VALUE_SEGMENTS, "VALUE_SEGMENTS", 0, "Change Segments", "Value changes segments"},
650 {BEV_MODAL_SEGMENTS_UP, "SEGMENTS_UP", 0, "Increase Segments", "Increase segments"},
651 {BEV_MODAL_SEGMENTS_DOWN, "SEGMENTS_DOWN", 0, "Decrease Segments", "Decrease segments"},
653 "OFFSET_MODE_CHANGE",
654 0,
655 "Change Offset Mode",
656 "Cycle through offset modes"},
658 "CLAMP_OVERLAP_TOGGLE",
659 0,
660 "Toggle Clamp Overlap",
661 "Toggle clamp overlap flag"},
663 "AFFECT_CHANGE",
664 0,
665 "Change Affect Type",
666 "Change which geometry type the operation affects, edges or vertices"},
668 "HARDEN_NORMALS_TOGGLE",
669 0,
670 "Toggle Harden Normals",
671 "Toggle harden normals flag"},
673 "MARK_SEAM_TOGGLE",
674 0,
675 "Toggle Mark Seam",
676 "Toggle mark seam flag"},
678 "MARK_SHARP_TOGGLE",
679 0,
680 "Toggle Mark Sharp",
681 "Toggle mark sharp flag"},
683 "OUTER_MITER_CHANGE",
684 0,
685 "Change Outer Miter",
686 "Cycle through outer miter kinds"},
688 "INNER_MITER_CHANGE",
689 0,
690 "Change Inner Miter",
691 "Cycle through inner miter kinds"},
692 {BEV_MODAL_PROFILE_TYPE_CHANGE, "PROFILE_TYPE_CHANGE", 0, "Cycle through profile types", ""},
694 "VERTEX_MESH_CHANGE",
695 0,
696 "Change Intersection Method",
697 "Cycle through intersection methods"},
698 {BEV_MODAL_SNAP_ON, "SNAP_ON", 0, "Snap", ""},
699 {BEV_MODAL_SNAP_OFF, "SNAP_OFF", 0, "Snap (OFF)", ""},
700 {BEV_MODAL_PRECISION_ON, "PRECISION_ON", 0, "Precision", ""},
701 {BEV_MODAL_PRECISION_OFF, "PRECISION_OFF", 0, "Precision (OFF)", ""},
702 {0, nullptr, 0, nullptr, nullptr},
703 };
704
705 wmKeyMap *keymap = WM_modalkeymap_find(keyconf, "Bevel Modal Map");
706
707 /* This function is called for each space-type, only needs to add map once. */
708 if (keymap && keymap->modal_items) {
709 return nullptr;
710 }
711
712 keymap = WM_modalkeymap_ensure(keyconf, "Bevel Modal Map", modal_items);
713
714 WM_modalkeymap_assign(keymap, "MESH_OT_bevel");
715
716 return keymap;
717}
718
720{
721 BevelData *opdata = static_cast<BevelData *>(op->customdata);
722 const bool has_numinput = hasNumInput(&opdata->num_input[opdata->value_mode]);
723 bool handled = false;
724 short etype = event->type;
725 short eval = event->val;
726
727 /* When activated from toolbar, need to convert left-mouse release to confirm. */
728 if (ELEM(etype, LEFTMOUSE, opdata->launch_event) && (eval == KM_RELEASE) &&
729 RNA_boolean_get(op->ptr, "release_confirm"))
730 {
731 etype = EVT_MODAL_MAP;
732 eval = BEV_MODAL_CONFIRM;
733 }
734 /* Modal numinput active, try to handle numeric inputs first... */
735 if (etype != EVT_MODAL_MAP && eval == KM_PRESS && has_numinput &&
736 handleNumInput(C, &opdata->num_input[opdata->value_mode], event))
737 {
739 edbm_bevel_calc(op);
742 }
743 if (etype == MOUSEMOVE) {
744 if (!has_numinput) {
746 edbm_bevel_calc(op);
748 handled = true;
749 }
750 }
751 else if (etype == MOUSEPAN) {
752 float delta = 0.02f * (event->xy[1] - event->prev_xy[1]);
753 if (opdata->segments >= 1 && opdata->segments + delta < 1) {
754 opdata->segments = 1;
755 }
756 else {
757 opdata->segments += delta;
758 }
759 RNA_int_set(op->ptr, "segments", int(opdata->segments));
760 edbm_bevel_calc(op);
762 handled = true;
763 }
764 else if (etype == EVT_MODAL_MAP) {
765 switch (eval) {
766 case BEV_MODAL_CANCEL:
767 edbm_bevel_cancel(C, op);
768 ED_workspace_status_text(C, nullptr);
769 return OPERATOR_CANCELLED;
770
772 edbm_bevel_calc(op);
773 edbm_bevel_exit(C, op);
774 ED_workspace_status_text(C, nullptr);
775 return OPERATOR_FINISHED;
776
778 opdata->segments = opdata->segments + 1;
779 RNA_int_set(op->ptr, "segments", int(opdata->segments));
780 edbm_bevel_calc(op);
782 handled = true;
783 break;
784
786 opdata->segments = max_ff(opdata->segments - 1, 1);
787 RNA_int_set(op->ptr, "segments", int(opdata->segments));
788 edbm_bevel_calc(op);
790 handled = true;
791 break;
792
794 int type = RNA_enum_get(op->ptr, "offset_type");
795 type++;
796 if (type > BEVEL_AMT_PERCENT) {
797 type = BEVEL_AMT_OFFSET;
798 }
799 if (opdata->value_mode == OFFSET_VALUE && type == BEVEL_AMT_PERCENT) {
801 }
802 else if (opdata->value_mode == OFFSET_VALUE_PERCENT && type != BEVEL_AMT_PERCENT) {
803 opdata->value_mode = OFFSET_VALUE;
804 }
805 RNA_enum_set(op->ptr, "offset_type", type);
806 if (opdata->initial_length[opdata->value_mode] == -1.0f) {
807 edbm_bevel_calc_initial_length(op, event, true);
808 }
809 }
810 /* Update offset accordingly to new offset_type. */
811 if (!has_numinput && ELEM(opdata->value_mode, OFFSET_VALUE, OFFSET_VALUE_PERCENT)) {
813 }
814 edbm_bevel_calc(op);
816 handled = true;
817 break;
818
820 bool clamp_overlap = RNA_boolean_get(op->ptr, "clamp_overlap");
821 RNA_boolean_set(op->ptr, "clamp_overlap", !clamp_overlap);
822 edbm_bevel_calc(op);
824 handled = true;
825 break;
826 }
827
829 opdata->value_mode = OFFSET_VALUE;
830 edbm_bevel_calc_initial_length(op, event, true);
831 break;
832
834 opdata->value_mode = PROFILE_VALUE;
835 edbm_bevel_calc_initial_length(op, event, true);
836 break;
837
839 opdata->value_mode = SEGMENTS_VALUE;
840 edbm_bevel_calc_initial_length(op, event, true);
841 break;
842
844 int affect_type = RNA_enum_get(op->ptr, "affect");
845 affect_type++;
846 if (affect_type > BEVEL_AFFECT_EDGES) {
847 affect_type = BEVEL_AFFECT_VERTICES;
848 }
849 RNA_enum_set(op->ptr, "affect", affect_type);
850 edbm_bevel_calc(op);
852 handled = true;
853 break;
854 }
855
857 bool mark_seam = RNA_boolean_get(op->ptr, "mark_seam");
858 RNA_boolean_set(op->ptr, "mark_seam", !mark_seam);
859 edbm_bevel_calc(op);
861 handled = true;
862 break;
863 }
864
866 bool mark_sharp = RNA_boolean_get(op->ptr, "mark_sharp");
867 RNA_boolean_set(op->ptr, "mark_sharp", !mark_sharp);
868 edbm_bevel_calc(op);
870 handled = true;
871 break;
872 }
873
875 int miter_inner = RNA_enum_get(op->ptr, "miter_inner");
876 miter_inner++;
877 if (miter_inner == BEVEL_MITER_PATCH) {
878 miter_inner++; /* no patch option for inner miter */
879 }
880 if (miter_inner > BEVEL_MITER_ARC) {
881 miter_inner = BEVEL_MITER_SHARP;
882 }
883 RNA_enum_set(op->ptr, "miter_inner", miter_inner);
884 edbm_bevel_calc(op);
886 handled = true;
887 break;
888 }
889
891 int miter_outer = RNA_enum_get(op->ptr, "miter_outer");
892 miter_outer++;
893 if (miter_outer > BEVEL_MITER_ARC) {
894 miter_outer = BEVEL_MITER_SHARP;
895 }
896 RNA_enum_set(op->ptr, "miter_outer", miter_outer);
897 edbm_bevel_calc(op);
899 handled = true;
900 break;
901 }
902
904 bool harden_normals = RNA_boolean_get(op->ptr, "harden_normals");
905 RNA_boolean_set(op->ptr, "harden_normals", !harden_normals);
906 edbm_bevel_calc(op);
908 handled = true;
909 break;
910 }
911
913 int profile_type = RNA_enum_get(op->ptr, "profile_type");
914 profile_type++;
915 if (profile_type > BEVEL_PROFILE_CUSTOM) {
916 profile_type = BEVEL_PROFILE_SUPERELLIPSE;
917 }
918 RNA_enum_set(op->ptr, "profile_type", profile_type);
919 edbm_bevel_calc(op);
921 handled = true;
922 break;
923 }
924
926 int vmesh_method = RNA_enum_get(op->ptr, "vmesh_method");
927 vmesh_method++;
928 if (vmesh_method > BEVEL_VMESH_CUTOFF) {
929 vmesh_method = BEVEL_VMESH_ADJ;
930 }
931 RNA_enum_set(op->ptr, "vmesh_method", vmesh_method);
932 edbm_bevel_calc(op);
934 handled = true;
935 break;
936 }
938 opdata->use_precision = true;
939 edbm_bevel_calc_initial_length(op, event, true);
941 handled = true;
942 break;
943 }
945 opdata->use_precision = false;
946 edbm_bevel_calc_initial_length(op, event, true);
948 handled = true;
949 break;
950 }
951 case BEV_MODAL_SNAP_ON: {
952 opdata->use_snap = true;
953 edbm_bevel_calc_initial_length(op, event, true);
955 handled = true;
956 break;
957 }
958 case BEV_MODAL_SNAP_OFF: {
959 opdata->use_snap = false;
960 edbm_bevel_calc_initial_length(op, event, true);
962 handled = true;
963 break;
964 }
965 }
966 }
967
968 /* Modal numinput inactive, try to handle numeric inputs last... */
969 if (!handled && eval == KM_PRESS &&
970 handleNumInput(C, &opdata->num_input[opdata->value_mode], event))
971 {
973 edbm_bevel_calc(op);
976 }
977
979}
980
982{
983 ui::Layout &layout = *op->layout;
984
985 int profile_type = RNA_enum_get(op->ptr, "profile_type");
986 int offset_type = RNA_enum_get(op->ptr, "offset_type");
987 bool affect_type = RNA_enum_get(op->ptr, "affect");
988
989 layout.use_property_split_set(true);
990 layout.use_property_decorate_set(false);
991
992 ui::Layout *row = &layout.row(false);
993 row->prop(op->ptr, "affect", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
994
995 layout.separator();
996
997 layout.prop(op->ptr, "offset_type", UI_ITEM_NONE, std::nullopt, ICON_NONE);
998
999 if (offset_type == BEVEL_AMT_PERCENT) {
1000 layout.prop(op->ptr, "offset_pct", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1001 }
1002 else {
1003 layout.prop(op->ptr, "offset", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1004 }
1005
1006 layout.prop(op->ptr, "segments", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1008 layout.prop(op->ptr,
1009 "profile",
1011 (profile_type == BEVEL_PROFILE_SUPERELLIPSE) ? IFACE_("Profile Shape") :
1012 IFACE_("Miter Profile Shape"),
1013 ICON_NONE);
1014 }
1015 layout.prop(op->ptr, "material", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1016
1017 ui::Layout *col = &layout.column(true);
1018 col->prop(op->ptr, "harden_normals", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1019 col->prop(op->ptr, "clamp_overlap", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1020 col->prop(op->ptr, "loop_slide", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1021
1022 col = &layout.column(true, IFACE_("Mark"));
1023 col->active_set(affect_type == BEVEL_AFFECT_EDGES);
1024 col->prop(op->ptr, "mark_seam", UI_ITEM_NONE, IFACE_("Seams"), ICON_NONE);
1025 col->prop(op->ptr, "mark_sharp", UI_ITEM_NONE, IFACE_("Sharp"), ICON_NONE);
1026
1027 layout.separator();
1028
1029 col = &layout.column(false);
1030 col->active_set(affect_type == BEVEL_AFFECT_EDGES);
1031 col->prop(op->ptr, "miter_outer", UI_ITEM_NONE, IFACE_("Miter Outer"), ICON_NONE);
1032 col->prop(op->ptr, "miter_inner", UI_ITEM_NONE, IFACE_("Inner"), ICON_NONE);
1033 if (RNA_enum_get(op->ptr, "miter_inner") == BEVEL_MITER_ARC) {
1034 col->prop(op->ptr, "spread", UI_ITEM_NONE, std::nullopt, ICON_NONE);
1035 }
1036
1037 layout.separator();
1038
1039 col = &layout.column(false);
1040 col->active_set(affect_type == BEVEL_AFFECT_EDGES);
1041 col->prop(op->ptr, "vmesh_method", UI_ITEM_NONE, IFACE_("Intersection Type"), ICON_NONE);
1042
1043 layout.prop(op->ptr, "face_strength_mode", UI_ITEM_NONE, IFACE_("Face Strength"), ICON_NONE);
1044
1045 layout.separator();
1046
1047 row = &layout.row(false);
1048 row->prop(op->ptr, "profile_type", ui::ITEM_R_EXPAND, std::nullopt, ICON_NONE);
1049 if (profile_type == BEVEL_PROFILE_CUSTOM) {
1050 /* Get an RNA pointer to ToolSettings to give to the curve profile template code. */
1051 Scene *scene = CTX_data_scene(C);
1052 PointerRNA toolsettings_ptr = RNA_pointer_create_discrete(
1053 &scene->id, RNA_ToolSettings, scene->toolsettings);
1054 template_curve_profile(&layout, &toolsettings_ptr, "custom_bevel_profile_preset");
1055 }
1056}
1057
1059{
1060 PropertyRNA *prop;
1061
1062 static const EnumPropertyItem offset_type_items[] = {
1063 {BEVEL_AMT_OFFSET, "OFFSET", 0, "Offset", "Amount is offset of new edges from original"},
1064 {BEVEL_AMT_WIDTH, "WIDTH", 0, "Width", "Amount is width of new face"},
1066 "DEPTH",
1067 0,
1068 "Depth",
1069 "Amount is perpendicular distance from original edge to bevel face"},
1070 {BEVEL_AMT_PERCENT, "PERCENT", 0, "Percent", "Amount is percent of adjacent edge length"},
1072 "ABSOLUTE",
1073 0,
1074 "Absolute",
1075 "Amount is absolute distance along adjacent edge"},
1076 {0, nullptr, 0, nullptr, nullptr},
1077 };
1078
1079 static const EnumPropertyItem prop_profile_type_items[] = {
1081 "SUPERELLIPSE",
1082 0,
1083 "Superellipse",
1084 "The profile can be a concave or convex curve"},
1086 "CUSTOM",
1087 0,
1088 "Custom",
1089 "The profile can be any arbitrary path between its endpoints"},
1090 {0, nullptr, 0, nullptr, nullptr},
1091 };
1092
1093 static const EnumPropertyItem face_strength_mode_items[] = {
1094 {BEVEL_FACE_STRENGTH_NONE, "NONE", 0, "None", "Do not set face strength"},
1095 {BEVEL_FACE_STRENGTH_NEW, "NEW", 0, "New", "Set face strength on new faces only"},
1097 "AFFECTED",
1098 0,
1099 "Affected",
1100 "Set face strength on new and modified faces only"},
1101 {BEVEL_FACE_STRENGTH_ALL, "ALL", 0, "All", "Set face strength on all faces"},
1102 {0, nullptr, 0, nullptr, nullptr},
1103 };
1104
1105 static const EnumPropertyItem miter_outer_items[] = {
1106 {BEVEL_MITER_SHARP, "SHARP", 0, "Sharp", "Outside of miter is sharp"},
1107 {BEVEL_MITER_PATCH, "PATCH", 0, "Patch", "Outside of miter is squared-off patch"},
1108 {BEVEL_MITER_ARC, "ARC", 0, "Arc", "Outside of miter is arc"},
1109 {0, nullptr, 0, nullptr, nullptr},
1110 };
1111
1112 static const EnumPropertyItem miter_inner_items[] = {
1113 {BEVEL_MITER_SHARP, "SHARP", 0, "Sharp", "Inside of miter is sharp"},
1114 {BEVEL_MITER_ARC, "ARC", 0, "Arc", "Inside of miter is arc"},
1115 {0, nullptr, 0, nullptr, nullptr},
1116 };
1117
1118 static const EnumPropertyItem vmesh_method_items[] = {
1119 {BEVEL_VMESH_ADJ, "ADJ", 0, "Grid Fill", "Default patterned fill"},
1121 "CUTOFF",
1122 0,
1123 "Cutoff",
1124 "A cutoff at each profile's end before the intersection"},
1125 {0, nullptr, 0, nullptr, nullptr},
1126 };
1127
1128 static const EnumPropertyItem prop_affect_items[] = {
1129 {BEVEL_AFFECT_VERTICES, "VERTICES", 0, "Vertices", "Affect only vertices"},
1130 {BEVEL_AFFECT_EDGES, "EDGES", 0, "Edges", "Affect only edges"},
1131 {0, nullptr, 0, nullptr, nullptr},
1132 };
1133
1134 /* identifiers */
1135 ot->name = "Bevel";
1136 ot->description = "Cut into selected items at an angle to create bevel or chamfer";
1137 ot->idname = "MESH_OT_bevel";
1138
1139 /* API callbacks. */
1140 ot->exec = edbm_bevel_exec;
1142 ot->modal = edbm_bevel_modal;
1145 ot->ui = edbm_bevel_ui;
1146
1147 /* flags */
1149
1150 /* properties */
1151 RNA_def_enum(ot->srna,
1152 "offset_type",
1153 offset_type_items,
1154 0,
1155 "Width Type",
1156 "The method for determining the size of the bevel");
1157 prop = RNA_def_property(ot->srna, "offset", PROP_FLOAT, PROP_DISTANCE);
1158 RNA_def_property_range(prop, 0.0, 1e6);
1159 RNA_def_property_ui_range(prop, 0.0, 100.0, 1, 3);
1160 RNA_def_property_ui_text(prop, "Width", "Bevel amount");
1161
1162 RNA_def_enum(ot->srna,
1163 "profile_type",
1164 prop_profile_type_items,
1165 0,
1166 "Profile Type",
1167 "The type of shape used to rebuild a beveled section");
1168
1169 prop = RNA_def_property(ot->srna, "offset_pct", PROP_FLOAT, PROP_PERCENTAGE);
1170 RNA_def_property_range(prop, 0.0, 100);
1171 RNA_def_property_ui_text(prop, "Width Percent", "Bevel amount for percentage method");
1172
1173 RNA_def_int(ot->srna,
1174 "segments",
1175 1,
1176 1,
1178 "Segments",
1179 "Segments for curved edge",
1180 1,
1181 100);
1182
1183 RNA_def_float(ot->srna,
1184 "profile",
1185 0.5f,
1187 1.0f,
1188 "Profile",
1189 "Controls profile shape (0.5 = round)",
1191 1.0f);
1192
1193 RNA_def_enum(ot->srna,
1194 "affect",
1195 prop_affect_items,
1197 "Affect",
1198 "Affect edges or vertices");
1199
1201 "clamp_overlap",
1202 false,
1203 "Clamp Overlap",
1204 "Do not allow beveled edges/vertices to overlap each other");
1205
1207 ot->srna, "loop_slide", true, "Loop Slide", "Prefer sliding along edges to even widths");
1208
1210 ot->srna, "mark_seam", false, "Mark Seams", "Preserve seams along beveled edges");
1212 ot->srna, "mark_sharp", false, "Mark Sharp", "Preserve sharp edges along beveled edges");
1213
1214 RNA_def_int(ot->srna,
1215 "material",
1216 -1,
1217 -1,
1218 INT_MAX,
1219 "Material Index",
1220 "Material for bevel faces (-1 means use adjacent faces)",
1221 -1,
1222 100);
1223
1225 "harden_normals",
1226 false,
1227 "Harden Normals",
1228 "Match normals of new faces to adjacent faces");
1229
1230 RNA_def_enum(ot->srna,
1231 "face_strength_mode",
1232 face_strength_mode_items,
1234 "Face Strength Mode",
1235 "Whether to set face strength, and which faces to set face strength on");
1236
1237 RNA_def_enum(ot->srna,
1238 "miter_outer",
1239 miter_outer_items,
1241 "Outer Miter",
1242 "Pattern to use for outside of miters");
1243
1244 RNA_def_enum(ot->srna,
1245 "miter_inner",
1246 miter_inner_items,
1248 "Inner Miter",
1249 "Pattern to use for inside of miters");
1250
1251 RNA_def_float(ot->srna,
1252 "spread",
1253 0.1f,
1254 0.0f,
1255 1e6f,
1256 "Spread",
1257 "Amount to spread arcs for arc inner miters",
1258 0.0f,
1259 100.0f);
1260
1261 RNA_def_enum(ot->srna,
1262 "vmesh_method",
1263 vmesh_method_items,
1265 "Vertex Mesh Method",
1266 "The method to use to create meshes at intersections");
1267
1268 prop = RNA_def_boolean(ot->srna, "release_confirm", false, "Confirm on Release", "");
1270}
1271
1272} // namespace blender
#define SNPRINTF_UTF8(dst, format,...)
#define IFACE_(msgid)
Object is a sort of wrapper for general info.
#define NUM_STR_REP_LEN
#define REGION_DRAW_POST_PIXEL
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define UI_ITEM_NONE
#define CLAMP(a, b, c)
#define ELEM(...)
void opmodal(std::string text, const wmOperatorType *ot, int propvalue, bool inverted=false)
Definition area.cc:1107
#define roundf(x)
#define PROFILE_VALUE
#define OFFSET_VALUE_PERCENT
#define SEGMENTS_HARD_MAX
#define OFFSET_VALUE
#define SEGMENTS_VALUE
#define MVAL_PIXEL_MARGIN
#define PROFILE_HARD_MIN
#define NUM_VALUE_KINDS
#define FLT_MIN
#define INT_MAX
float3x3 scale(float3x3 mat, float2 scale)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
bool calculateTransformCenter(bContext *C, int centerMode, float cent3d[3], float cent2d[2])
BMesh Iterators.
void EDBM_flag_disable_all(BMesh *bm, char hflag)
UserDef U
Definition blender.cc:58
ScrArea * CTX_wm_area(const bContext *C)
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description)
@ BEVEL_FACE_STRENGTH_ALL
@ BEVEL_FACE_STRENGTH_NEW
@ BEVEL_FACE_STRENGTH_NONE
@ BEVEL_FACE_STRENGTH_AFFECTED
int RNA_enum_get(PointerRNA *ptr, const char *name)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void EDBM_selectmode_flush(BMesh *bm, short selectmode)
void void void EDBM_redo_state_free(BMBackup *backup) ATTR_NONNULL(1)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
Definition wm_keymap.cc:999
BMesh * BKE_editmesh_bmesh_get_for_write(Mesh *mesh)
Definition editmesh.cc:79
bool handleNumInput(bContext *C, NumInput *n, const wmEvent *event)
Definition numinput.cc:344
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.
bool EDBM_op_init(BMesh *bm, BMOperator *bmop, wmOperator *op, const char *fmt,...)
static const float value_clamp_max[NUM_VALUE_KINDS]
float mat4_to_scale(const float mat[4][4])
BMBackup EDBM_redo_state_store(BMesh *bm)
float ED_view3d_pixel_size(const RegionView3D *rv3d, const float co[3])
void EDBM_update(Mesh *mesh, const EDBMUpdate_Params *params)
int RNA_property_enum_get(PointerRNA *ptr, PropertyRNA *prop)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
@ V3D_AROUND_CENTER_MEDIAN
static const float value_snap_increments[NUM_VALUE_KINDS]
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
static const float value_clamp_min[NUM_VALUE_KINDS]
int RNA_int_get(PointerRNA *ptr, const char *name)
static float get_bevel_offset(wmOperator *op)
bool hasNumInput(const NumInput *n)
Definition numinput.cc:188
static bool edbm_bevel_calc(wmOperator *op)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
void BMO_op_exec(BMesh *bm, BMOperator *op)
BMESH OPSTACK EXEC OP.
void ED_region_tag_redraw(ARegion *region)
Definition area.cc:681
bool EDBM_automerge_connected(Object *obedit, bool update, char hflag, float dist)
ViewLayer * CTX_data_view_layer(const bContext *C)
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
Global G
Definition blender.cc:57
bool RNA_property_enum_name_gettexted(bContext *C, PointerRNA *ptr, PropertyRNA *prop, const int value, const char **r_name)
PropertyRNA * RNA_def_property(StructOrFunctionRNA *cont_, const char *identifier_c_str, int type, int subtype)
static bool edbm_bevel_init(bContext *C, wmOperator *op, const bool is_modal)
static wmOperatorStatus edbm_bevel_exec(bContext *C, wmOperator *op)
bool ED_operator_editmesh(bContext *C)
bool EDBM_op_finish(BMesh *bm, BMOperator *bmop, wmOperator *op, const bool do_report)
void * ED_region_draw_cb_activate(ARegionType *art, void(*draw)(const bContext *, ARegion *, void *), void *customdata, int type)
static const float value_start[NUM_VALUE_KINDS]
bool ED_region_draw_cb_exit(ARegionType *art, void *handle)
void MESH_OT_bevel(wmOperatorType *ot)
@ BEV_MODAL_AFFECT_CHANGE
@ BEV_MODAL_SEGMENTS_UP
@ BEV_MODAL_OFFSET_MODE_CHANGE
@ BEV_MODAL_VALUE_OFFSET
@ BEV_MODAL_INNER_MITER_CHANGE
@ BEV_MODAL_HARDEN_NORMALS_TOGGLE
@ BEV_MODAL_SEGMENTS_DOWN
@ BEV_MODAL_CLAMP_OVERLAP_TOGGLE
@ BEV_MODAL_OUTER_MITER_CHANGE
@ BEV_MODAL_MARK_SEAM_TOGGLE
@ BEV_MODAL_MARK_SHARP_TOGGLE
@ BEV_MODAL_PRECISION_OFF
@ BEV_MODAL_VALUE_PROFILE
@ BEV_MODAL_VALUE_SEGMENTS
@ BEV_MODAL_PROFILE_TYPE_CHANGE
@ BEV_MODAL_VERTEX_MESH_CHANGE
@ BEV_MODAL_PRECISION_ON
wmKeyMap * bevel_modal_keymap(wmKeyConfig *keyconf)
static const float value_scale_per_inch[NUM_VALUE_KINDS]
void initNumInput(NumInput *n)
Definition numinput.cc:85
void RNA_def_property_range(PropertyRNA *prop, double min, double max)
static void edbm_bevel_cancel(bContext *C, wmOperator *op)
static const float value_increments_precision_factors[NUM_VALUE_KINDS]
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
static void edbm_bevel_numinput_set_value(wmOperator *op)
static void edbm_bevel_mouse_set_value(wmOperator *op, const wmEvent *event)
static void edbm_bevel_update_status_text(bContext *C, wmOperator *op)
void ED_area_status_text(ScrArea *area, const char *str)
Definition area.cc:975
RegionView3D * CTX_wm_region_view3d(const bContext *C)
ToolSettings * CTX_data_tool_settings(const bContext *C)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
static wmOperatorStatus edbm_bevel_invoke(bContext *C, wmOperator *op, const wmEvent *event)
size_t BKE_unit_value_as_string_scaled(char *str, int str_maxncpy, double value, int prec, int type, const UnitSettings &settings, bool pad, bool do_unit_suffix)
Definition unit.cc:1944
void RNA_float_set(PointerRNA *ptr, const char *name, float value)
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
bool applyNumInput(NumInput *n, float *vec)
Definition numinput.cc:207
BMEditMesh * BKE_editmesh_from_object(Object *ob)
Return the BMEditMesh for a given object.
Definition editmesh.cc:59
static void edbm_bevel_ui(bContext *C, wmOperator *op)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
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_redo_state_restore(BMBackup *backup, BMEditMesh *em, BMesh *bm, bool recalc_looptris) ATTR_NONNULL(1
Main * CTX_data_main(const bContext *C)
MINLINE float max_ff(float a, float b)
@ PROP_SKIP_SAVE
Definition RNA_types.hh:414
@ PROP_HIDDEN
Definition RNA_types.hh:408
Vector< Object * > BKE_view_layer_array_from_objects_in_edit_mode_unique_data(const Main &bmain, const Scene *scene, ViewLayer *view_layer, const View3D *v3d)
static wmOperatorStatus edbm_bevel_modal(bContext *C, wmOperator *op, const wmEvent *event)
static void edbm_bevel_calc_initial_length(wmOperator *op, const wmEvent *event, bool mode_changed)
@ BEVEL_PROFILE_SUPERELLIPSE
const BMesh * BKE_editmesh_bmesh_get(const Object *ob)
Definition editmesh.cc:65
@ G_TRANSFORM_EDIT
@ KM_RELEASE
Definition WM_types.hh:325
static const char * value_rna_name[NUM_VALUE_KINDS]
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
bool EDBM_uvselect_clear(BMesh *bm)
Scene * CTX_data_scene(const bContext *C)
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
Definition wm_keymap.cc:972
@ OPTYPE_REGISTER
Definition WM_types.hh:188
@ OPTYPE_UNDO
Definition WM_types.hh:190
@ OPTYPE_BLOCKING
Definition WM_types.hh:192
@ OPTYPE_GRAB_CURSOR_XY
Definition WM_types.hh:196
void void EDBM_redo_state_restore_and_free(BMBackup *backup, BMEditMesh *em, BMesh *bm, bool recalc_looptris) ATTR_NONNULL(1
void ED_region_draw_mouse_line_cb(const bContext *C, ARegion *region, void *arg_info)
Definition ed_draw.cc:672
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
@ PROP_PERCENTAGE
Definition RNA_types.hh:307
@ PROP_DISTANCE
Definition RNA_types.hh:313
int WM_userdef_event_type_from_keymap_type(int kmitype)
@ B_UNIT_LENGTH
Definition BKE_unit.hh:166
@ B_UNIT_NONE
Definition BKE_unit.hh:165
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
ARegion * CTX_wm_region(const bContext *C)
void ED_workspace_status_text(bContext *C, const char *str)
Definition area.cc:1153
float RNA_float_get(PointerRNA *ptr, const char *name)
View3D * CTX_wm_view3d(const bContext *C)
static void edbm_bevel_exit(bContext *C, wmOperator *op)
void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode, BMSelectFlushFlag flag)
Select Mode Flush.
@ NUM_NO_NEGATIVE
@ NUM_NO_FRACTION
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
bke::ARegionRuntime * runtime
struct BMOpSlot slots_out[BMO_OP_MAX_SLOTS]
float scale[NUM_VALUE_KINDS]
NumInput num_input[NUM_VALUE_KINDS]
Vector< BevelObjectStore > ob_store
CurveProfile * custom_profile
float initial_length[NUM_VALUE_KINDS]
float shift_value[NUM_VALUE_KINDS]
int unit_type[NUM_MAX_ELEMENTS]
short val_flag[NUM_MAX_ELEMENTS]
struct UnitSettings unit
struct ToolSettings * toolsettings
struct CurveProfile * custom_bevel_profile_preset
struct ARegionType * type
void use_property_decorate_set(bool is_decorate)
void use_property_split_set(bool is_sep)
void prop(PointerRNA *ptr, PropertyRNA *prop, int index, int value, eUI_Item_Flag flag, std::optional< StringRef > name_opt, int icon, std::optional< StringRef > placeholder=std::nullopt)
void active_set(bool active)
Layout & column(bool align)
void separator(float factor=1.0f, LayoutSeparatorType type=LayoutSeparatorType::Auto)
Layout & row(bool align)
wmEventType type
Definition WM_types.hh:817
wmOperatorStatus(*) exec(bContext *C, wmOperator *op) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1125
const char * description
Definition WM_types.hh:1115
void(*) cancel(bContext *C, wmOperator *op)
Definition WM_types.hh:1149
void(*) ui(bContext *C, wmOperator *op)
Definition WM_types.hh:1176
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1165
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1141
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
Definition WM_types.hh:1157
struct wmOperatorType * type