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