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