Blender V5.3
transform_gizmo_extrude_3d.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
10#include "BLI_listbase.hh"
11#include "BLI_math_matrix_c.hh"
12#include "BLI_math_vector_c.hh"
13#include "BLI_utildefines.hh"
14
15#include "BKE_context.hh"
16#include "BKE_global.hh"
17#include "BKE_scene.hh"
18
19#include "RNA_access.hh"
20#include "RNA_define.hh"
21
22#include "WM_api.hh"
23#include "WM_message.hh"
24#include "WM_toolsystem.hh"
25#include "WM_types.hh"
26
27#include "ED_gizmo_library.hh"
28#include "ED_gizmo_utils.hh"
29#include "ED_screen.hh"
30#include "ED_transform.hh"
31
32#include "UI_resources.hh"
33
34#include "MEM_guardedalloc.h"
35
36namespace blender::ed::transform {
37
38/* -------------------------------------------------------------------- */
41
42enum {
45};
46
47static const float extrude_button_scale = 0.15f;
48static const float extrude_button_offset_scale = 1.5f;
49static const float extrude_outer_scale = 1.2f;
50static const float extrude_arrow_scale = 0.7f;
51static const float extrude_arrow_xyz_axis_scale = 0.6666f;
52static const float extrude_arrow_normal_axis_scale = 0.6666f;
53static const float extrude_dial_scale = 0.2;
54
55static const uchar shape_plus[] = {
56 0x73, 0x73, 0x73, 0x36, 0x8c, 0x36, 0x8c, 0x73, 0xc9, 0x73, 0xc9, 0x8c, 0x8c,
57 0x8c, 0x8c, 0xc9, 0x73, 0xc9, 0x73, 0x8c, 0x36, 0x8c, 0x36, 0x73, 0x36, 0x73,
58};
59
61
62 /* XYZ & normal. */
64 /* Only visible when 'drag' tool option is disabled. */
66 /* Constrained & unconstrained (arrow & circle). */
69
70 /* Copied from the transform operator,
71 * use to redo with the same settings. */
72 struct {
73 float orient_matrix[3][3];
74 bool constraint_axis[3];
75 float value[4];
76 int orient_type;
78
79 /* Depends on object type. */
81
82 struct {
83 float normal_mat3[3][3]; /* Use Z axis for normal. */
86
89};
90
92 const float mat[3][3])
93{
94 for (int i = 0; i < 3; i++) {
96 mat[i],
99 }
100}
101
103 const float mat[3][3])
104{
105 /* Set orientation without location. */
106 for (int j = 0; j < 3; j++) {
107 copy_v3_v3(ggd->adjust[0]->matrix_basis[j], mat[j]);
108 }
109 /* NOP when (i == 2). */
110 swap_v3_v3(ggd->adjust[0]->matrix_basis[ggd->adjust_axis], ggd->adjust[0]->matrix_basis[2]);
111}
112
113static void gizmo_mesh_extrude_setup(const bContext *C, wmGizmoGroup *gzgroup)
114{
116 gzgroup->customdata = ggd;
117
118 const wmGizmoType *gzt_arrow = WM_gizmotype_find("GIZMO_GT_arrow_3d", true);
119 const wmGizmoType *gzt_move = WM_gizmotype_find("GIZMO_GT_button_2d", true);
120 const wmGizmoType *gzt_dial = WM_gizmotype_find("GIZMO_GT_dial_3d", true);
121
122 ggd->adjust[0] = WM_gizmo_new_ptr(gzt_arrow, gzgroup, nullptr);
123 ggd->adjust[1] = WM_gizmo_new_ptr(gzt_dial, gzgroup, nullptr);
125
126 for (int i = 0; i < 4; i++) {
127 ggd->invoke_xyz_no[i] = WM_gizmo_new_ptr(gzt_move, gzgroup, nullptr);
129 }
130
131 {
132 ggd->invoke_view = WM_gizmo_new_ptr(gzt_dial, gzgroup, nullptr);
133 ggd->invoke_view->select_bias = -2.0f;
135 }
136
137 {
138 PropertyRNA *prop = RNA_struct_find_property(ggd->invoke_xyz_no[3]->ptr, "shape");
139 for (int i = 0; i < 4; i++) {
141 prop,
142 reinterpret_cast<const char *>(shape_plus),
144 }
145 }
146
147 {
148 const char *op_idname = nullptr;
149 /* Grease pencil does not use `obedit`. */
150 /* GPXX: Remove if #OB_MODE_EDIT_GPENCIL_LEGACY is merged with #OB_MODE_EDIT. */
151 const Object *obact = CTX_data_active_object(C);
152 if (obact->type == OB_MESH) {
153 op_idname = "MESH_OT_extrude_context_move";
154 ggd->normal_axis = 2;
155 }
156 else if (obact->type == OB_ARMATURE) {
157 op_idname = "ARMATURE_OT_extrude_move";
158 ggd->normal_axis = 1;
159 }
160 else if (obact->type == OB_CURVES_LEGACY) {
161 op_idname = "CURVE_OT_extrude_move";
162 ggd->normal_axis = 2;
163 }
164 else {
165 BLI_assert(0);
166 }
167 ggd->ot_extrude = WM_operatortype_find(op_idname, true);
168 ggd->gzgt_axis_type_prop = RNA_struct_type_find_property(gzgroup->type->srna, "axis_type");
169 }
170
171 for (int i = 0; i < 3; i++) {
173 }
175 ggd->invoke_view->color[3] = 0.5f;
176
177 for (int i = 0; i < 2; i++) {
179 }
180
181 for (int i = 0; i < 4; i++) {
183 }
185 ggd->invoke_view->line_width = 2.0f;
186
189 ggd->adjust[1]->line_width = 2.0f;
190
191 /* XYZ & normal axis extrude. */
192 for (int i = 0; i < 4; i++) {
193 PointerRNA *ptr = WM_gizmo_operator_set(ggd->invoke_xyz_no[i], 0, ggd->ot_extrude, nullptr);
194 {
195 bool constraint[3] = {false, false, false};
196 constraint[(i < 3) ? i : ggd->normal_axis] = true;
197 PointerRNA macroptr = RNA_pointer_get(ptr, "TRANSFORM_OT_translate");
198 RNA_boolean_set(&macroptr, "release_confirm", true);
199 RNA_boolean_set_array(&macroptr, "constraint_axis", constraint);
200 }
201 }
202
203 {
204 PointerRNA *ptr = WM_gizmo_operator_set(ggd->invoke_view, 0, ggd->ot_extrude, nullptr);
205 PointerRNA macroptr = RNA_pointer_get(ptr, "TRANSFORM_OT_translate");
206 RNA_boolean_set(&macroptr, "release_confirm", true);
207
208 const bool constraint[3] = {false, false, false};
209 RNA_boolean_set_array(&macroptr, "constraint_axis", constraint);
210 }
211
212 /* Adjust extrude. */
213 for (int i = 0; i < 2; i++) {
214 wmGizmo *gz = ggd->adjust[i];
215 PointerRNA *ptr = WM_gizmo_operator_set(gz, 0, ggd->ot_extrude, nullptr);
216 PointerRNA macroptr = RNA_pointer_get(ptr, "TRANSFORM_OT_translate");
217 RNA_boolean_set(&macroptr, "release_confirm", true);
219 gzop->is_redo = true;
220 }
221}
222
224{
225 GizmoExtrudeGroup *ggd = static_cast<GizmoExtrudeGroup *>(gzgroup->customdata);
226
227 for (int i = 0; i < 4; i++) {
229 }
231 for (int i = 0; i < 2; i++) {
233 }
234
235 if (G.moving) {
236 return;
237 }
238
239 Scene *scene = CTX_data_scene(C);
240 RegionView3D *rv3d = static_cast<RegionView3D *>(CTX_wm_region_data(C));
241
242 int axis_type;
243 {
244 PointerRNA ptr;
245 bToolRef *tref = WM_toolsystem_ref_from_context(const_cast<bContext *>(C));
247 axis_type = RNA_property_enum_get(&ptr, ggd->gzgt_axis_type_prop);
248 }
249
250 ggd->data.orientation_index = BKE_scene_orientation_get_index(scene, SCE_ORIENT_DEFAULT);
251 const bool use_normal = ((ggd->data.orientation_index != V3D_ORIENT_NORMAL) ||
252 (axis_type == EXTRUDE_AXIS_NORMAL));
253 const int axis_len_used = use_normal ? 4 : 3;
254
255 TransformBounds tbounds;
256
257 if (use_normal) {
258 TransformBounds tbounds_normal;
259 TransformCalcParams params{};
261 if (!calc_gizmo_stats(C, &params, &tbounds_normal, rv3d)) {
262 unit_m3(tbounds_normal.axis);
263 }
264 copy_m3_m3(ggd->data.normal_mat3, tbounds_normal.axis);
265 }
266
267 /* TODO(@ideasman42): run second since this modifies the 3D view, it should not. */
268 TransformCalcParams params{};
269 params.orientation_index = ggd->data.orientation_index + 1;
270 if (!calc_gizmo_stats(C, &params, &tbounds, rv3d)) {
271 return;
272 }
273
274 /* Main axis is normal. */
275 if (!use_normal) {
276 copy_m3_m3(ggd->data.normal_mat3, tbounds.axis);
277 }
278
279 /* Offset the add icon. */
281 ggd->data.normal_mat3[ggd->normal_axis],
284
285 /* Adjust current operator. */
286 /* Don't use 'WM_operator_last_redo' because selection actions will be ignored. */
288 bool has_redo = (op && op->type == ggd->ot_extrude);
289 wmOperator *op_xform = has_redo ? op->macro.last() : nullptr;
290
291 bool adjust_is_flip = false;
292 wmGizmo *gz_adjust = nullptr;
293
294 if (has_redo) {
295 gz_adjust = ggd->adjust[1];
296 /* We can't access this from 'ot->last_properties'
297 * because some properties use skip-save. */
298 RNA_float_get_array(op_xform->ptr, "orient_matrix", &ggd->redo_xform.orient_matrix[0][0]);
299 RNA_boolean_get_array(op_xform->ptr, "constraint_axis", ggd->redo_xform.constraint_axis);
300 RNA_float_get_array(op_xform->ptr, "value", ggd->redo_xform.value);
301 ggd->redo_xform.orient_type = RNA_enum_get(op_xform->ptr, "orient_type");
302
303 /* Set properties for redo. */
304 for (int i = 0; i < 3; i++) {
305 if (ggd->redo_xform.constraint_axis[i]) {
306 adjust_is_flip = ggd->redo_xform.value[i] < 0.0f;
307 ggd->adjust_axis = i;
308 gz_adjust = ggd->adjust[0];
309 break;
310 }
311 }
312 }
313
314 /* Needed for normal orientation. */
316
317 /* Location. */
318 for (int i = 0; i < axis_len_used; i++) {
320 }
322 /* Un-hide. */
323 for (int i = 0; i < axis_len_used; i++) {
325 }
326
327 if (has_redo) {
328 if (gz_adjust == ggd->adjust[0]) {
330 if (adjust_is_flip) {
331 negate_v3(ggd->adjust[0]->matrix_basis[2]);
332 }
333 }
334 WM_gizmo_set_matrix_location(gz_adjust, tbounds.center);
335 WM_gizmo_set_flag(gz_adjust, WM_GIZMO_HIDDEN, false);
336 }
337
338 /* Redo with current settings. */
339 if (has_redo) {
340 for (int i = 0; i < 4; i++) {
342 "draw_options",
344 (((gz_adjust == ggd->adjust[0]) &&
345 dot_v3v3(ggd->adjust[0]->matrix_basis[2],
346 ggd->invoke_xyz_no[i]->matrix_offset[3]) > 0.98f) ?
347 0 :
349 }
350 }
351 else {
352 for (int i = 0; i < 4; i++) {
354 "draw_options",
356 }
357 }
358
359 /* TODO: skip calculating axis which won't be used (above). */
360 switch (axis_type) {
362 for (int i = 0; i < 3; i++) {
364 }
365 break;
366 case EXTRUDE_AXIS_XYZ:
368 break;
369 }
370
373 }
374 else {
376 }
377}
378
380{
381 GizmoExtrudeGroup *ggd = static_cast<GizmoExtrudeGroup *>(gzgroup->customdata);
382 switch (ggd->data.orientation_index) {
383 case V3D_ORIENT_VIEW: {
385 float mat[3][3];
386 copy_m3_m4(mat, rv3d->viewinv);
387 normalize_m3(mat);
389 break;
390 }
391 }
392
393 /* Basic ordering for drawing only. */
394 {
396 for (wmGizmo &gz : gzgroup->gizmos) {
397 gz.temp.f = dot_v3v3(rv3d->viewinv[2], gz.matrix_offset[3]);
398 }
400
401 if ((ggd->adjust[1]->flag & WM_GIZMO_HIDDEN) == 0) {
402 copy_v3_v3(ggd->adjust[1]->matrix_basis[0], rv3d->viewinv[0]);
403 copy_v3_v3(ggd->adjust[1]->matrix_basis[1], rv3d->viewinv[1]);
404 copy_v3_v3(ggd->adjust[1]->matrix_basis[2], rv3d->viewinv[2]);
405 }
406 if ((ggd->invoke_view->flag & WM_GIZMO_HIDDEN) == 0) {
407 copy_v3_v3(ggd->invoke_view->matrix_basis[0], rv3d->viewinv[0]);
408 copy_v3_v3(ggd->invoke_view->matrix_basis[1], rv3d->viewinv[1]);
409 copy_v3_v3(ggd->invoke_view->matrix_basis[2], rv3d->viewinv[2]);
410 }
411 }
412}
413
415 wmGizmoGroup *gzgroup,
416 wmGizmo *gz,
417 const wmEvent * /*event*/)
418{
419 GizmoExtrudeGroup *ggd = static_cast<GizmoExtrudeGroup *>(gzgroup->customdata);
420 if (ELEM(gz, ggd->adjust[0], ggd->adjust[1])) {
421 /* Set properties for redo. */
423 PointerRNA macroptr = RNA_pointer_get(&gzop->ptr, "TRANSFORM_OT_translate");
424 if (gz == ggd->adjust[0]) {
425 RNA_boolean_set_array(&macroptr, "constraint_axis", ggd->redo_xform.constraint_axis);
426 RNA_float_set_array(&macroptr, "orient_matrix", &ggd->redo_xform.orient_matrix[0][0]);
427 RNA_enum_set(&macroptr, "orient_matrix_type", ggd->redo_xform.orient_type);
428 RNA_enum_set(&macroptr, "orient_type", ggd->redo_xform.orient_type);
429 }
430 RNA_float_set_array(&macroptr, "value", ggd->redo_xform.value);
431 }
432 else if (gz == ggd->invoke_view) {
433 /* Pass. */
434 }
435 else {
436 /* Workaround for extrude action modifying normals. */
437 const int i = BLI_array_findindex(ggd->invoke_xyz_no, ARRAY_SIZE(ggd->invoke_xyz_no), &gz);
438 BLI_assert(i != -1);
439 bool use_normal_matrix = false;
440 if (i == 3) {
441 use_normal_matrix = true;
442 }
443 else if (ggd->data.orientation_index == V3D_ORIENT_NORMAL) {
444 use_normal_matrix = true;
445 }
446 if (use_normal_matrix) {
448 PointerRNA macroptr = RNA_pointer_get(&gzop->ptr, "TRANSFORM_OT_translate");
449 RNA_float_set_array(&macroptr, "orient_matrix", &ggd->data.normal_mat3[0][0]);
450 RNA_enum_set(&macroptr, "orient_type", V3D_ORIENT_NORMAL);
451 }
452 }
453}
454
456 wmGizmoGroup *gzgroup,
457 wmMsgBus *mbus)
458{
459 GizmoExtrudeGroup *ggd = static_cast<GizmoExtrudeGroup *>(gzgroup->customdata);
460 ARegion *region = CTX_wm_region(C);
461
462 /* Subscribe to view properties. */
463 wmMsgSubscribeValue msg_sub_value_gz_tag_refresh{};
464 msg_sub_value_gz_tag_refresh.owner = region;
465 msg_sub_value_gz_tag_refresh.user_data = gzgroup->parent_gzmap;
466 msg_sub_value_gz_tag_refresh.notify = WM_gizmo_do_msg_notify_tag_refresh;
467
468 {
470 mbus, TransformOrientationSlot, type, &msg_sub_value_gz_tag_refresh);
471 }
472
473 wmMsgParams_RNA params{};
474 params.ptr.type = gzgroup->type->srna;
475 params.prop = ggd->gzgt_axis_type_prop;
476 WM_msg_subscribe_rna_params(mbus, &params, &msg_sub_value_gz_tag_refresh, __func__);
477
478 {
479 Scene *scene = CTX_data_scene(C);
480 PointerRNA toolsettings_ptr = RNA_pointer_create_discrete(
481 &scene->id, RNA_ToolSettings, scene->toolsettings);
482 const PropertyRNA *props[] = {
483 &rna_ToolSettings_workspace_tool_type,
484 };
485 for (int i = 0; i < ARRAY_SIZE(props); i++) {
487 mbus, &toolsettings_ptr, props[i], &msg_sub_value_gz_tag_refresh, __func__);
488 }
489 }
490}
491
493{
494 gzgt->name = "3D View Extrude";
495 gzgt->idname = "VIEW3D_GGT_xform_extrude";
496
499
502
510
511 static const EnumPropertyItem axis_type_items[] = {
512 {EXTRUDE_AXIS_NORMAL, "NORMAL", 0, "Normal", "Only show normal axis"},
513 {EXTRUDE_AXIS_XYZ, "XYZ", 0, "XYZ", "Follow scene orientation"},
514 {0, nullptr, 0, nullptr, nullptr},
515 };
516 RNA_def_enum(gzgt->srna, "axis_type", axis_type_items, 0, "Axis Type", "");
517}
518
520
521} // namespace blender::ed::transform
Generic array manipulation API.
#define BLI_array_findindex(arr, arr_len, p)
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define WM_toolsystem_ref_properties_ensure_from_gizmo_group(tref, gzgroup, r_ptr)
#define ELEM(...)
static void gizmo_mesh_extrude_invoke_prepare(const bContext *, wmGizmoGroup *gzgroup, wmGizmo *gz, const wmEvent *)
static const float extrude_arrow_xyz_axis_scale
static void gizmo_mesh_extrude_orientation_matrix_set(GizmoExtrudeGroup *ggd, const float mat[3][3])
static void gizmo_mesh_extrude_message_subscribe(const bContext *C, wmGizmoGroup *gzgroup, wmMsgBus *mbus)
static const float extrude_button_offset_scale
static const float extrude_arrow_normal_axis_scale
static void gizmo_mesh_extrude_refresh(const bContext *C, wmGizmoGroup *gzgroup)
void VIEW3D_GGT_xform_extrude(wmGizmoGroupType *gzgt)
static void gizmo_mesh_extrude_orientation_matrix_set_for_adjust(GizmoExtrudeGroup *ggd, const float mat[3][3])
static void gizmo_mesh_extrude_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
static void gizmo_mesh_extrude_setup(const bContext *C, wmGizmoGroup *gzgroup)
int calc_gizmo_stats(const bContext *C, const TransformCalcParams *params, TransformBounds *tbounds, RegionView3D *rv3d)
void get_color_3fv(int colorid, float col[3])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void RNA_float_set_array(PointerRNA *ptr, const char *name, const float *values)
int RNA_enum_get(PointerRNA *ptr, const char *name)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
void WM_gizmo_do_msg_notify_tag_refresh(bContext *, wmMsgSubscribeKey *, wmMsgSubscribeValue *msg_val)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void copy_m3_m4(float m1[3][3], const float m2[4][4])
void RNA_property_string_set_bytes(PointerRNA *ptr, PropertyRNA *prop, const char *value, int len)
void copy_m3_m3(float m1[3][3], const float m2[3][3])
int WM_gizmo_cmp_temp_fl_reverse(const void *gz_a_ptr, const void *gz_b_ptr)
const wmGizmoType * WM_gizmotype_find(const StringRef idname, bool quiet)
void normalize_m3(float R[3][3]) ATTR_NONNULL()
int RNA_property_enum_get(PointerRNA *ptr, PropertyRNA *prop)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
int BKE_scene_orientation_get_index(Scene *scene, int slot_index)
Definition scene.cc:2678
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
void RNA_boolean_get_array(PointerRNA *ptr, const char *name, bool *values)
void WM_msg_subscribe_rna_params(wmMsgBus *mbus, const wmMsgParams_RNA *msg_key_params, const wmMsgSubscribeValue *msg_val_params, const char *id_repr)
void * CTX_wm_region_data(const bContext *C)
void WM_gizmo_set_scale(wmGizmo *gz, const float scale)
Definition wm_gizmo.cc:313
Global G
Definition blender.cc:57
void WM_gizmo_set_flag(wmGizmo *gz, const int flag, const bool enable)
Definition wm_gizmo.cc:303
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
unsigned char uchar
Definition BKE_text.h:58
MINLINE void swap_v3_v3(float a[3], float b[3])
BMesh const char void * data
wmWindowManager * CTX_wm_manager(const bContext *C)
PointerRNA * WM_gizmo_operator_set(wmGizmo *gz, int part_index, wmOperatorType *ot, IDProperty *properties)
Definition wm_gizmo.cc:199
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
MINLINE void negate_v3(float r[3])
PointerRNA RNA_pointer_create_discrete(ID *id, StructRNA *type, void *data)
PropertyRNA * RNA_struct_type_find_property(StructRNA *srna, const char *identifier)
RegionView3D * CTX_wm_region_view3d(const bContext *C)
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
PointerRNA RNA_pointer_get(PointerRNA *ptr, const char *name)
void void BLI_listbase_sort(ListBase *listbase, int(*cmp)(const void *, const void *)) ATTR_NONNULL(1
Definition listbase.cc:319
@ SCE_WORKSPACE_TOOL_FALLBACK
void RNA_boolean_set_array(PointerRNA *ptr, const char *name, const bool *values)
void WM_msg_subscribe_rna(wmMsgBus *mbus, PointerRNA *ptr, const PropertyRNA *prop, const wmMsgSubscribeValue *msg_val_params, const char *id_repr)
@ WM_GIZMOGROUPTYPE_DELAY_REFRESH_FOR_TWEAK
@ WM_GIZMOGROUPTYPE_TOOL_FALLBACK_KEYMAP
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
@ WM_GIZMO_DRAW_OFFSET_SCALE
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
void unit_m3(float m[3][3])
bToolRef * WM_toolsystem_ref_from_context(const bContext *C)
Scene * CTX_data_scene(const bContext *C)
wmKeyMap * WM_gizmogroup_setup_keymap_generic_maybe_drag(const wmGizmoGroupType *, wmKeyConfig *kc)
wmGizmoOpElem * WM_gizmo_operator_get(wmGizmo *gz, int part_index)
Definition wm_gizmo.cc:191
bool ED_gizmo_poll_or_unlink_delayed_from_tool(const bContext *C, wmGizmoGroupType *gzgt)
void WM_gizmo_set_matrix_location(wmGizmo *gz, const float origin[3])
Definition wm_gizmo.cc:283
@ ED_GIZMO_BUTTON_SHOW_BACKDROP
@ ED_GIZMO_BUTTON_SHOW_HELPLINE
wmGizmo * WM_gizmo_new_ptr(const wmGizmoType *gzt, wmGizmoGroup *gzgroup, PointerRNA *properties)
Definition wm_gizmo.cc:84
Object * CTX_data_active_object(const bContext *C)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
ARegion * CTX_wm_region(const bContext *C)
void RNA_float_get_array(PointerRNA *ptr, const char *name, float *values)
@ ED_GIZMO_DIAL_DRAW_FLAG_FILL_SELECT
StructRNA * type
Definition RNA_types.hh:63
struct ToolSettings * toolsettings
ListBaseT< wmOperator > operators
struct blender::ed::transform::GizmoExtrudeGroup::@125026335333032242107216230126355206175201350104 data
struct blender::ed::transform::GizmoExtrudeGroup::@153004366075260041223104153321252211044373324124 redo_xform
wmGizmoGroupFnMsgBusSubscribe message_subscribe
wmGizmoGroupFnRefresh refresh
wmGizmoGroupFnInvokePrepare invoke_prepare
wmGizmoGroupFnSetupKeymap setup_keymap
wmGizmoMapType_Params gzmap_params
wmGizmoGroupFnDrawPrepare draw_prepare
eWM_GizmoFlagGroupTypeFlag flag
wmGizmoGroupType * type
ListBaseT< wmGizmo > gizmos
float matrix_basis[4][4]
float matrix_offset[4][4]
eWM_GizmoFlag flag
union blender::wmGizmo::@207216221077365030243271316333035277144006330157 temp
const PropertyRNA * prop
ListBaseT< wmOperator > macro
struct wmOperatorType * type
bke::WindowManagerRuntime * runtime
#define WM_msg_subscribe_rna_anon_prop(mbus, type_, prop_, value)