Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / gizmo_library / gizmo_types / dial3d_gizmo.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2014 Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file dial3d_gizmo.c
27  *  \ingroup wm
28  *
29  * \name Dial Gizmo
30  *
31  * 3D Gizmo
32  *
33  * \brief Circle shaped gizmo for circular interaction.
34  * Currently no own handling, use with operator only.
35  *
36  * - `matrix[0]` is derived from Y and Z.
37  * - `matrix[1]` is 'up' when DialGizmo.use_start_y_axis is set.
38  * - `matrix[2]` is the axis the dial rotates around (all dials).
39  */
40
41 #include "MEM_guardedalloc.h"
42
43 #include "BLI_math.h"
44
45 #include "BKE_context.h"
46
47 #include "BIF_gl.h"
48 #include "BIF_glutil.h"
49
50 #include "GPU_immediate.h"
51 #include "GPU_immediate_util.h"
52 #include "GPU_matrix.h"
53 #include "GPU_select.h"
54 #include "GPU_state.h"
55
56 #include "RNA_access.h"
57 #include "RNA_define.h"
58
59 #include "WM_api.h"
60 #include "WM_types.h"
61
62 #include "ED_screen.h"
63 #include "ED_view3d.h"
64 #include "ED_gizmo_library.h"
65
66 /* own includes */
67 #include "../gizmo_geometry.h"
68 #include "../gizmo_library_intern.h"
69
70 /* to use custom dials exported to geom_dial_gizmo.c */
71 // #define USE_GIZMO_CUSTOM_DIAL
72
73 static int gizmo_dial_modal(
74         bContext *C, wmGizmo *gz, const wmEvent *event,
75         eWM_GizmoFlagTweak tweak_flag);
76
77 typedef struct DialInteraction {
78         float init_mval[2];
79
80         /* only for when using properties */
81         float init_prop_angle;
82
83         /* cache the last angle to detect rotations bigger than -/+ PI */
84         float last_angle;
85         /* number of full rotations */
86         int rotations;
87
88         /* final output values, used for drawing */
89         struct {
90                 float angle_ofs;
91                 float angle_delta;
92         } output;
93 } DialInteraction;
94
95 #define DIAL_WIDTH       1.0f
96 #define DIAL_RESOLUTION 48
97
98 /* Could make option, negative to clip more (don't show when view aligned). */
99 #define DIAL_CLIP_BIAS 0.02
100
101 /**
102  * We can't use this for the #wmGizmoType.matrix_basis_get callback, it conflicts with depth picking.
103  */
104 static void dial_calc_matrix(const wmGizmo *gz, float mat[4][4])
105 {
106         float rot[3][3];
107         const float up[3] = {0.0f, 0.0f, 1.0f};
108
109         rotation_between_vecs_to_mat3(rot, up, gz->matrix_basis[2]);
110         copy_m4_m3(mat, rot);
111         copy_v3_v3(mat[3], gz->matrix_basis[3]);
112 }
113
114 /* -------------------------------------------------------------------- */
115
116 static void dial_geom_draw(
117         const wmGizmo *gz, const float color[4], const bool select,
118         float axis_modal_mat[4][4], float clip_plane[4])
119 {
120 #ifdef USE_GIZMO_CUSTOM_DIAL
121         UNUSED_VARS(dial, col, axis_modal_mat, clip_plane);
122         wm_gizmo_geometryinfo_draw(&wm_gizmo_geom_data_dial, select);
123 #else
124         const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
125         const bool filled = (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_FILL) != 0;
126
127         GPU_line_width(gz->line_width);
128
129         GPUVertFormat *format = immVertexFormat();
130         uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
131
132         if (clip_plane) {
133                 immBindBuiltinProgram(GPU_SHADER_3D_CLIPPED_UNIFORM_COLOR);
134                 float clip_plane_f[4] = {clip_plane[0], clip_plane[1], clip_plane[2], clip_plane[3]};
135                 immUniform4fv("ClipPlane", clip_plane_f);
136                 immUniformMatrix4fv("ModelMatrix", axis_modal_mat);
137         }
138         else {
139                 immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
140         }
141
142         immUniformColor4fv(color);
143
144         if (filled) {
145                 imm_draw_circle_fill_2d(pos, 0, 0, 1.0, DIAL_RESOLUTION);
146         }
147         else {
148                 imm_draw_circle_wire_2d(pos, 0, 0, 1.0, DIAL_RESOLUTION);
149         }
150
151         immUnbindProgram();
152
153         UNUSED_VARS(select);
154 #endif
155 }
156
157 /**
158  * Draws a line from (0, 0, 0) to \a co_outer, at \a angle.
159  */
160 static void dial_ghostarc_draw_helpline(const float angle, const float co_outer[3], const float color[4])
161 {
162         GPU_line_width(1.0f);
163
164         GPU_matrix_push();
165         GPU_matrix_rotate_3f(RAD2DEGF(angle), 0.0f, 0.0f, -1.0f);
166
167         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
168
169         immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
170
171         immUniformColor4fv(color);
172
173         immBegin(GPU_PRIM_LINE_STRIP, 2);
174         immVertex3f(pos, 0.0f, 0.0f, 0.0f);
175         immVertex3fv(pos, co_outer);
176         immEnd();
177
178         immUnbindProgram();
179
180         GPU_matrix_pop();
181 }
182
183 static void dial_ghostarc_draw(
184         const wmGizmo *gz, const float angle_ofs, const float angle_delta, const float color[4])
185 {
186         const float width_inner = DIAL_WIDTH - gz->line_width * 0.5f / U.gizmo_size;
187
188         GPUVertFormat *format = immVertexFormat();
189         uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
190         immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
191         immUniformColor4fv(color);
192         imm_draw_disk_partial_fill_2d(
193                 pos, 0, 0, 0.0, width_inner, DIAL_RESOLUTION, RAD2DEGF(angle_ofs), RAD2DEGF(angle_delta));
194         immUnbindProgram();
195 }
196
197 static void dial_ghostarc_get_angles(
198         struct Depsgraph *depsgraph,
199         const wmGizmo *gz,
200         const wmEvent *event,
201         const ARegion *ar, const View3D *v3d,
202         float mat[4][4], const float co_outer[3],
203         float *r_start, float *r_delta)
204 {
205         DialInteraction *inter = gz->interaction_data;
206         const RegionView3D *rv3d = ar->regiondata;
207         const float mval[2] = {event->x - ar->winrct.xmin, event->y - ar->winrct.ymin};
208
209         /* we might need to invert the direction of the angles */
210         float view_vec[3], axis_vec[3];
211         ED_view3d_global_to_vector(rv3d, gz->matrix_basis[3], view_vec);
212         normalize_v3_v3(axis_vec, gz->matrix_basis[2]);
213
214         float proj_outer_rel[3];
215         mul_v3_project_m4_v3(proj_outer_rel, mat, co_outer);
216         sub_v3_v3(proj_outer_rel, gz->matrix_basis[3]);
217
218         float proj_mval_new_rel[3];
219         float proj_mval_init_rel[3];
220         float dial_plane[4];
221         float ray_co[3], ray_no[3];
222         float ray_lambda;
223
224         plane_from_point_normal_v3(dial_plane, gz->matrix_basis[3], axis_vec);
225
226         if (!ED_view3d_win_to_ray(depsgraph, ar, v3d, inter->init_mval, ray_co, ray_no, false) ||
227             !isect_ray_plane_v3(ray_co, ray_no, dial_plane, &ray_lambda, false))
228         {
229                 goto fail;
230         }
231         madd_v3_v3v3fl(proj_mval_init_rel, ray_co, ray_no, ray_lambda);
232         sub_v3_v3(proj_mval_init_rel, gz->matrix_basis[3]);
233
234         if (!ED_view3d_win_to_ray(depsgraph, ar, v3d, mval, ray_co, ray_no, false) ||
235             !isect_ray_plane_v3(ray_co, ray_no, dial_plane, &ray_lambda, false))
236         {
237                 goto fail;
238         }
239         madd_v3_v3v3fl(proj_mval_new_rel, ray_co, ray_no, ray_lambda);
240         sub_v3_v3(proj_mval_new_rel, gz->matrix_basis[3]);
241
242         const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
243
244         /* Start direction from mouse or set by user */
245         const float *proj_init_rel =
246                 (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_START_Y) ?
247                 gz->matrix_basis[1] : proj_mval_init_rel;
248
249         /* return angles */
250         const float start = angle_wrap_rad(angle_signed_on_axis_v3v3_v3(proj_outer_rel, proj_init_rel, axis_vec));
251         const float delta = angle_wrap_rad(angle_signed_on_axis_v3v3_v3(proj_mval_init_rel, proj_mval_new_rel, axis_vec));
252
253         /* Change of sign, we passed the 180 degree threshold. This means we need to add a turn
254          * to distinguish between transition from 0 to -1 and -PI to +PI, use comparison with PI/2.
255          * Logic taken from BLI_dial_angle */
256         if ((delta * inter->last_angle < 0.0f) &&
257             (fabsf(inter->last_angle) > (float)M_PI_2))
258         {
259                 if (inter->last_angle < 0.0f)
260                         inter->rotations--;
261                 else
262                         inter->rotations++;
263         }
264         inter->last_angle = delta;
265
266         *r_start = start;
267         *r_delta = fmod(delta + 2.0f * (float)M_PI * inter->rotations, 2 * (float)M_PI);
268         return;
269
270         /* If we can't project (unlikely). */
271 fail:
272         *r_start = 0.0;
273         *r_delta = 0.0;
274 }
275
276 static void dial_draw_intern(
277         const bContext *C, wmGizmo *gz,
278         const bool select, const bool highlight, float clip_plane[4])
279 {
280         float matrix_basis_adjust[4][4];
281         float matrix_final[4][4];
282         float color[4];
283
284         BLI_assert(CTX_wm_area(C)->spacetype == SPACE_VIEW3D);
285
286         gizmo_color_get(gz, highlight, color);
287
288         dial_calc_matrix(gz, matrix_basis_adjust);
289
290         WM_gizmo_calc_matrix_final_params(
291                 gz, &((struct WM_GizmoMatrixParams) {
292                     .matrix_basis = (void *)matrix_basis_adjust,
293                 }), matrix_final);
294
295         GPU_matrix_push();
296         GPU_matrix_mul(matrix_final);
297
298         /* draw rotation indicator arc first */
299         if ((gz->flag & WM_GIZMO_DRAW_VALUE) &&
300             (gz->state & WM_GIZMO_STATE_MODAL))
301         {
302                 const float co_outer[4] = {0.0f, DIAL_WIDTH, 0.0f}; /* coordinate at which the arc drawing will be started */
303
304                 DialInteraction *inter = gz->interaction_data;
305
306                 /* XXX, View3D rotation gizmo doesn't call modal. */
307                 if (!WM_gizmo_target_property_is_valid_any(gz)) {
308                         wmWindow *win = CTX_wm_window(C);
309                         gizmo_dial_modal((bContext *)C, gz, win->eventstate, 0);
310                 }
311
312                 float angle_ofs = inter->output.angle_ofs;
313                 float angle_delta = inter->output.angle_delta;
314
315                 /* draw! */
316                 for (int i = 0; i < 2; i++) {
317                         GPU_polygon_smooth(false);
318                         dial_ghostarc_draw(gz, angle_ofs, angle_delta, (const float[4]){0.8f, 0.8f, 0.8f, 0.4f});
319                         GPU_polygon_smooth(true);
320
321                         dial_ghostarc_draw_helpline(angle_ofs, co_outer, color); /* starting position */
322                         dial_ghostarc_draw_helpline(angle_ofs + angle_delta, co_outer, color); /* starting position + current value */
323
324                         if (i == 0) {
325                                 const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
326                                 if ((draw_options & ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_MIRROR) == 0) {
327                                         break;
328                                 }
329                         }
330
331                         angle_ofs += (float)M_PI;
332                 }
333         }
334
335         /* draw actual dial gizmo */
336         dial_geom_draw(gz, color, select, matrix_basis_adjust, clip_plane);
337
338         GPU_matrix_pop();
339 }
340
341 static void gizmo_dial_draw_select(const bContext *C, wmGizmo *gz, int select_id)
342 {
343         float clip_plane_buf[4];
344         const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
345         float *clip_plane = (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_CLIP) ? clip_plane_buf : NULL;
346
347         /* enable clipping if needed */
348         if (clip_plane) {
349                 ARegion *ar = CTX_wm_region(C);
350                 RegionView3D *rv3d = ar->regiondata;
351
352                 copy_v3_v3(clip_plane, rv3d->viewinv[2]);
353                 clip_plane[3] = -dot_v3v3(rv3d->viewinv[2], gz->matrix_basis[3]);
354                 clip_plane[3] += DIAL_CLIP_BIAS * gz->scale_final;
355                 glEnable(GL_CLIP_DISTANCE0);
356         }
357
358         GPU_select_load_id(select_id);
359         dial_draw_intern(C, gz, true, false, clip_plane);
360
361         if (clip_plane) {
362                 glDisable(GL_CLIP_DISTANCE0);
363         }
364 }
365
366 static void gizmo_dial_draw(const bContext *C, wmGizmo *gz)
367 {
368         const bool is_modal = gz->state & WM_GIZMO_STATE_MODAL;
369         const bool is_highlight = (gz->state & WM_GIZMO_STATE_HIGHLIGHT) != 0;
370         float clip_plane_buf[4];
371         const int draw_options = RNA_enum_get(gz->ptr, "draw_options");
372         float *clip_plane = (!is_modal && (draw_options & ED_GIZMO_DIAL_DRAW_FLAG_CLIP)) ? clip_plane_buf : NULL;
373
374         /* enable clipping if needed */
375         if (clip_plane) {
376                 ARegion *ar = CTX_wm_region(C);
377                 RegionView3D *rv3d = ar->regiondata;
378
379                 copy_v3_v3(clip_plane, rv3d->viewinv[2]);
380                 clip_plane[3] = -dot_v3v3(rv3d->viewinv[2], gz->matrix_basis[3]);
381                 clip_plane[3] += DIAL_CLIP_BIAS * gz->scale_final;
382
383                 glEnable(GL_CLIP_DISTANCE0);
384         }
385
386         GPU_blend(true);
387         dial_draw_intern(C, gz, false, is_highlight, clip_plane);
388         GPU_blend(false);
389
390         if (clip_plane) {
391                 glDisable(GL_CLIP_DISTANCE0);
392         }
393 }
394
395 static int gizmo_dial_modal(
396         bContext *C, wmGizmo *gz, const wmEvent *event,
397         eWM_GizmoFlagTweak UNUSED(tweak_flag))
398 {
399         const float co_outer[4] = {0.0f, DIAL_WIDTH, 0.0f}; /* coordinate at which the arc drawing will be started */
400         float angle_ofs, angle_delta;
401
402         float matrix[4][4];
403
404         dial_calc_matrix(gz, matrix);
405
406         dial_ghostarc_get_angles(
407                 CTX_data_depsgraph(C),
408                 gz, event, CTX_wm_region(C), CTX_wm_view3d(C), matrix, co_outer, &angle_ofs, &angle_delta);
409
410         DialInteraction *inter = gz->interaction_data;
411
412         inter->output.angle_delta = angle_delta;
413         inter->output.angle_ofs = angle_ofs;
414
415         /* set the property for the operator and call its modal function */
416         wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
417         if (WM_gizmo_target_property_is_valid(gz_prop)) {
418                 WM_gizmo_target_property_value_set(C, gz, gz_prop, inter->init_prop_angle + angle_delta);
419         }
420         return OPERATOR_RUNNING_MODAL;
421 }
422
423
424 static void gizmo_dial_setup(wmGizmo *gz)
425 {
426         const float dir_default[3] = {0.0f, 0.0f, 1.0f};
427
428         /* defaults */
429         copy_v3_v3(gz->matrix_basis[2], dir_default);
430 }
431
432 static int gizmo_dial_invoke(
433         bContext *UNUSED(C), wmGizmo *gz, const wmEvent *event)
434 {
435         DialInteraction *inter = MEM_callocN(sizeof(DialInteraction), __func__);
436
437         inter->init_mval[0] = event->mval[0];
438         inter->init_mval[1] = event->mval[1];
439
440         wmGizmoProperty *gz_prop = WM_gizmo_target_property_find(gz, "offset");
441         if (WM_gizmo_target_property_is_valid(gz_prop)) {
442                 inter->init_prop_angle = WM_gizmo_target_property_value_get(gz, gz_prop);
443         }
444
445         gz->interaction_data = inter;
446
447         return OPERATOR_RUNNING_MODAL;
448 }
449
450 /* -------------------------------------------------------------------- */
451 /** \name Dial Gizmo API
452  *
453  * \{ */
454
455 static void GIZMO_GT_dial_3d(wmGizmoType *gzt)
456 {
457         /* identifiers */
458         gzt->idname = "GIZMO_GT_dial_3d";
459
460         /* api callbacks */
461         gzt->draw = gizmo_dial_draw;
462         gzt->draw_select = gizmo_dial_draw_select;
463         gzt->setup = gizmo_dial_setup;
464         gzt->invoke = gizmo_dial_invoke;
465         gzt->modal = gizmo_dial_modal;
466
467         gzt->struct_size = sizeof(wmGizmo);
468
469         /* rna */
470         static EnumPropertyItem rna_enum_draw_options[] = {
471                 {ED_GIZMO_DIAL_DRAW_FLAG_CLIP, "CLIP", 0, "Clipped", ""},
472                 {ED_GIZMO_DIAL_DRAW_FLAG_FILL, "FILL", 0, "Filled", ""},
473                 {ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_MIRROR, "ANGLE_MIRROR", 0, "Angle Mirror", ""},
474                 {ED_GIZMO_DIAL_DRAW_FLAG_ANGLE_START_Y, "ANGLE_START_Y", 0, "Angle Start Y", ""},
475                 {0, NULL, 0, NULL, NULL}
476         };
477         RNA_def_enum_flag(gzt->srna, "draw_options", rna_enum_draw_options, 0, "Draw Options", "");
478
479         WM_gizmotype_target_property_def(gzt, "offset", PROP_FLOAT, 1);
480 }
481
482 void ED_gizmotypes_dial_3d(void)
483 {
484         WM_gizmotype_append(GIZMO_GT_dial_3d);
485 }
486
487 /** \} */