WM: option to ignore cursor image/clip/view2d zoom
[blender.git] / source / blender / editors / space_view3d / view3d_gizmo_navigate.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
17 /** \file
18  * \ingroup spview3d
19  */
20
21 #include "BLI_math.h"
22 #include "BLI_utildefines.h"
23
24 #include "BKE_context.h"
25 #include "BKE_object.h"
26
27 #include "DNA_object_types.h"
28
29 #include "ED_screen.h"
30 #include "ED_gizmo_library.h"
31
32 #include "UI_interface.h"
33 #include "UI_resources.h"
34
35 #include "MEM_guardedalloc.h"
36
37 #include "RNA_access.h"
38
39 #include "WM_api.h"
40 #include "WM_types.h"
41
42 #include "view3d_intern.h" /* own include */
43
44 /* -------------------------------------------------------------------- */
45 /** \name View3D Navigation Gizmo Group
46  * \{ */
47
48 /* Offset from screen edge. */
49 #define GIZMO_OFFSET_FAC 1.2f
50 /* Size of main icon. */
51 #define GIZMO_SIZE 80
52 /* Factor for size of smaller button. */
53 #define GIZMO_MINI_FAC 0.35f
54 /* How much mini buttons offset from the primary. */
55 #define GIZMO_MINI_OFFSET_FAC 0.38f
56
57 enum {
58   GZ_INDEX_MOVE = 0,
59   GZ_INDEX_ROTATE = 1,
60   GZ_INDEX_ZOOM = 2,
61
62   /* just buttons */
63   /* overlaps GZ_INDEX_ORTHO (switch between) */
64   GZ_INDEX_PERSP = 3,
65   GZ_INDEX_ORTHO = 4,
66   GZ_INDEX_CAMERA = 5,
67
68   GZ_INDEX_TOTAL = 6,
69 };
70
71 struct NavigateGizmoInfo {
72   const char *opname;
73   const char *gizmo;
74   uint icon;
75 };
76
77 static struct NavigateGizmoInfo g_navigate_params[GZ_INDEX_TOTAL] = {
78     {
79         .opname = "VIEW3D_OT_move",
80         .gizmo = "GIZMO_GT_button_2d",
81         ICON_VIEW_PAN,
82     },
83     {
84         .opname = "VIEW3D_OT_rotate",
85         .gizmo = "VIEW3D_GT_navigate_rotate",
86         0,
87     },
88     {
89         .opname = "VIEW3D_OT_zoom",
90         .gizmo = "GIZMO_GT_button_2d",
91         ICON_VIEW_ZOOM,
92     },
93     {
94         .opname = "VIEW3D_OT_view_persportho",
95         .gizmo = "GIZMO_GT_button_2d",
96         ICON_VIEW_PERSPECTIVE,
97     },
98     {
99         .opname = "VIEW3D_OT_view_persportho",
100         .gizmo = "GIZMO_GT_button_2d",
101         ICON_VIEW_ORTHO,
102     },
103     {
104         .opname = "VIEW3D_OT_view_camera",
105         .gizmo = "GIZMO_GT_button_2d",
106         ICON_VIEW_CAMERA,
107     },
108 };
109
110 struct NavigateWidgetGroup {
111   wmGizmo *gz_array[GZ_INDEX_TOTAL];
112   /* Store the view state to check for changes. */
113   struct {
114     rcti rect_visible;
115     struct {
116       char is_persp;
117       char is_camera;
118       char viewlock;
119     } rv3d;
120   } state;
121   int region_size[2];
122 };
123
124 static bool WIDGETGROUP_navigate_poll(const bContext *C, wmGizmoGroupType *UNUSED(gzgt))
125 {
126   View3D *v3d = CTX_wm_view3d(C);
127   if (((U.uiflag & USER_SHOW_GIZMO_AXIS) == 0) ||
128       (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE))) {
129     return false;
130   }
131   return true;
132 }
133
134 static void WIDGETGROUP_navigate_setup(const bContext *C, wmGizmoGroup *gzgroup)
135 {
136   struct NavigateWidgetGroup *navgroup = MEM_callocN(sizeof(struct NavigateWidgetGroup), __func__);
137
138   navgroup->region_size[0] = -1;
139   navgroup->region_size[1] = -1;
140
141   wmOperatorType *ot_view_axis = WM_operatortype_find("VIEW3D_OT_view_axis", true);
142   wmOperatorType *ot_view_camera = WM_operatortype_find("VIEW3D_OT_view_camera", true);
143
144   for (int i = 0; i < GZ_INDEX_TOTAL; i++) {
145     const struct NavigateGizmoInfo *info = &g_navigate_params[i];
146     navgroup->gz_array[i] = WM_gizmo_new(info->gizmo, gzgroup, NULL);
147     wmGizmo *gz = navgroup->gz_array[i];
148     gz->flag |= WM_GIZMO_MOVE_CURSOR | WM_GIZMO_DRAW_MODAL;
149
150     if (i == GZ_INDEX_ROTATE) {
151       gz->color[3] = 0.0f;
152       copy_v3_fl(gz->color_hi, 0.5f);
153       gz->color_hi[3] = 0.5f;
154     }
155     else {
156       uchar icon_color[3];
157       UI_GetThemeColor3ubv(TH_TEXT, icon_color);
158       int color_tint, color_tint_hi;
159       if (icon_color[0] > 128) {
160         color_tint = -40;
161         color_tint_hi = 60;
162         gz->color[3] = 0.5f;
163         gz->color_hi[3] = 0.5f;
164       }
165       else {
166         color_tint = 60;
167         color_tint_hi = 60;
168         gz->color[3] = 0.5f;
169         gz->color_hi[3] = 0.75f;
170       }
171       UI_GetThemeColorShade3fv(TH_HEADER, color_tint, gz->color);
172       UI_GetThemeColorShade3fv(TH_HEADER, color_tint_hi, gz->color_hi);
173     }
174
175     /* may be overwritten later */
176     gz->scale_basis = (GIZMO_SIZE * GIZMO_MINI_FAC) / 2;
177     if (info->icon != 0) {
178       PropertyRNA *prop = RNA_struct_find_property(gz->ptr, "icon");
179       RNA_property_enum_set(gz->ptr, prop, info->icon);
180       RNA_enum_set(
181           gz->ptr, "draw_options", ED_GIZMO_BUTTON_SHOW_OUTLINE | ED_GIZMO_BUTTON_SHOW_BACKDROP);
182     }
183
184     wmOperatorType *ot = WM_operatortype_find(info->opname, true);
185     WM_gizmo_operator_set(gz, 0, ot, NULL);
186   }
187
188   {
189     wmGizmo *gz = navgroup->gz_array[GZ_INDEX_CAMERA];
190     WM_gizmo_operator_set(gz, 0, ot_view_camera, NULL);
191   }
192
193   /* Click only buttons (not modal). */
194   {
195     int gz_ids[] = {GZ_INDEX_PERSP, GZ_INDEX_ORTHO, GZ_INDEX_CAMERA};
196     for (int i = 0; i < ARRAY_SIZE(gz_ids); i++) {
197       wmGizmo *gz = navgroup->gz_array[gz_ids[i]];
198       RNA_boolean_set(gz->ptr, "show_drag", false);
199     }
200   }
201
202   /* Modal operators, don't use initial mouse location since we're clicking on a button. */
203   {
204     int gz_ids[] = {GZ_INDEX_MOVE, GZ_INDEX_ROTATE, GZ_INDEX_ZOOM};
205     for (int i = 0; i < ARRAY_SIZE(gz_ids); i++) {
206       wmGizmo *gz = navgroup->gz_array[gz_ids[i]];
207       wmGizmoOpElem *gzop = WM_gizmo_operator_get(gz, 0);
208       RNA_boolean_set(&gzop->ptr, "use_cursor_init", false);
209     }
210   }
211
212   {
213     wmGizmo *gz = navgroup->gz_array[GZ_INDEX_ROTATE];
214     gz->scale_basis = GIZMO_SIZE / 2;
215     char mapping[6] = {
216         RV3D_VIEW_LEFT,
217         RV3D_VIEW_RIGHT,
218         RV3D_VIEW_FRONT,
219         RV3D_VIEW_BACK,
220         RV3D_VIEW_BOTTOM,
221         RV3D_VIEW_TOP,
222     };
223
224     for (int part_index = 0; part_index < 6; part_index += 1) {
225       PointerRNA *ptr = WM_gizmo_operator_set(gz, part_index + 1, ot_view_axis, NULL);
226       RNA_enum_set(ptr, "type", mapping[part_index]);
227     }
228
229     /* When dragging an axis, use this instead. */
230     wmWindowManager *wm = CTX_wm_manager(C);
231     gz->keymap = WM_gizmo_keymap_generic_click_drag(wm);
232     gz->drag_part = 0;
233   }
234
235   gzgroup->customdata = navgroup;
236 }
237
238 static void WIDGETGROUP_navigate_draw_prepare(const bContext *C, wmGizmoGroup *gzgroup)
239 {
240   struct NavigateWidgetGroup *navgroup = gzgroup->customdata;
241   ARegion *ar = CTX_wm_region(C);
242   const RegionView3D *rv3d = ar->regiondata;
243
244   for (int i = 0; i < 3; i++) {
245     copy_v3_v3(navgroup->gz_array[GZ_INDEX_ROTATE]->matrix_offset[i], rv3d->viewmat[i]);
246   }
247
248   rcti rect_visible;
249   ED_region_visible_rect(ar, &rect_visible);
250
251   if ((navgroup->state.rect_visible.xmax == rect_visible.xmax) &&
252       (navgroup->state.rect_visible.ymax == rect_visible.ymax) &&
253       (navgroup->state.rv3d.is_persp == rv3d->is_persp) &&
254       (navgroup->state.rv3d.is_camera == (rv3d->persp == RV3D_CAMOB)) &&
255       (navgroup->state.rv3d.viewlock == rv3d->viewlock)) {
256     return;
257   }
258
259   navgroup->state.rect_visible = rect_visible;
260   navgroup->state.rv3d.is_persp = rv3d->is_persp;
261   navgroup->state.rv3d.is_camera = (rv3d->persp == RV3D_CAMOB);
262   navgroup->state.rv3d.viewlock = rv3d->viewlock;
263
264   const bool show_rotate = (rv3d->viewlock & RV3D_LOCKED) == 0;
265   const bool show_fixed_offset = navgroup->state.rv3d.is_camera;
266   const float icon_size = GIZMO_SIZE;
267   const float icon_offset = (icon_size * 0.52f) * GIZMO_OFFSET_FAC * UI_DPI_FAC;
268   const float icon_offset_mini = icon_size * GIZMO_MINI_OFFSET_FAC * UI_DPI_FAC;
269   const float co_rotate[2] = {
270       rect_visible.xmax - icon_offset,
271       rect_visible.ymax - icon_offset,
272   };
273   const float co[2] = {
274       rect_visible.xmax -
275           ((show_rotate || show_fixed_offset) ? (icon_offset * 2.0f) : (icon_offset_mini * 0.75f)),
276       rect_visible.ymax - icon_offset_mini * 0.75f,
277   };
278
279   wmGizmo *gz;
280
281   for (uint i = 0; i < ARRAY_SIZE(navgroup->gz_array); i++) {
282     gz = navgroup->gz_array[i];
283     WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, true);
284   }
285
286   /* RV3D_LOCKED or Camera: only show supported buttons. */
287   if (show_rotate) {
288     gz = navgroup->gz_array[GZ_INDEX_ROTATE];
289     gz->matrix_basis[3][0] = co_rotate[0];
290     gz->matrix_basis[3][1] = co_rotate[1];
291     WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
292   }
293
294   int icon_mini_slot = 0;
295
296   gz = navgroup->gz_array[GZ_INDEX_ZOOM];
297   gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
298   gz->matrix_basis[3][1] = co[1];
299   WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
300
301   gz = navgroup->gz_array[GZ_INDEX_MOVE];
302   gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
303   gz->matrix_basis[3][1] = co[1];
304   WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
305
306   if ((rv3d->viewlock & RV3D_LOCKED) == 0) {
307     gz = navgroup->gz_array[GZ_INDEX_CAMERA];
308     gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
309     gz->matrix_basis[3][1] = co[1];
310     WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
311
312     if (navgroup->state.rv3d.is_camera == false) {
313       gz = navgroup->gz_array[rv3d->is_persp ? GZ_INDEX_PERSP : GZ_INDEX_ORTHO];
314       gz->matrix_basis[3][0] = co[0] - (icon_offset_mini * icon_mini_slot++);
315       gz->matrix_basis[3][1] = co[1];
316       WM_gizmo_set_flag(gz, WM_GIZMO_HIDDEN, false);
317     }
318   }
319 }
320
321 void VIEW3D_GGT_navigate(wmGizmoGroupType *gzgt)
322 {
323   gzgt->name = "View3D Navigate";
324   gzgt->idname = "VIEW3D_GGT_navigate";
325
326   gzgt->flag |= (WM_GIZMOGROUPTYPE_PERSISTENT | WM_GIZMOGROUPTYPE_SCALE |
327                  WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL);
328
329   gzgt->poll = WIDGETGROUP_navigate_poll;
330   gzgt->setup = WIDGETGROUP_navigate_setup;
331   gzgt->draw_prepare = WIDGETGROUP_navigate_draw_prepare;
332 }
333
334 /** \} */