Merge branch 'blender2.7'
[blender.git] / source / blender / editors / transform / transform_input.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  * Contributor(s): none yet.
19  *
20  * ***** END GPL LICENSE BLOCK *****
21  */
22
23 /** \file blender/editors/transform/transform_input.c
24  *  \ingroup edtransform
25  */
26
27
28 #include <stdlib.h>
29 #include <math.h>
30
31 #include "DNA_screen_types.h"
32
33 #include "BKE_context.h"
34
35 #include "BLI_math.h"
36 #include "BLI_utildefines.h"
37
38 #include "WM_types.h"
39 #include "WM_api.h"
40
41 #include "transform.h"
42
43 #include "MEM_guardedalloc.h"
44
45 /* ************************** INPUT FROM MOUSE *************************** */
46
47 static void InputVector(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
48 {
49         convertViewVec(t, output, mval[0] - mi->imval[0], mval[1] - mi->imval[1]);
50 }
51
52 static void InputSpring(TransInfo *UNUSED(t), MouseInput *mi, const double mval[2], float output[3])
53 {
54         double dx, dy;
55         float ratio;
56
57         dx = ((double)mi->center[0] - mval[0]);
58         dy = ((double)mi->center[1] - mval[1]);
59         ratio = hypot(dx, dy) / (double)mi->factor;
60
61         output[0] = ratio;
62 }
63
64 static void InputSpringFlip(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
65 {
66         InputSpring(t, mi, mval, output);
67
68         /* flip scale */
69         /* values can become really big when zoomed in so use longs [#26598] */
70         if ((int64_t)((int)mi->center[0] - mval[0]) * (int64_t)((int)mi->center[0] - mi->imval[0]) +
71             (int64_t)((int)mi->center[1] - mval[1]) * (int64_t)((int)mi->center[1] - mi->imval[1]) < 0)
72         {
73                 output[0] *= -1.0f;
74         }
75 }
76
77 static void InputSpringDelta(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
78 {
79         InputSpring(t, mi, mval, output);
80         output[0] -= 1.0f;
81 }
82
83 static void InputTrackBall(TransInfo *UNUSED(t), MouseInput *mi, const double mval[2], float output[3])
84 {
85         output[0] = (float)(mi->imval[1] - mval[1]);
86         output[1] = (float)(mval[0] - mi->imval[0]);
87
88         output[0] *= mi->factor;
89         output[1] *= mi->factor;
90 }
91
92 static void InputHorizontalRatio(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
93 {
94         const int winx = t->ar ? t->ar->winx : 1;
95
96         output[0] = ((mval[0] - mi->imval[0]) / winx) * 2.0f;
97 }
98
99 static void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
100 {
101         float vec[3];
102
103         InputVector(t, mi, mval, vec);
104         project_v3_v3v3(vec, vec, t->viewinv[0]);
105
106         output[0] = dot_v3v3(t->viewinv[0], vec) * 2.0f;
107 }
108
109 static void InputVerticalRatio(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
110 {
111         const int winy = t->ar ? t->ar->winy : 1;
112
113         output[0] = ((mval[1] - mi->imval[1]) / winy) * 2.0f;
114 }
115
116 static void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
117 {
118         float vec[3];
119
120         InputVector(t, mi, mval, vec);
121         project_v3_v3v3(vec, vec, t->viewinv[1]);
122
123         output[0] = dot_v3v3(t->viewinv[1], vec) * 2.0f;
124 }
125
126 void setCustomPoints(TransInfo *UNUSED(t), MouseInput *mi, const int mval_start[2], const int mval_end[2])
127 {
128         int *data;
129
130         mi->data = MEM_reallocN(mi->data, sizeof(int) * 4);
131
132         data = mi->data;
133
134         data[0] = mval_start[0];
135         data[1] = mval_start[1];
136         data[2] = mval_end[0];
137         data[3] = mval_end[1];
138 }
139
140 void setCustomPointsFromDirection(TransInfo *t, MouseInput *mi, const float dir[2])
141 {
142         BLI_ASSERT_UNIT_V2(dir);
143         const int win_axis = t->ar ? ((abs((int)(t->ar->winx * dir[0])) + abs((int)(t->ar->winy * dir[1]))) / 2) : 1;
144         const int mval_start[2] = {
145                 mi->imval[0] + dir[0] * win_axis,
146                 mi->imval[1] + dir[1] * win_axis,
147         };
148         const int mval_end[2] = {mi->imval[0], mi->imval[1]};
149         setCustomPoints(t, mi, mval_start, mval_end);
150 }
151
152 static void InputCustomRatioFlip(TransInfo *UNUSED(t), MouseInput *mi, const double mval[2], float output[3])
153 {
154         double length;
155         double distance;
156         double dx, dy;
157         const int *data = mi->data;
158
159         if (data) {
160                 int mdx, mdy;
161                 dx = data[2] - data[0];
162                 dy = data[3] - data[1];
163
164                 length = hypot(dx, dy);
165
166                 mdx = mval[0] - data[2];
167                 mdy = mval[1] - data[3];
168
169                 distance = (length != 0.0) ? (mdx * dx + mdy * dy) / length : 0.0;
170
171                 output[0] = (length != 0.0) ? (double)(distance / length) : 0.0;
172         }
173 }
174
175 static void InputCustomRatio(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
176 {
177         InputCustomRatioFlip(t, mi, mval, output);
178         output[0] = -output[0];
179 }
180
181 struct InputAngle_Data {
182         double angle;
183         double mval_prev[2];
184 };
185
186 static void InputAngle(TransInfo *UNUSED(t), MouseInput *mi, const double mval[2], float output[3])
187 {
188         struct InputAngle_Data *data = mi->data;
189         double dx2 = mval[0] - (double)mi->center[0];
190         double dy2 = mval[1] - (double)mi->center[1];
191         double B = sqrt(dx2 * dx2 + dy2 * dy2);
192
193         double dx1 = data->mval_prev[0] - (double)mi->center[0];
194         double dy1 = data->mval_prev[1] - (double)mi->center[1];
195         double A = sqrt(dx1 * dx1 + dy1 * dy1);
196
197         double dx3 = mval[0] - data->mval_prev[0];
198         double dy3 = mval[1] - data->mval_prev[1];
199
200         /* use doubles here, to make sure a "1.0" (no rotation) doesn't become 9.999999e-01, which gives 0.02 for acos */
201         double deler = (((dx1 * dx1 + dy1 * dy1) +
202                          (dx2 * dx2 + dy2 * dy2) -
203                          (dx3 * dx3 + dy3 * dy3)) / (2.0 * (((A * B) != 0.0) ? (A * B) : 1.0)));
204         /* ((A * B) ? (A * B) : 1.0) this takes care of potential divide by zero errors */
205
206         float dphi;
207
208         dphi = saacos((float)deler);
209         if ((dx1 * dy2 - dx2 * dy1) > 0.0) dphi = -dphi;
210
211         /* If the angle is zero, because of lack of precision close to the 1.0 value in acos
212          * approximate the angle with the opposite side of the normalized triangle
213          * This is a good approximation here since the smallest acos value seems to be around
214          * 0.02 degree and lower values don't even have a 0.01% error compared to the approximation
215          */
216         if (dphi == 0) {
217                 double dx, dy;
218
219                 dx2 /= A;
220                 dy2 /= A;
221
222                 dx1 /= B;
223                 dy1 /= B;
224
225                 dx = dx1 - dx2;
226                 dy = dy1 - dy2;
227
228                 dphi = sqrt(dx * dx + dy * dy);
229                 if ((dx1 * dy2 - dx2 * dy1) > 0.0) dphi = -dphi;
230         }
231
232         data->angle += ((double)dphi) * (mi->precision ? (double)mi->precision_factor : 1.0);
233
234         data->mval_prev[0] = mval[0];
235         data->mval_prev[1] = mval[1];
236
237         output[0] = data->angle;
238 }
239
240 static void InputAngleSpring(TransInfo *t, MouseInput *mi, const double mval[2], float output[3])
241 {
242         float toutput[3];
243
244         InputAngle(t, mi, mval, output);
245         InputSpring(t, mi, mval, toutput);
246
247         output[1] = toutput[0];
248 }
249
250 void initMouseInput(TransInfo *UNUSED(t), MouseInput *mi, const float center[2], const int mval[2], const bool precision)
251 {
252         mi->factor = 0;
253         mi->precision = precision;
254
255         mi->center[0] = center[0];
256         mi->center[1] = center[1];
257
258         mi->imval[0] = mval[0];
259         mi->imval[1] = mval[1];
260
261         mi->post = NULL;
262 }
263
264 static void calcSpringFactor(MouseInput *mi)
265 {
266         mi->factor = sqrtf(((float)(mi->center[1] - mi->imval[1])) * ((float)(mi->center[1] - mi->imval[1])) +
267                            ((float)(mi->center[0] - mi->imval[0])) * ((float)(mi->center[0] - mi->imval[0])));
268
269         if (mi->factor == 0.0f) {
270                 mi->factor = 1.0f; /* prevent Inf */
271         }
272 }
273
274 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode)
275 {
276         /* incase we allocate a new value */
277         void *mi_data_prev = mi->data;
278
279         mi->use_virtual_mval = true;
280         mi->precision_factor = 1.0f / 10.0f;
281
282         switch (mode) {
283                 case INPUT_VECTOR:
284                         mi->apply = InputVector;
285                         t->helpline = HLP_NONE;
286                         break;
287                 case INPUT_SPRING:
288                         calcSpringFactor(mi);
289                         mi->apply = InputSpring;
290                         t->helpline = HLP_SPRING;
291                         break;
292                 case INPUT_SPRING_FLIP:
293                         calcSpringFactor(mi);
294                         mi->apply = InputSpringFlip;
295                         t->helpline = HLP_SPRING;
296                         break;
297                 case INPUT_SPRING_DELTA:
298                         calcSpringFactor(mi);
299                         mi->apply = InputSpringDelta;
300                         t->helpline = HLP_SPRING;
301                         break;
302                 case INPUT_ANGLE:
303                 case INPUT_ANGLE_SPRING:
304                 {
305                         struct InputAngle_Data *data;
306                         mi->use_virtual_mval = false;
307                         mi->precision_factor = 1.0f / 30.0f;
308                         data = MEM_callocN(sizeof(struct InputAngle_Data), "angle accumulator");
309                         data->mval_prev[0] = mi->imval[0];
310                         data->mval_prev[1] = mi->imval[1];
311                         mi->data = data;
312                         if (mode == INPUT_ANGLE) {
313                                 mi->apply = InputAngle;
314                         }
315                         else {
316                                 calcSpringFactor(mi);
317                                 mi->apply = InputAngleSpring;
318                         }
319                         t->helpline = HLP_ANGLE;
320                         break;
321                 }
322                 case INPUT_TRACKBALL:
323                         mi->precision_factor = 1.0f / 30.0f;
324                         /* factor has to become setting or so */
325                         mi->factor = 0.01f;
326                         mi->apply = InputTrackBall;
327                         t->helpline = HLP_TRACKBALL;
328                         break;
329                 case INPUT_HORIZONTAL_RATIO:
330                         mi->apply = InputHorizontalRatio;
331                         t->helpline = HLP_HARROW;
332                         break;
333                 case INPUT_HORIZONTAL_ABSOLUTE:
334                         mi->apply = InputHorizontalAbsolute;
335                         t->helpline = HLP_HARROW;
336                         break;
337                 case INPUT_VERTICAL_RATIO:
338                         mi->apply = InputVerticalRatio;
339                         t->helpline = HLP_VARROW;
340                         break;
341                 case INPUT_VERTICAL_ABSOLUTE:
342                         mi->apply = InputVerticalAbsolute;
343                         t->helpline = HLP_VARROW;
344                         break;
345                 case INPUT_CUSTOM_RATIO:
346                         mi->apply = InputCustomRatio;
347                         t->helpline = HLP_CARROW;
348                         break;
349                 case INPUT_CUSTOM_RATIO_FLIP:
350                         mi->apply = InputCustomRatioFlip;
351                         t->helpline = HLP_CARROW;
352                         break;
353                 case INPUT_NONE:
354                 default:
355                         mi->apply = NULL;
356                         break;
357         }
358
359         /* setup for the mouse cursor: either set a custom one,
360          * or hide it if it will be drawn with the helpline */
361         wmWindow *win = CTX_wm_window(t->context);
362         switch (t->helpline) {
363                 case HLP_NONE:
364                         /* INPUT_VECTOR, INPUT_CUSTOM_RATIO, INPUT_CUSTOM_RATIO_FLIP */
365                         if (t->flag & T_MODAL) {
366                                 t->flag |= T_MODAL_CURSOR_SET;
367                                 WM_cursor_modal_set(win, BC_NSEW_SCROLLCURSOR);
368                         }
369                         break;
370                 case HLP_SPRING:
371                 case HLP_ANGLE:
372                 case HLP_TRACKBALL:
373                 case HLP_HARROW:
374                 case HLP_VARROW:
375                 case HLP_CARROW:
376                         if (t->flag & T_MODAL) {
377                                 t->flag |= T_MODAL_CURSOR_SET;
378                                 WM_cursor_modal_set(win, CURSOR_NONE);
379                         }
380                         break;
381                 default:
382                         break;
383         }
384
385         /* if we've allocated new data, free the old data
386          * less hassle then checking before every alloc above */
387         if (mi_data_prev && (mi_data_prev != mi->data)) {
388                 MEM_freeN(mi_data_prev);
389         }
390
391         /* Don't write into the values when non-modal because they are already set from operator redo values. */
392         if (t->flag & T_MODAL) {
393                 /* bootstrap mouse input with initial values */
394                 applyMouseInput(t, mi, mi->imval, t->values);
395         }
396 }
397
398 void setInputPostFct(MouseInput *mi, void (*post)(struct TransInfo *t, float values[3]))
399 {
400         mi->post = post;
401 }
402
403 void applyMouseInput(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
404 {
405         double mval_db[2];
406
407         if (mi->use_virtual_mval) {
408                 /* update accumulator */
409                 double mval_delta[2];
410
411                 mval_delta[0] = (mval[0] - mi->imval[0]) - mi->virtual_mval.prev[0];
412                 mval_delta[1] = (mval[1] - mi->imval[1]) - mi->virtual_mval.prev[1];
413
414                 mi->virtual_mval.prev[0] += mval_delta[0];
415                 mi->virtual_mval.prev[1] += mval_delta[1];
416
417                 if (mi->precision) {
418                         mval_delta[0] *= (double)mi->precision_factor;
419                         mval_delta[1] *= (double)mi->precision_factor;
420                 }
421
422                 mi->virtual_mval.accum[0] += mval_delta[0];
423                 mi->virtual_mval.accum[1] += mval_delta[1];
424
425                 mval_db[0] = mi->imval[0] + mi->virtual_mval.accum[0];
426                 mval_db[1] = mi->imval[1] + mi->virtual_mval.accum[1];
427         }
428         else {
429                 mval_db[0] = mval[0];
430                 mval_db[1] = mval[1];
431         }
432
433
434         if (mi->apply != NULL) {
435                 mi->apply(t, mi, mval_db, output);
436         }
437
438         if (!is_zero_v3(t->values_modal_offset)) {
439                 float values_ofs[3];
440                 if (t->con.mode & CON_APPLY) {
441                         mul_v3_m3v3(values_ofs, t->spacemtx, t->values_modal_offset);
442                 }
443                 else {
444                         copy_v3_v3(values_ofs, t->values_modal_offset);
445                 }
446                 add_v3_v3(t->values, values_ofs);
447         }
448
449         if (mi->post) {
450                 mi->post(t, output);
451         }
452 }
453
454 eRedrawFlag handleMouseInput(TransInfo *t, MouseInput *mi, const wmEvent *event)
455 {
456         eRedrawFlag redraw = TREDRAW_NOTHING;
457
458         switch (event->type) {
459                 case LEFTSHIFTKEY:
460                 case RIGHTSHIFTKEY:
461                         if (event->val == KM_PRESS) {
462                                 t->modifiers |= MOD_PRECISION;
463                                 /* shift is modifier for higher precision transforn */
464                                 mi->precision = 1;
465                                 redraw = TREDRAW_HARD;
466                         }
467                         else if (event->val == KM_RELEASE) {
468                                 t->modifiers &= ~MOD_PRECISION;
469                                 mi->precision = 0;
470                                 redraw = TREDRAW_HARD;
471                         }
472                         break;
473         }
474
475         return redraw;
476 }