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