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