UI: use consistent "Color Burn" name for blend mode
[blender.git] / source / blender / editors / gizmo_library / gizmo_types / dial3d_gizmo.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2014 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup edgizmolib
22  *
23  * \name Dial Gizmo
24  *
25  * 3D Gizmo
26  *
27  * \brief Circle shaped gizmo for circular interaction.
28  * Currently no own handling, use with operator only.
29  *
30  * - `matrix[0]` is derived from Y and Z.
31  * - `matrix[1]` is 'up' when DialGizmo.use_start_y_axis is set.
32  * - `matrix[2]` is the axis the dial rotates around (all dials).
33  */
34
35 #include "MEM_guardedalloc.h"
36
37 #include "BLI_math.h"
38
39 #include "BKE_context.h"
40
41 #include "GPU_immediate.h"
42 #include "GPU_immediate_util.h"
43 #include "GPU_matrix.h"
44 #include "GPU_select.h"
45 #include "GPU_state.h"
46
47 #include "RNA_access.h"
48 #include "RNA_define.h"
49
50 #include "WM_api.h"
51 #include "WM_types.h"
52
53 #include "ED_screen.h"
54 #include "ED_view3d.h"
55 #include "ED_transform.h"
56 #include "ED_gizmo_library.h"
57
58 /* own includes */
59 #include "../gizmo_geometry.h"
60 #include "../gizmo_library_intern.h"
61
62 /* To use custom dials exported to geom_dial_gizmo.c */
63 // #define USE_GIZMO_CUSTOM_DIAL
64
65 typedef struct DialInteraction {
66   struct {
67     float mval[2];
68     /* Only for when using properties. */
69     float prop_angle;
70   } init;
71   struct {
72     /* Cache the last angle to detect rotations bigger than -/+ PI. */
73     eWM_GizmoFlagTweak tweak_flag;
74     float angle;
75   } prev;
76
77   /* Number of full rotations. */
78   int rotations;
79   bool has_drag;
80   float angle_increment;
81
82   /* Final output values, used for drawing. */
83   struct {
84     float angle_ofs;
85     float angle_delta;
86   } output;
87 } DialInteraction;
88
89 #define DIAL_WIDTH 1.0f
90 #define DIAL_RESOLUTION 48
91
92 /* Could make option, negative to clip more (don't show when view aligned). */
93 #define DIAL_CLIP_BIAS 0.02
94
95 /* -------------------------------------------------------------------- */
96
97 static void dial_geom_draw(const float color[4],
98                            const float line_width,
99                            const bool select,
100                            const float axis_modal_mat[4][4],
101                            const float clip_plane[4],
102                            const float arc_partial_angle,
103                            const float arc_inner_factor,
104                            const int draw_options)
105 {
106 #ifdef USE_GIZMO_CUSTOM_DIAL
107   UNUSED_VARS(gz, axis_modal_mat, clip_plane);
108   wm_gizmo_geometryinfo_draw(&wm_gizmo_geom_data_dial, select, color);
109 #else
110   const bool filled = ((draw_options & (select ? (ED_GIZMO_DIAL_DRAW_FLAG_FILL |
111                                                   ED_GIZMO_DIAL_DRAW_FLAG_FILL_SELECT) :
112                                                  ED_GIZMO_DIAL_DRAW_FLAG_FILL)));
113
114   GPU_line_width(line_width);
115
116   GPUVertFormat *format = immVertexFormat();
117   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
118
119   if (clip_plane) {
120     immBindBuiltinProgram(GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR);
121     immUniform4fv("ClipPlane", clip_plane);
122     immUniformMatrix4fv("ModelMatrix", axis_modal_mat);
123     glEnable(GL_CLIP_DISTANCE0);
124   }
125   else {
126     immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
127   }
128
129   immUniformColor4fv(color);
130
131   if (filled) {
132     if (arc_partial_angle == 0.0f) {
133       if (arc_inner_factor == 0.0f) {
134         imm_draw_circle_fill_2d(pos, 0, 0, 1.0, DIAL_RESOLUTION);
135       }
136       else {
137         imm_draw_disk_partial_fill_2d(
138             pos, 0, 0, arc_inner_factor, 1.0f, DIAL_RESOLUTION, 0, RAD2DEGF(M_PI * 2));
139       }
140     }
141     else {
142       float arc_partial_deg = RAD2DEGF((M_PI * 2) - arc_partial_angle);
143       imm_draw_disk_partial_fill_2d(pos,
144                                     0,
145                                     0,
146                                     arc_inner_factor,
147                                     1.0f,
148                                     DIAL_RESOLUTION,
149                                     -arc_partial_deg / 2,
150                                     arc_partial_deg);
151     }
152   }
153   else {
154     if (arc_partial_angle == 0.0f) {
155       imm_draw_circle_wire_2d(pos, 0, 0, 1.0, DIAL_RESOLUTION);
156       if (arc_inner_factor != 0.0f) {
157         imm_draw_circle_wire_2d(pos, 0, 0, arc_inner_factor, DIAL_RESOLUTION);
158       }
159     }
160     else {
161       float arc_partial_deg = RAD2DEGF((M_PI * 2) - arc_partial_angle);
162       imm_draw_circle_partial_wire_2d(
163           pos, 0, 0, 1.0, DIAL_RESOLUTION, -arc_partial_deg / 2, arc_partial_deg);
164 #  if 0
165       if (arc_inner_factor != 0.0f) {
166         BLI_assert(0);
167       }
168 #  endif
169     }
170   }
171
172   immUnbindProgram();
173
174   if (clip_plane) {
175     glDisable(GL_CLIP_DISTANCE0);
176   }
177
178   UNUSED_VARS(select);
179 #endif
180 }
181
182 /**
183  * Draws a line from (0, 0, 0) to \a co_outer, at \a angle.
184  */
185 static void dial_ghostarc_draw_helpline(const float angle,
186                                         const float co_outer[3],
187                                         const float color[4])
188 {
189   GPU_matrix_push();
190   GPU_matrix_rotate_3f(RAD2DEGF(angle), 0.0f, 0.0f, -1.0f);
191
192   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
193
194   immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
195
196   immUniformColor4fv(color);
197
198   immBegin(GPU_PRIM_LINE_STRIP, 2);
199   immVertex3f(pos, 0.0f, 0, 0.0f);
200   immVertex3fv(pos, co_outer);
201   immEnd();
202
203   immUnbindProgram();
204
205   GPU_matrix_pop();
206 }
207
208 /**
209  * Draws segments to indicate the position of each increment.
210  */
211 static void dial_ghostarc_draw_incremental_angle(const float incremental_angle, const float offset)
212 {
213   const int tot_incr = (2 * M_PI) / incremental_angle;
214   GPU_line_width(1.0f);
215
216   uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
217   immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
218   immUniformColor3f(1.0f, 1.0f, 1.0f);
219   immBegin(GPU_PRIM_LINES, tot_incr * 2);
220
221   float v[3] = {0};
222   for (int i = 0; i < tot_incr; i++) {
223     v[0] = sinf(offset + incremental_angle * i);
224     v[1] = cosf(offset + incremental_angle * i);
225
226     mul_v2_fl(v, DIAL_WIDTH * 1.1f);
227     immVertex3fv(pos, v);
228
229     mul_v2_fl(v, 1.1f);
230     immVertex3fv(pos, v);
231   }
232
233   immEnd();
234   immUnbindProgram();
235 }
236
237 static void dial_ghostarc_draw(const float angle_ofs,
238                                const float angle_delta,
239                                const float arc_inner_factor,
240                                const float color[4])
241 {
242   const float width_inner = DIAL_WIDTH;
243   GPUVertFormat *format = immVertexFormat();
244   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
245   immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
246
247   if (arc_inner_factor != 0.0) {
248     float color_dark[4] = {0};
249     color_dark[3] = color[3] / 2;
250     immUniformColor4fv(color_dark);
251     imm_draw_disk_partial_fill_2d(pos,
252                                   0,
253                                   0,
254                                   arc_inner_factor,
255                                   width_inner,
256                                   DIAL_RESOLUTION,
257                                   RAD2DEGF(angle_ofs),
258                                   RAD2DEGF(M_PI * 2));
259   }
260
261   immUniformColor4fv(color);
262   imm_draw_disk_partial_fill_2d(pos,
263                                 0,
264                                 0,
265                                 arc_inner_factor,
266                                 width_inner,
267                                 DIAL_RESOLUTION,
268                                 RAD2DEGF(angle_ofs),
269                                 RAD2DEGF(angle_delta));
270   immUnbindProgram();
271 }
272
273 static void dial_ghostarc_get_angles(const wmGizmo *gz,
274                                      const wmEvent *event,
275                                      const ARegion *ar,
276                                      float mat[4][4],
277                                      const float co_outer[3],
278                                      float *r_start,
279                                      float *r_delta)
280 {
281   DialInteraction *inter = gz->interaction_data;
282   const RegionView3D *rv3d = ar->regiondata;
283   const float mval[2] = {event->x - ar->winrct.xmin, event->y - ar->winrct.ymin};
284
285   /* We might need to invert the direction of the angles. */
286   float view_vec[3], axis_vec[3];
287   ED_view3d_global_to_vector(rv3d, gz->matrix_basis[3], view_vec);
288   normalize_v3_v3(axis_vec, gz->matrix_basis[2]);
289
290   float proj_outer_rel[3];
291   mul_v3_project_m4_v3(proj_outer_rel, mat, co_outer);
292   sub_v3_v3(proj_outer_rel, gz->matrix_basis[3]);
293
294   float proj_mval_new_rel[3];
295   float proj_mval_init_rel[3];
296   float dial_plane[4];
297
298   plane_from_point_normal_v3(dial_plane, gz->matrix_basis[3], axis_vec);
299
300   if (!ED_view3d_win_to_3d_on_plane(ar, dial_plane, inter->init.mval, false, proj_mval_init_rel)) {
301     goto fail;
302   }
303   sub_v3_v3(proj_mval_init_rel, gz->matrix_basis[3]);
304
305   if (!ED_view3d_win_to_3d_on_plane(ar, dial_plane, mval, false, proj_mval_new_rel)) {
306     goto fail;
307   }
308   sub_v3_v3(proj_mval_new_rel, gz->matrix_basis[3]);
309
310   const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
311
312   /* Start direction from mouse or set by user. */
313   const float *proj_init_rel = (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_START_Y) ?
314                                    gz->matrix_basis[1] :
315                                    proj_mval_init_rel;
316
317   /* Return angles. */
318   const float start = angle_wrap_rad(
319       angle_signed_on_axis_v3v3_v3(proj_outer_rel, proj_init_rel, axis_vec));
320   const float delta = angle_wrap_rad(
321       angle_signed_on_axis_v3v3_v3(proj_mval_init_rel, proj_mval_new_rel, axis_vec));
322
323   /* Change of sign, we passed the 180 degree threshold. This means we need to add a turn
324    * to distinguish between transition from 0 to -1 and -PI to +PI, use comparison with PI/2.
325    * Logic taken from #BLI_dial_angle */
326   if ((delta * inter->prev.angle < 0.0f) && (fabsf(inter->prev.angle) > (float)M_PI_2)) {
327     if (inter->prev.angle < 0.0f) {
328       inter->rotations--;
329     }
330     else {
331       inter->rotations++;
332     }
333   }
334   inter->prev.angle = delta;
335
336   const bool wrap_angle = RNA_boolean_get(gz->ptr, "wrap_angle");
337   const double delta_final = (double)delta + ((2 * M_PI) * (double)inter->rotations);
338   *r_start = start;
339   *r_delta = (float)(wrap_angle ? fmod(delta_final, 2 * M_PI) : delta_final);
340   return;
341
342   /* If we can't project (unlikely). */
343 fail:
344   *r_start = 0.0;
345   *r_delta = 0.0;
346 }
347
348 static void dial_ghostarc_draw_with_helplines(const float angle_ofs,
349                                               const float angle_delta,
350                                               const float arc_inner_factor,
351                                               const float color_helpline[4],
352                                               const int draw_options)
353 {
354   /* Coordinate at which the arc drawing will be started. */
355   const float co_outer[4] = {0.0f, DIAL_WIDTH, 0.0f};
356   dial_ghostarc_draw(
357       angle_ofs, angle_delta, arc_inner_factor, (const float[4]){0.8f, 0.8f, 0.8f, 0.4f});
358   GPU_line_width(1.0f);
359   dial_ghostarc_draw_helpline(angle_ofs, co_outer, color_helpline);
360   if (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_VALUE) {
361     GPU_line_width(3.0f);
362   }
363   dial_ghostarc_draw_helpline(angle_ofs + angle_delta, co_outer, color_helpline);
364 }
365
366 static void dial_draw_intern(
367     const bContext *C, wmGizmo *gz, const bool select, const bool highlight, float clip_plane[4])
368 {
369   float matrix_final[4][4];
370   float color[4];
371
372   (void)C;
373   BLI_assert(CTX_wm_area(C)->spacetype == SPACE_VIEW3D);
374
375   gizmo_color_get(gz, highlight, color);
376
377   WM_gizmo_calc_matrix_final(gz, matrix_final);
378
379   const float arc_partial_angle = RNA_float_get(gz->ptr, "arc_partial_angle");
380   const float arc_inner_factor = RNA_float_get(gz->ptr, "arc_inner_factor");
381   int draw_options = RNA_enum_get(gz->ptr, "draw_options");
382   float angle_ofs = 0.0f;
383   float angle_delta = 0.0f;
384   float angle_increment = 0.0f;
385
386   if (select) {
387     draw_options &= ~ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_VALUE;
388   }
389
390   if (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_VALUE && (gz->flag & WM_GIZMO_DRAW_VALUE)) {
391     DialInteraction *inter = gz->interaction_data;
392     if (inter) {
393       angle_ofs = inter->output.angle_ofs;
394       angle_delta = inter->output.angle_delta;
395       angle_increment = inter->angle_increment;
396     }
397     else {
398       wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
399       if (WM_gizmo_target_property_is_valid(gz_prop)) {
400         angle_delta = WM_gizmo_target_property_float_get(gz, gz_prop);
401       }
402     }
403   }
404
405   ED_gizmotypes_dial_3d_draw_util(gz->matrix_basis,
406                                   matrix_final,
407                                   gz->line_width,
408                                   color,
409                                   select,
410                                   &(struct Dial3dParams){
411                                       .draw_options = draw_options,
412                                       .angle_ofs = angle_ofs,
413                                       .angle_delta = angle_delta,
414                                       .angle_increment = angle_increment,
415                                       .arc_partial_angle = arc_partial_angle,
416                                       .arc_inner_factor = arc_inner_factor,
417                                       .clip_plane = clip_plane,
418                                   });
419 }
420
421 static void gizmo_dial_draw_select(const bContext *C, wmGizmo *gz, int select_id)
422 {
423   float clip_plane_buf[4];
424   const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
425   float *clip_plane = (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_CLIP) ? clip_plane_buf : NULL;
426
427   if (clip_plane) {
428     ARegion *ar = CTX_wm_region(C);
429     RegionView3D *rv3d = ar->regiondata;
430
431     copy_v3_v3(clip_plane, rv3d->viewinv[2]);
432     clip_plane[3] = -dot_v3v3(rv3d->viewinv[2], gz->matrix_basis[3]);
433     clip_plane[3] += DIAL_CLIP_BIAS;
434   }
435
436   GPU_select_load_id(select_id);
437   dial_draw_intern(C, gz, true, false, clip_plane);
438
439   if (clip_plane) {
440     glDisable(GL_CLIP_DISTANCE0);
441   }
442 }
443
444 static void gizmo_dial_draw(const bContext *C, wmGizmo *gz)
445 {
446   const bool is_modal = gz->state & WM_GIZMO_STATE_MODAL;
447   const bool is_highlight = (gz->state & WM_GIZMO_STATE_HIGHLIGHT) != 0;
448   float clip_plane_buf[4];
449   const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
450   float *clip_plane = (!is_modal && (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_CLIP)) ?
451                           clip_plane_buf :
452                           NULL;
453
454   if (clip_plane) {
455     ARegion *ar = CTX_wm_region(C);
456     RegionView3D *rv3d = ar->regiondata;
457
458     copy_v3_v3(clip_plane, rv3d->viewinv[2]);
459     clip_plane[3] = -dot_v3v3(rv3d->viewinv[2], gz->matrix_basis[3]);
460     clip_plane[3] += DIAL_CLIP_BIAS;
461   }
462
463   GPU_blend(true);
464   dial_draw_intern(C, gz, false, is_highlight, clip_plane);
465   GPU_blend(false);
466 }
467
468 static int gizmo_dial_modal(bContext *C,
469                             wmGizmo *gz,
470                             const wmEvent *event,
471                             eWM_GizmoFlagTweak tweak_flag)
472 {
473   DialInteraction *inter = gz->interaction_data;
474   if ((event->type != MOUSEMOVE) && (inter->prev.tweak_flag == tweak_flag)) {
475     return OPERATOR_RUNNING_MODAL;
476   }
477   /* Coordinate at which the arc drawing will be started. */
478   const float co_outer[4] = {0.0f, DIAL_WIDTH, 0.0f};
479   float angle_ofs, angle_delta, angle_increment = 0.0f;
480
481   dial_ghostarc_get_angles(
482       gz, event, CTX_wm_region(C), gz->matrix_basis, co_outer, &angle_ofs, &angle_delta);
483
484   if (tweak_flag & WM_GIZMO_TWEAK_SNAP) {
485     angle_increment = RNA_float_get(gz->ptr, "incremental_angle");
486     angle_delta = (float)roundf((double)angle_delta / angle_increment) * angle_increment;
487   }
488   if (tweak_flag & WM_GIZMO_TWEAK_PRECISE) {
489     angle_increment *= 0.2f;
490     angle_delta *= 0.2f;
491   }
492   if (angle_delta != 0.0f) {
493     inter->has_drag = true;
494   }
495
496   inter->angle_increment = angle_increment;
497   inter->output.angle_delta = angle_delta;
498   inter->output.angle_ofs = angle_ofs;
499
500   /* Set the property for the operator and call its modal function. */
501   wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
502   if (WM_gizmo_target_property_is_valid(gz_prop)) {
503     WM_gizmo_target_property_float_set(C, gz, gz_prop, inter->init.prop_angle + angle_delta);
504   }
505
506   inter->prev.tweak_flag = tweak_flag;
507
508   return OPERATOR_RUNNING_MODAL;
509 }
510
511 static void gizmo_dial_exit(bContext *C, wmGizmo *gz, const bool cancel)
512 {
513   DialInteraction *inter = gz->interaction_data;
514   bool use_reset_value = false;
515   float reset_value = 0.0f;
516   if (cancel) {
517     /* Set the property for the operator and call its modal function. */
518     wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
519     if (WM_gizmo_target_property_is_valid(gz_prop)) {
520       use_reset_value = true;
521       reset_value = inter->init.prop_angle;
522     }
523   }
524   else {
525     if (inter->has_drag == false) {
526       PropertyRNA *prop = RNA_struct_find_property(gz->ptr, "click_value");
527       if (RNA_property_is_set(gz->ptr, prop)) {
528         use_reset_value = true;
529         reset_value = RNA_property_float_get(gz->ptr, prop);
530       }
531     }
532   }
533
534   if (use_reset_value) {
535     wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
536     if (WM_gizmo_target_property_is_valid(gz_prop)) {
537       WM_gizmo_target_property_float_set(C, gz, gz_prop, reset_value);
538     }
539   }
540 }
541
542 static void gizmo_dial_setup(wmGizmo *gz)
543 {
544   const float dir_default[3] = {0.0f, 0.0f, 1.0f};
545
546   /* defaults */
547   copy_v3_v3(gz->matrix_basis[2], dir_default);
548 }
549
550 static int gizmo_dial_invoke(bContext *UNUSED(C), wmGizmo *gz, const wmEvent *event)
551 {
552   DialInteraction *inter = MEM_callocN(sizeof(DialInteraction), __func__);
553
554   inter->init.mval[0] = event->mval[0];
555   inter->init.mval[1] = event->mval[1];
556
557   wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
558   if (WM_gizmo_target_property_is_valid(gz_prop)) {
559     inter->init.prop_angle = WM_gizmo_target_property_float_get(gz, gz_prop);
560   }
561
562   gz->interaction_data = inter;
563
564   return OPERATOR_RUNNING_MODAL;
565 }
566
567 /* -------------------------------------------------------------------- */
568 /** \name Dial Gizmo API
569  *
570  * \{ */
571
572 void ED_gizmotypes_dial_3d_draw_util(const float matrix_basis[4][4],
573                                      const float matrix_final[4][4],
574                                      const float line_width,
575                                      const float color[4],
576                                      const bool select,
577                                      struct Dial3dParams *params)
578 {
579   GPU_matrix_push();
580   GPU_matrix_mul(matrix_final);
581
582   GPU_polygon_smooth(false);
583
584   if ((params->draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_VALUE) != 0) {
585     /* Draw rotation indicator arc first. */
586     dial_ghostarc_draw_with_helplines(params->angle_ofs,
587                                       params->angle_delta,
588                                       params->arc_inner_factor,
589                                       color,
590                                       params->draw_options);
591
592     if ((params->draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_MIRROR) != 0) {
593       dial_ghostarc_draw_with_helplines(params->angle_ofs + M_PI,
594                                         params->angle_delta,
595                                         params->arc_inner_factor,
596                                         color,
597                                         params->draw_options);
598     }
599   }
600
601   if (params->angle_increment) {
602     dial_ghostarc_draw_incremental_angle(params->angle_increment, params->angle_ofs);
603   }
604
605   /* Draw actual dial gizmo. */
606   dial_geom_draw(color,
607                  line_width,
608                  select,
609                  matrix_basis,
610                  params->clip_plane,
611                  params->arc_partial_angle,
612                  params->arc_inner_factor,
613                  params->draw_options);
614
615   GPU_matrix_pop();
616 }
617
618 static void GIZMO_GT_dial_3d(wmGizmoType *gzt)
619 {
620   /* identifiers */
621   gzt->idname = "GIZMO_GT_dial_3d";
622
623   /* api callbacks */
624   gzt->draw = gizmo_dial_draw;
625   gzt->draw_select = gizmo_dial_draw_select;
626   gzt->setup = gizmo_dial_setup;
627   gzt->invoke = gizmo_dial_invoke;
628   gzt->modal = gizmo_dial_modal;
629   gzt->exit = gizmo_dial_exit;
630
631   gzt->struct_size = sizeof(wmGizmo);
632
633   /* rna */
634   static EnumPropertyItem rna_enum_draw_options[] = {
635       {ED_GIZMO_DIAL_DRAW_FLAG_CLIP, "CLIP", 0, "Clipped", ""},
636       {ED_GIZMO_DIAL_DRAW_FLAG_FILL, "FILL", 0, "Filled", ""},
637       {ED_GIZMO_DIAL_DRAW_FLAG_FILL_SELECT, "FILL_SELECT", 0, "Use fill for selection test", ""},
638       {ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_MIRROR, "ANGLE_MIRROR", 0, "Angle Mirror", ""},
639       {ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_START_Y, "ANGLE_START_Y", 0, "Angle Start Y", ""},
640       {ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_VALUE, "ANGLE_VALUE", 0, "Show Angle Value", ""},
641       {0, NULL, 0, NULL, NULL},
642   };
643   RNA_def_enum_flag(gzt->srna, "draw_options", rna_enum_draw_options, 0, "Draw Options", "");
644   RNA_def_boolean(gzt->srna, "wrap_angle", true, "Wrap Angle", "");
645   RNA_def_float_factor(
646       gzt->srna, "arc_inner_factor", 0.0f, 0.0f, 1.0f, "Arc Inner Factor", "", 0.0f, 1.0f);
647   RNA_def_float_factor(gzt->srna,
648                        "arc_partial_angle",
649                        0.0f,
650                        0.0f,
651                        M_PI * 2,
652                        "Show Partial Dial",
653                        "",
654                        0.0f,
655                        M_PI * 2);
656   RNA_def_float_factor(gzt->srna,
657                        "incremental_angle",
658                        SNAP_INCREMENTAL_ANGLE,
659                        0.0f,
660                        M_PI * 2,
661                        "Incremental Angle",
662                        "Angle to snap in steps",
663                        0.0f,
664                        M_PI * 2);
665   RNA_def_float(gzt->srna,
666                 "click_value",
667                 0.0f,
668                 -FLT_MAX,
669                 FLT_MAX,
670                 "Click Value",
671                 "Value to use for a single click action",
672                 -FLT_MAX,
673                 FLT_MAX);
674
675   WM_gizmotype_target_property_def(gzt, "offset", PROP_FLOAT, 1);
676 }
677
678 void ED_gizmotypes_dial_3d(void)
679 {
680   WM_gizmotype_append(GIZMO_GT_dial_3d);
681 }
682
683 /** \} */