svn merge -r 30566:30717 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender-staging.git] / source / blender / editors / transform / transform_input.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): none yet.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26 #include <math.h>
27
28 #include "DNA_screen_types.h"
29
30 #include "BLI_math.h"
31
32 #include "WM_types.h"
33
34 #include "transform.h"
35
36 #include "MEM_guardedalloc.h" 
37
38 /* ************************** INPUT FROM MOUSE *************************** */
39
40 void InputVector(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
41 {
42         float vec[3], dvec[3];
43         if(mi->precision)
44         {
45                 /* calculate the main translation and the precise one separate */
46                 convertViewVec(t, dvec, (short)(mval[0] - mi->precision_mval[0]), (short)(mval[1] - mi->precision_mval[1]));
47                 mul_v3_fl(dvec, 0.1f);
48                 convertViewVec(t, vec, (short)(mi->precision_mval[0] - t->imval[0]), (short)(mi->precision_mval[1] - t->imval[1]));
49                 add_v3_v3v3(output, vec, dvec);
50         }
51         else
52         {
53                 convertViewVec(t, output, (short)(mval[0] - t->imval[0]), (short)(mval[1] - t->imval[1]));
54         }
55
56 }
57
58 void InputSpring(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
59 {
60         float ratio, precise_ratio, dx, dy;
61         if(mi->precision)
62         {
63                 /* calculate ratio for shiftkey pos, and for total, and blend these for precision */
64                 dx = (float)(mi->center[0] - mi->precision_mval[0]);
65                 dy = (float)(mi->center[1] - mi->precision_mval[1]);
66                 ratio = (float)sqrt( dx*dx + dy*dy);
67
68                 dx= (float)(mi->center[0] - mval[0]);
69                 dy= (float)(mi->center[1] - mval[1]);
70                 precise_ratio = (float)sqrt( dx*dx + dy*dy);
71
72                 ratio = (ratio + (precise_ratio - ratio) / 10.0f) / mi->factor;
73         }
74         else
75         {
76                 dx = (float)(mi->center[0] - mval[0]);
77                 dy = (float)(mi->center[1] - mval[1]);
78                 ratio = (float)sqrt( dx*dx + dy*dy) / mi->factor;
79         }
80
81         output[0] = ratio;
82 }
83
84 void InputSpringFlip(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
85 {
86         InputSpring(t, mi, mval, output);
87
88         /* flip scale */
89         if      ((mi->center[0] - mval[0]) * (mi->center[0] - mi->imval[0]) +
90                  (mi->center[1] - mval[1]) * (mi->center[1] - mi->imval[1]) < 0)
91          {
92                 output[0] *= -1.0f;
93          }
94 }
95
96 void InputTrackBall(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
97 {
98
99         if(mi->precision)
100         {
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         {
106                 output[0] = (float)( mi->imval[1] - mval[1] );
107                 output[1] = (float)( mval[0] - mi->imval[0] );
108         }
109
110         output[0] *= mi->factor;
111         output[1] *= mi->factor;
112 }
113
114 void InputHorizontalRatio(TransInfo *t, MouseInput *mi, short mval[2], float output[3]) {
115         float x, pad;
116
117         pad = t->ar->winx / 10;
118
119         if (mi->precision)
120         {
121                 /* deal with Shift key by adding motion / 10 to motion before shift press */
122                 x = mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f;
123         }
124         else {
125                 x = mval[0];
126         }
127
128         output[0] = (x - pad) / (t->ar->winx - 2 * pad);
129 }
130
131 void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, short mval[2], float output[3]) {
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 void InputVerticalRatio(TransInfo *t, MouseInput *mi, short mval[2], float output[3]) {
141         float y, pad;
142
143         pad = t->ar->winy / 10;
144
145         if (mi->precision) {
146                 /* deal with Shift key by adding motion / 10 to motion before shift press */
147                 y = mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f;
148         }
149         else {
150                 y = mval[0];
151         }
152
153         output[0] = (y - pad) / (t->ar->winy - 2 * pad);
154 }
155
156 void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, short mval[2], float output[3]) {
157         float vec[3];
158
159         InputVector(t, mi, mval, vec);
160         project_v3_v3v3(vec, vec, t->viewinv[1]);
161
162         output[0] = dot_v3v3(t->viewinv[1], vec) * 2.0f;
163 }
164
165 void setCustomPoints(TransInfo *t, MouseInput *mi, short start[2], short end[2])
166 {
167         short *data;
168
169         if (mi->data == NULL) {
170                 mi->data = MEM_callocN(sizeof(short) * 4, "custom points");
171         }
172         
173         data = mi->data;
174
175         data[0] = start[0];
176         data[1] = start[1];
177         data[2] = end[0];
178         data[3] = end[1];
179 }
180
181 void InputCustomRatio(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
182 {
183         float length;
184         float distance;
185         short *data = mi->data;
186         short dx, dy;
187         
188         if (data) {
189                 dx = data[2] - data[0];
190                 dy = data[3] - data[1];
191                 
192                 length = (float)sqrtf(dx*dx + dy*dy);
193                 
194                 if (mi->precision) {
195                         /* deal with Shift key by adding motion / 10 to motion before shift press */
196                         short mdx, mdy;
197                         mdx = (mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f) - data[2];
198                         mdy = (mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f) - data[3];
199
200                         distance = (length != 0.0f)? (mdx*dx + mdy*dy) / length: 0.0f;
201                 }
202                 else {
203                         short mdx, mdy;
204                         mdx = mval[0] - data[2];
205                         mdy = mval[1] - data[3];
206
207                         distance = (length != 0.0f)? (mdx*dx + mdy*dy) / length: 0.0f;
208                 }
209
210                 output[0] = (length != 0.0f)? distance / length: 0.0f;
211         }
212 }
213
214 void InputAngle(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
215 {
216         double dx2 = mval[0] - mi->center[0];
217         double dy2 = mval[1] - mi->center[1];
218         double B = sqrt(dx2*dx2+dy2*dy2);
219
220         double dx1 = mi->imval[0] - mi->center[0];
221         double dy1 = mi->imval[1] - mi->center[1];
222         double A = sqrt(dx1*dx1+dy1*dy1);
223
224         double dx3 = mval[0] - mi->imval[0];
225         double dy3 = mval[1] - mi->imval[1];
226
227         double *angle = mi->data;
228
229         /* use doubles here, to make sure a "1.0" (no rotation) doesnt become 9.999999e-01, which gives 0.02 for acos */
230         double deler = ((dx1*dx1+dy1*dy1)+(dx2*dx2+dy2*dy2)-(dx3*dx3+dy3*dy3))
231                 / (2.0 * (A*B?A*B:1.0));
232         /* (A*B?A*B:1.0f) this takes care of potential divide by zero errors */
233
234         float dphi;
235
236         dphi = saacos((float)deler);
237         if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
238
239         /* If the angle is zero, because of lack of precision close to the 1.0 value in acos
240          * approximate the angle with the oposite side of the normalized triangle
241          * This is a good approximation here since the smallest acos value seems to be around
242          * 0.02 degree and lower values don't even have a 0.01% error compared to the approximation
243          * */
244         if (dphi == 0)
245         {
246                 double dx, dy;
247
248                 dx2 /= A;
249                 dy2 /= A;
250
251                 dx1 /= B;
252                 dy1 /= B;
253
254                 dx = dx1 - dx2;
255                 dy = dy1 - dy2;
256
257                 dphi = sqrt(dx*dx + dy*dy);
258                 if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
259         }
260
261         if(mi->precision) dphi = dphi/30.0f;
262
263         /* if no delta angle, don't update initial position */
264         if (dphi != 0)
265         {
266                 mi->imval[0] = mval[0];
267                 mi->imval[1] = mval[1];
268         }
269
270         *angle += dphi;
271
272         output[0] = *angle;
273 }
274
275 void initMouseInput(TransInfo *t, MouseInput *mi, int center[2], short mval[2])
276 {
277         mi->factor = 0;
278         mi->precision = 0;
279
280         mi->center[0] = center[0];
281         mi->center[1] = center[1];
282
283         mi->imval[0] = mval[0];
284         mi->imval[1] = mval[1];
285
286         mi->post = NULL;
287 }
288
289 static void calcSpringFactor(MouseInput *mi)
290 {
291         mi->factor = (float)sqrt(
292                 (
293                         ((float)(mi->center[1] - mi->imval[1]))*((float)(mi->center[1] - mi->imval[1]))
294                 +
295                         ((float)(mi->center[0] - mi->imval[0]))*((float)(mi->center[0] - mi->imval[0]))
296                 ) );
297
298         if (mi->factor==0.0f)
299                 mi->factor= 1.0f; /* prevent Inf */
300 }
301
302 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode)
303 {
304
305         switch(mode)
306         {
307         case INPUT_VECTOR:
308                 mi->apply = InputVector;
309                 t->helpline = HLP_NONE;
310                 break;
311         case INPUT_SPRING:
312                 calcSpringFactor(mi);
313                 mi->apply = InputSpring;
314                 t->helpline = HLP_SPRING;
315                 break;
316         case INPUT_SPRING_FLIP:
317                 calcSpringFactor(mi);
318                 mi->apply = InputSpringFlip;
319                 t->helpline = HLP_SPRING;
320                 break;
321         case INPUT_ANGLE:
322                 mi->data = MEM_callocN(sizeof(double), "angle accumulator");
323                 mi->apply = InputAngle;
324                 t->helpline = HLP_ANGLE;
325                 break;
326         case INPUT_TRACKBALL:
327                 /* factor has to become setting or so */
328                 mi->factor = 0.01f;
329                 mi->apply = InputTrackBall;
330                 t->helpline = HLP_TRACKBALL;
331                 break;
332         case INPUT_HORIZONTAL_RATIO:
333                 mi->factor = (float)(mi->center[0] - mi->imval[0]);
334                 mi->apply = InputHorizontalRatio;
335                 t->helpline = HLP_HARROW;
336                 break;
337         case INPUT_HORIZONTAL_ABSOLUTE:
338                 mi->apply = InputHorizontalAbsolute;
339                 t->helpline = HLP_HARROW;
340                 break;
341         case INPUT_VERTICAL_RATIO:
342                 mi->apply = InputVerticalRatio;
343                 t->helpline = HLP_VARROW;
344                 break;
345         case INPUT_VERTICAL_ABSOLUTE:
346                 mi->apply = InputVerticalAbsolute;
347                 t->helpline = HLP_VARROW;
348                 break;
349         case INPUT_CUSTOM_RATIO:
350                 mi->apply = InputCustomRatio;
351                 t->helpline = HLP_NONE;
352                 break;
353         case INPUT_NONE:
354         default:
355                 mi->apply = NULL;
356                 break;
357         }
358
359         /* bootstrap mouse input with initial values */
360         applyMouseInput(t, mi, mi->imval, t->values);
361 }
362
363 void setInputPostFct(MouseInput *mi, void       (*post)(struct TransInfo *, float [3]))
364 {
365         mi->post = post;
366 }
367
368 void applyMouseInput(TransInfo *t, MouseInput *mi, short mval[2], float output[3])
369 {
370         if (mi->apply != NULL)
371         {
372                 mi->apply(t, mi, mval, output);
373         }
374
375         if (mi->post)
376         {
377                 mi->post(t, output);
378         }
379 }
380
381 int handleMouseInput(TransInfo *t, MouseInput *mi, wmEvent *event)
382 {
383         int redraw = TREDRAW_NOTHING;
384
385         switch (event->type)
386         {
387         case LEFTSHIFTKEY:
388         case RIGHTSHIFTKEY:
389                 if (event->val==KM_PRESS)
390                 {
391                         t->modifiers |= MOD_PRECISION;
392                         /* shift is modifier for higher precision transform
393                          * store the mouse position where the normal movement ended */
394                         mi->precision_mval[0] = event->x - t->ar->winrct.xmin;
395                         mi->precision_mval[1] = event->y - t->ar->winrct.ymin;
396                         mi->precision = 1;
397                 }
398                 else
399                 {
400                         t->modifiers &= ~MOD_PRECISION;
401                         mi->precision = 0;
402                 }
403                 redraw = TREDRAW_HARD;
404                 break;
405         }
406
407         return redraw;
408 }