Merged changes in the trunk up to revision 54110.
[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 = (float)sqrt(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 InputTrackBall(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
98 {
99
100         if (mi->precision) {
101                 output[0] = (mi->imval[1] - mi->precision_mval[1]) + (mi->precision_mval[1] - mval[1]) * 0.1f;
102                 output[1] = (mi->precision_mval[0] - mi->imval[0]) + (mval[0] - mi->precision_mval[0]) * 0.1f;
103         }
104         else {
105                 output[0] = (float)(mi->imval[1] - mval[1]);
106                 output[1] = (float)(mval[0] - mi->imval[0]);
107         }
108
109         output[0] *= mi->factor;
110         output[1] *= mi->factor;
111 }
112
113 static void InputHorizontalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
114 {
115         float x, pad;
116
117         pad = t->ar->winx / 10;
118
119         if (mi->precision) {
120                 /* deal with Shift key by adding motion / 10 to motion before shift press */
121                 x = mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f;
122         }
123         else {
124                 x = mval[0];
125         }
126
127         output[0] = (x - pad) / (t->ar->winx - 2 * pad);
128 }
129
130 static void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
131 {
132         float vec[3];
133
134         InputVector(t, mi, mval, vec);
135         project_v3_v3v3(vec, vec, t->viewinv[0]);
136
137         output[0] = dot_v3v3(t->viewinv[0], vec) * 2.0f;
138 }
139
140 static void InputVerticalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
141 {
142         float y, pad;
143
144         pad = t->ar->winy / 10;
145
146         if (mi->precision) {
147                 /* deal with Shift key by adding motion / 10 to motion before shift press */
148                 y = mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f;
149         }
150         else {
151                 y = mval[0];
152         }
153
154         output[0] = (y - pad) / (t->ar->winy - 2 * pad);
155 }
156
157 static void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
158 {
159         float vec[3];
160
161         InputVector(t, mi, mval, vec);
162         project_v3_v3v3(vec, vec, t->viewinv[1]);
163
164         output[0] = dot_v3v3(t->viewinv[1], vec) * 2.0f;
165 }
166
167 void setCustomPoints(TransInfo *UNUSED(t), MouseInput *mi, const int start[2], const int end[2])
168 {
169         int *data;
170
171         if (mi->data == NULL) {
172                 mi->data = MEM_callocN(sizeof(int) * 4, "custom points");
173         }
174         
175         data = mi->data;
176
177         data[0] = start[0];
178         data[1] = start[1];
179         data[2] = end[0];
180         data[3] = end[1];
181 }
182
183 static void InputCustomRatio(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
184 {
185         double length;
186         double distance;
187         double dx, dy;
188         int *data = mi->data;
189         
190         if (data) {
191                 dx = data[2] - data[0];
192                 dy = data[3] - data[1];
193                 
194                 length = sqrt(dx * dx + dy * dy);
195                 
196                 if (mi->precision) {
197                         /* deal with Shift key by adding motion / 10 to motion before shift press */
198                         int mdx, mdy;
199                         mdx = (mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f) - data[2];
200                         mdy = (mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f) - data[3];
201
202                         distance = (length != 0.0) ? (mdx * dx + mdy * dy) / length : 0.0;
203                 }
204                 else {
205                         int mdx, mdy;
206                         mdx = mval[0] - data[2];
207                         mdy = mval[1] - data[3];
208
209                         distance = (length != 0.0) ? (mdx * dx + mdy * dy) / length : 0.0;
210                 }
211
212                 output[0] = (length != 0.0) ? (double)(distance / length) : 0.0;
213         }
214 }
215
216 static void InputAngle(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
217 {
218         double dx2 = mval[0] - mi->center[0];
219         double dy2 = mval[1] - mi->center[1];
220         double B = sqrt(dx2 * dx2 + dy2 * dy2);
221
222         double dx1 = mi->imval[0] - mi->center[0];
223         double dy1 = mi->imval[1] - mi->center[1];
224         double A = sqrt(dx1 * dx1 + dy1 * dy1);
225
226         double dx3 = mval[0] - mi->imval[0];
227         double dy3 = mval[1] - mi->imval[1];
228
229         double *angle = mi->data;
230
231         /* use doubles here, to make sure a "1.0" (no rotation) doesnt become 9.999999e-01, which gives 0.02 for acos */
232         double deler = (((dx1 * dx1 + dy1 * dy1) +
233                          (dx2 * dx2 + dy2 * dy2) -
234                          (dx3 * dx3 + dy3 * dy3)) / (2.0 * ((A * B) ? (A * B) : 1.0)));
235         /* ((A*B)?(A*B):1.0) this takes care of potential divide by zero errors */
236
237         float dphi;
238
239         dphi = saacos((float)deler);
240         if ((dx1 * dy2 - dx2 * dy1) > 0.0) dphi = -dphi;
241
242         /* If the angle is zero, because of lack of precision close to the 1.0 value in acos
243          * approximate the angle with the opposite side of the normalized triangle
244          * This is a good approximation here since the smallest acos value seems to be around
245          * 0.02 degree and lower values don't even have a 0.01% error compared to the approximation
246          */
247         if (dphi == 0) {
248                 double dx, dy;
249
250                 dx2 /= A;
251                 dy2 /= A;
252
253                 dx1 /= B;
254                 dy1 /= B;
255
256                 dx = dx1 - dx2;
257                 dy = dy1 - dy2;
258
259                 dphi = sqrt(dx * dx + dy * dy);
260                 if ((dx1 * dy2 - dx2 * dy1) > 0.0) dphi = -dphi;
261         }
262
263         if (mi->precision) {
264                 dphi = dphi / 30.0f;
265         }
266
267         /* if no delta angle, don't update initial position */
268         if (dphi != 0) {
269                 mi->imval[0] = mval[0];
270                 mi->imval[1] = mval[1];
271         }
272
273         *angle += (double)dphi;
274
275         output[0] = *angle;
276 }
277
278 void initMouseInput(TransInfo *UNUSED(t), MouseInput *mi, const int center[2], const int mval[2])
279 {
280         mi->factor = 0;
281         mi->precision = 0;
282
283         mi->center[0] = center[0];
284         mi->center[1] = center[1];
285
286         mi->imval[0] = mval[0];
287         mi->imval[1] = mval[1];
288
289         mi->post = NULL;
290 }
291
292 static void calcSpringFactor(MouseInput *mi)
293 {
294         mi->factor = sqrtf(((float)(mi->center[1] - mi->imval[1])) * ((float)(mi->center[1] - mi->imval[1])) +
295                            ((float)(mi->center[0] - mi->imval[0])) * ((float)(mi->center[0] - mi->imval[0])));
296
297         if (mi->factor == 0.0f) {
298                 mi->factor = 1.0f; /* prevent Inf */
299         }
300 }
301
302 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode)
303 {
304         /* may have been allocated previously */
305         /* TODO, holding R-key can cause mem leak, but this causes [#28903]
306          * disable for now. */
307 #if 0
308         if (mi->data) {
309                 MEM_freeN(mi->data);
310                 mi->data = NULL;
311         }
312 #endif
313
314         switch (mode) {
315                 case INPUT_VECTOR:
316                         mi->apply = InputVector;
317                         t->helpline = HLP_NONE;
318                         break;
319                 case INPUT_SPRING:
320                         calcSpringFactor(mi);
321                         mi->apply = InputSpring;
322                         t->helpline = HLP_SPRING;
323                         break;
324                 case INPUT_SPRING_FLIP:
325                         calcSpringFactor(mi);
326                         mi->apply = InputSpringFlip;
327                         t->helpline = HLP_SPRING;
328                         break;
329                 case INPUT_ANGLE:
330                         mi->data = MEM_callocN(sizeof(double), "angle accumulator");
331                         mi->apply = InputAngle;
332                         t->helpline = HLP_ANGLE;
333                         break;
334                 case INPUT_TRACKBALL:
335                         /* factor has to become setting or so */
336                         mi->factor = 0.01f;
337                         mi->apply = InputTrackBall;
338                         t->helpline = HLP_TRACKBALL;
339                         break;
340                 case INPUT_HORIZONTAL_RATIO:
341                         mi->factor = (float)(mi->center[0] - mi->imval[0]);
342                         mi->apply = InputHorizontalRatio;
343                         t->helpline = HLP_HARROW;
344                         break;
345                 case INPUT_HORIZONTAL_ABSOLUTE:
346                         mi->apply = InputHorizontalAbsolute;
347                         t->helpline = HLP_HARROW;
348                         break;
349                 case INPUT_VERTICAL_RATIO:
350                         mi->apply = InputVerticalRatio;
351                         t->helpline = HLP_VARROW;
352                         break;
353                 case INPUT_VERTICAL_ABSOLUTE:
354                         mi->apply = InputVerticalAbsolute;
355                         t->helpline = HLP_VARROW;
356                         break;
357                 case INPUT_CUSTOM_RATIO:
358                         mi->apply = InputCustomRatio;
359                         t->helpline = HLP_NONE;
360                         break;
361                 case INPUT_NONE:
362                 default:
363                         mi->apply = NULL;
364                         break;
365         }
366
367         /* bootstrap mouse input with initial values */
368         applyMouseInput(t, mi, mi->imval, t->values);
369 }
370
371 void setInputPostFct(MouseInput *mi, void (*post)(struct TransInfo *t, float values[3]))
372 {
373         mi->post = post;
374 }
375
376 void applyMouseInput(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
377 {
378         if (mi->apply != NULL) {
379                 mi->apply(t, mi, mval, output);
380         }
381
382         if (mi->post) {
383                 mi->post(t, output);
384         }
385 }
386
387 int handleMouseInput(TransInfo *t, MouseInput *mi, wmEvent *event)
388 {
389         int redraw = TREDRAW_NOTHING;
390
391         switch (event->type) {
392                 case LEFTSHIFTKEY:
393                 case RIGHTSHIFTKEY:
394                         if (event->val == KM_PRESS) {
395                                 t->modifiers |= MOD_PRECISION;
396                                 /* shift is modifier for higher precision transform
397                                  * store the mouse position where the normal movement ended */
398                                 copy_v2_v2_int(mi->precision_mval, event->mval);
399                                 mi->precision = 1;
400                                 redraw = TREDRAW_HARD;
401                         }
402                         else if (event->val == KM_RELEASE) {
403                                 t->modifiers &= ~MOD_PRECISION;
404                                 mi->precision = 0;
405                                 redraw = TREDRAW_HARD;
406                         }
407                         break;
408         }
409
410         return redraw;
411 }