b520f239ef53283cc56d2331c030f27c0b16f489
[blender.git] / source / blender / editors / space_view3d / view3d_manipulator_navigate_type.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  * ***** END GPL LICENSE BLOCK *****
19  */
20
21 /** \file view3d_manipulator_navigate_type.c
22  *  \ingroup wm
23  *
24  * \name Custom Orientation/Navigation Manipulator for the 3D View
25  *
26  * \brief Simple manipulator to axis and translate.
27  *
28  * - scale_basis: used for the size.
29  * - matrix_basis: used for the location.
30  * - matrix_offset: used to store the orientation.
31  */
32
33 #include "MEM_guardedalloc.h"
34
35 #include "BLI_math.h"
36 #include "BLI_sort_utils.h"
37
38 #include "BKE_context.h"
39
40 #include "BIF_gl.h"
41 #include "BIF_glutil.h"
42
43 #include "GPU_immediate.h"
44 #include "GPU_immediate_util.h"
45 #include "GPU_matrix.h"
46 #include "GPU_select.h"
47
48 #include "RNA_access.h"
49 #include "RNA_define.h"
50
51 #include "UI_resources.h"
52
53 #include "WM_api.h"
54 #include "WM_types.h"
55
56 #include "ED_screen.h"
57 #include "ED_view3d.h"
58 #include "ED_manipulator_library.h"
59
60 #include "view3d_intern.h"
61
62 #define DIAL_RESOLUTION 32
63
64 #define HANDLE_SIZE 0.33
65
66 static void axis_geom_draw(
67         const wmManipulator *mpr, const float color[4], const bool UNUSED(select))
68 {
69         glLineWidth(mpr->line_width);
70
71         Gwn_VertFormat *format = immVertexFormat();
72         const uint pos_id = GWN_vertformat_attr_add(format, "pos", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
73         immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
74
75         /* flip z for reverse */
76         const float cone_coords[5][3] = {
77                 {-1, -1, 4},
78                 {-1, +1, 4},
79                 {+1, +1, 4},
80                 {+1, -1, 4},
81                 {0,   0, 2},
82         };
83
84         struct {
85                 float depth;
86                 char index;
87                 char axis;
88                 char is_pos;
89         } axis_order[6] = {
90                 {-mpr->matrix_offset[0][2], 0, 0, false},
91                 {+mpr->matrix_offset[0][2], 1, 0, true},
92                 {-mpr->matrix_offset[1][2], 2, 1, false},
93                 {+mpr->matrix_offset[1][2], 3, 1, true},
94                 {-mpr->matrix_offset[2][2], 4, 2, false},
95                 {+mpr->matrix_offset[2][2], 5, 2, true},
96         };
97         qsort(&axis_order, ARRAY_SIZE(axis_order), sizeof(axis_order[0]), BLI_sortutil_cmp_float);
98
99         const float scale_axis = 0.33f;
100         static const float axis_highlight[4] = {1, 1, 1, 1};
101         static const float axis_black[4] = {0, 0, 0, 1};
102         static float axis_color[3][4];
103         gpuPushMatrix();
104         gpuMultMatrix(mpr->matrix_offset);
105
106         bool draw_center_done = false;
107
108         for (int axis_index = 0; axis_index < ARRAY_SIZE(axis_order); axis_index++) {
109                 const int index = axis_order[axis_index].index;
110                 const int axis = axis_order[axis_index].axis;
111                 const bool is_pos = axis_order[axis_index].is_pos;
112
113                 /* Draw slightly before, so axis aligned arrows draw ontop. */
114                 if ((draw_center_done == false) && (axis_order[axis_index].depth > -0.01f)) {
115
116                         /* Circle defining active area (revert back to 2D space). */
117                         {
118                                 gpuPopMatrix();
119                                 immUniformColor4fv(color);
120                                 imm_draw_circle_fill_3d(pos_id, 0, 0, 1.0f, DIAL_RESOLUTION);
121                                 gpuPushMatrix();
122                                 gpuMultMatrix(mpr->matrix_offset);
123                         }
124
125                         /* Center cube. */
126                         {
127                                 float center[3], size[3];
128
129                                 zero_v3(center);
130                                 copy_v3_fl(size, HANDLE_SIZE);
131
132                                 glEnable(GL_DEPTH_TEST);
133                                 glDepthMask(GL_TRUE);
134                                 glDepthFunc(GL_LEQUAL);
135                                 glBlendFunc(GL_ONE, GL_ZERO);
136                                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
137
138                                 glEnable(GL_LINE_SMOOTH);
139                                 glEnable(GL_BLEND);
140                                 glLineWidth(1.0f);
141                                 immUniformColor4fv(axis_highlight);
142                                 imm_draw_cube_fill_3d(pos_id, center, size);
143                                 immUniformColor4fv(axis_black);
144                                 madd_v3_v3fl(
145                                         center,
146                                         (float [3]){
147                                         mpr->matrix_offset[0][2],
148                                         mpr->matrix_offset[1][2],
149                                         mpr->matrix_offset[2][2]},
150                                         0.08f);
151                                 imm_draw_cube_wire_3d(pos_id, center, size);
152                                 glDisable(GL_BLEND);
153                                 glDisable(GL_LINE_SMOOTH);
154                                 glDisable(GL_DEPTH_TEST);
155                         }
156
157                         draw_center_done = true;
158                 }
159                 UI_GetThemeColor3fv(TH_AXIS_X + axis, axis_color[axis]);
160                 axis_color[axis][3] = 1.0f;
161
162                 const int index_z = axis;
163                 const int index_y = (axis + 1) % 3;
164                 const int index_x = (axis + 2) % 3;
165
166 #define ROTATED_VERT(v_orig) \
167                 { \
168                         float v[3]; \
169                         copy_v3_v3(v, v_orig); \
170                         if (is_pos == 0) { \
171                                 v[2] *= -1.0f; \
172                         } \
173                         immVertex3f(pos_id, v[index_x] * scale_axis, v[index_y] * scale_axis, v[index_z] * scale_axis); \
174                 } ((void)0)
175
176                 bool ok = true;
177
178                 /* skip view align axis */
179                 if (len_squared_v2(mpr->matrix_offset[axis]) < 1e-6f && (mpr->matrix_offset[axis][2] > 0.0f) == is_pos) {
180                         ok = false;
181                 }
182                 if (ok) {
183                         immUniformColor4fv(index + 1 == mpr->highlight_part ? axis_highlight : axis_color[axis]);
184                         immBegin(GWN_PRIM_TRI_FAN, 6);
185                         ROTATED_VERT(cone_coords[4]);
186                         for (int j = 0; j <= 4; j++) {
187                                 ROTATED_VERT(cone_coords[j % 4]);
188                         }
189                         immEnd();
190                 }
191
192 #undef ROTATED_VERT
193         }
194
195         gpuPopMatrix();
196         immUnbindProgram();
197 }
198
199 static void axis3d_draw_intern(
200         const bContext *UNUSED(C), wmManipulator *mpr,
201         const bool select, const bool highlight)
202 {
203         const float *color = highlight ? mpr->color_hi : mpr->color;
204         float matrix_final[4][4];
205         float matrix_unit[4][4];
206
207         unit_m4(matrix_unit);
208
209         WM_manipulator_calc_matrix_final_params(
210                 mpr,
211                 &((struct WM_ManipulatorMatrixParams) {
212                     .matrix_offset = matrix_unit,
213                 }), matrix_final);
214
215         gpuPushMatrix();
216         gpuMultMatrix(matrix_final);
217
218         glEnable(GL_BLEND);
219         axis_geom_draw(mpr, color, select);
220         glDisable(GL_BLEND);
221         gpuPopMatrix();
222 }
223
224 static void manipulator_axis_draw(const bContext *C, wmManipulator *mpr)
225 {
226         const bool is_modal = mpr->state & WM_MANIPULATOR_STATE_MODAL;
227         const bool is_highlight = (mpr->state & WM_MANIPULATOR_STATE_HIGHLIGHT) != 0 && (mpr->highlight_part == 0);
228
229         (void)is_modal;
230
231         glEnable(GL_BLEND);
232         axis3d_draw_intern(C, mpr, false, is_highlight);
233         glDisable(GL_BLEND);
234 }
235
236 static int manipulator_axis_test_select(
237         bContext *UNUSED(C), wmManipulator *mpr, const wmEvent *event)
238 {
239         float point_local[2] = {UNPACK2(event->mval)};
240         sub_v2_v2(point_local, mpr->matrix_basis[3]);
241         mul_v2_fl(point_local, 1.0f / mpr->scale_basis);
242
243         const float len_sq = len_squared_v2(point_local);
244         if (len_sq > SQUARE(1.0 + HANDLE_SIZE)) {
245                 return -1;
246         }
247
248         int part_best = -1;
249         int part_index = 1;
250         float i_best_len_sq = SQUARE(HANDLE_SIZE);
251         for (int i = 0; i < 3; i++) {
252                 for (int is_pos = 0; is_pos < 2; is_pos++) {
253                         float co[2] = {
254                                 mpr->matrix_offset[i][0] * (is_pos ? 1 : -1),
255                                 mpr->matrix_offset[i][1] * (is_pos ? 1 : -1),
256                         };
257
258                         bool ok = true;
259
260                         /* Check if we're viewing on an axis, there is no point to clicking on the current axis so show the reverse. */
261                         if (len_squared_v2(co) < 1e-6f && (mpr->matrix_offset[i][2] > 0.0f) == is_pos) {
262                                 ok = false;
263                         }
264
265                         if (ok) {
266                                 const float len_axis_sq = len_squared_v2v2(co, point_local);
267                                 if (len_axis_sq < i_best_len_sq) {
268                                         part_best = part_index;
269                                         i_best_len_sq = len_axis_sq;
270                                 }
271                         }
272                         part_index += 1;
273                 }
274         }
275
276         if (part_best != -1) {
277                 return part_best;
278         }
279
280         /* The 'mpr->scale_final' is already applied when projecting. */
281         if (len_sq < 1.0f) {
282                 return 0;
283         }
284
285         return -1;
286 }
287
288 static int manipulator_axis_cursor_get(wmManipulator *mpr)
289 {
290         if (mpr->highlight_part > 0) {
291                 return CURSOR_EDIT;
292         }
293         return BC_NSEW_SCROLLCURSOR;
294 }
295
296 void VIEW3D_WT_navigate_rotate(wmManipulatorType *wt)
297 {
298         /* identifiers */
299         wt->idname = "VIEW3D_WT_navigate_rotate";
300
301         /* api callbacks */
302         wt->draw = manipulator_axis_draw;
303         wt->test_select = manipulator_axis_test_select;
304         wt->cursor_get = manipulator_axis_cursor_get;
305
306         wt->struct_size = sizeof(wmManipulator);
307 }