Merged changes in the trunk up to revision 54802.
[blender-staging.git] / source / blender / editors / transform / transform_constraints.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/transform/transform_constraints.c
29  *  \ingroup edtransform
30  */
31
32
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <math.h>
37
38 #ifndef WIN32
39 #include <unistd.h>
40 #else
41 #include <io.h>
42 #endif
43
44
45 #include "DNA_object_types.h"
46 #include "DNA_scene_types.h"
47 #include "DNA_screen_types.h"
48 #include "DNA_space_types.h"
49 #include "DNA_view3d_types.h"
50
51 #include "BIF_gl.h"
52 #include "BIF_glutil.h"
53
54 #include "BKE_context.h"
55
56 #include "ED_image.h"
57 #include "ED_view3d.h"
58
59 #include "BLI_math.h"
60 #include "BLI_utildefines.h"
61 #include "BLI_string.h"
62
63 #include "BLF_translation.h"
64
65 #include "UI_resources.h"
66
67 #include "transform.h"
68
69 static void drawObjectConstraint(TransInfo *t);
70
71 /* ************************** CONSTRAINTS ************************* */
72 static void constraintAutoValues(TransInfo *t, float vec[3])
73 {
74         int mode = t->con.mode;
75         if (mode & CON_APPLY) {
76                 float nval = (t->flag & T_NULL_ONE) ? 1.0f : 0.0f;
77
78                 if ((mode & CON_AXIS0) == 0) {
79                         vec[0] = nval;
80                 }
81                 if ((mode & CON_AXIS1) == 0) {
82                         vec[1] = nval;
83                 }
84                 if ((mode & CON_AXIS2) == 0) {
85                         vec[2] = nval;
86                 }
87         }
88 }
89
90 void constraintNumInput(TransInfo *t, float vec[3])
91 {
92         int mode = t->con.mode;
93         if (mode & CON_APPLY) {
94                 float nval = (t->flag & T_NULL_ONE) ? 1.0f : 0.0f;
95
96                 if (getConstraintSpaceDimension(t) == 2) {
97                         int axis = mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2);
98                         if (axis == (CON_AXIS0 | CON_AXIS1)) {
99                                 /* vec[0] = vec[0]; */ /* same */
100                                 /* vec[1] = vec[1]; */ /* same */
101                                 vec[2] = nval;
102                         }
103                         else if (axis == (CON_AXIS1 | CON_AXIS2)) {
104                                 vec[2] = vec[1];
105                                 vec[1] = vec[0];
106                                 vec[0] = nval;
107                         }
108                         else if (axis == (CON_AXIS0 | CON_AXIS2)) {
109                                 /* vec[0] = vec[0]; */  /* same */
110                                 vec[2] = vec[1];
111                                 vec[1] = nval;
112                         }
113                 }
114                 else if (getConstraintSpaceDimension(t) == 1) {
115                         if (mode & CON_AXIS0) {
116                                 /* vec[0] = vec[0]; */ /* same */
117                                 vec[1] = nval;
118                                 vec[2] = nval;
119                         }
120                         else if (mode & CON_AXIS1) {
121                                 vec[1] = vec[0];
122                                 vec[0] = nval;
123                                 vec[2] = nval;
124                         }
125                         else if (mode & CON_AXIS2) {
126                                 vec[2] = vec[0];
127                                 vec[0] = nval;
128                                 vec[1] = nval;
129                         }
130                 }
131         }
132 }
133
134 static void postConstraintChecks(TransInfo *t, float vec[3], float pvec[3])
135 {
136         int i = 0;
137
138         mul_m3_v3(t->con.imtx, vec);
139
140         snapGrid(t, vec);
141
142         if (t->num.flag & T_NULL_ONE) {
143                 if (!(t->con.mode & CON_AXIS0))
144                         vec[0] = 1.0f;
145
146                 if (!(t->con.mode & CON_AXIS1))
147                         vec[1] = 1.0f;
148
149                 if (!(t->con.mode & CON_AXIS2))
150                         vec[2] = 1.0f;
151         }
152
153         if (hasNumInput(&t->num)) {
154                 applyNumInput(&t->num, vec);
155                 constraintNumInput(t, vec);
156                 removeAspectRatio(t, vec);
157         }
158
159         /* autovalues is operator param, use that directly but not if snapping is forced */
160         if (t->flag & T_AUTOVALUES && (t->tsnap.status & SNAP_FORCED) == 0) {
161                 mul_v3_m3v3(vec, t->con.imtx, t->auto_values);
162                 constraintAutoValues(t, vec);
163                 /* inverse transformation at the end */
164         }
165
166         if (t->con.mode & CON_AXIS0) {
167                 pvec[i++] = vec[0];
168         }
169         if (t->con.mode & CON_AXIS1) {
170                 pvec[i++] = vec[1];
171         }
172         if (t->con.mode & CON_AXIS2) {
173                 pvec[i++] = vec[2];
174         }
175
176         mul_m3_v3(t->con.mtx, vec);
177 }
178
179 static void viewAxisCorrectCenter(TransInfo *t, float t_con_center[3])
180 {
181         if (t->spacetype == SPACE_VIEW3D) {
182                 // View3D *v3d = t->sa->spacedata.first;
183                 const float min_dist = 1.0f;  /* v3d->near; */
184                 float dir[3];
185                 float l;
186
187                 sub_v3_v3v3(dir, t_con_center, t->viewinv[3]);
188                 if (dot_v3v3(dir, t->viewinv[2]) < 0.0f) {
189                         negate_v3(dir);
190                 }
191                 project_v3_v3v3(dir, dir, t->viewinv[2]);
192
193                 l = len_v3(dir);
194
195                 if (l < min_dist) {
196                         float diff[3];
197                         normalize_v3_v3(diff, t->viewinv[2]);
198                         mul_v3_fl(diff, min_dist - l);
199
200                         sub_v3_v3(t_con_center, diff);
201                 }
202         }
203 }
204
205 static void axisProjection(TransInfo *t, const float axis[3], const float in[3], float out[3])
206 {
207         float norm[3], vec[3], factor, angle;
208         float t_con_center[3];
209
210         if (is_zero_v3(in)) {
211                 return;
212         }
213
214         copy_v3_v3(t_con_center, t->con.center);
215
216         /* checks for center being too close to the view center */
217         viewAxisCorrectCenter(t, t_con_center);
218         
219         angle = fabsf(angle_v3v3(axis, t->viewinv[2]));
220         if (angle > (float)M_PI / 2.0f) {
221                 angle = (float)M_PI - angle;
222         }
223         angle = RAD2DEGF(angle);
224
225         /* For when view is parallel to constraint... will cause NaNs otherwise
226          * So we take vertical motion in 3D space and apply it to the
227          * constraint axis. Nice for camera grab + MMB */
228         if (angle < 5.0f) {
229                 project_v3_v3v3(vec, in, t->viewinv[1]);
230                 factor = dot_v3v3(t->viewinv[1], vec) * 2.0f;
231                 /* since camera distance is quite relative, use quadratic relationship. holding shift can compensate */
232                 if (factor < 0.0f) factor *= -factor;
233                 else factor *= factor;
234
235                 copy_v3_v3(out, axis);
236                 normalize_v3(out);
237                 mul_v3_fl(out, -factor);  /* -factor makes move down going backwards */
238         }
239         else {
240                 float v[3], i1[3], i2[3];
241                 float v2[3], v4[3];
242                 float norm_center[3];
243                 float plane[3];
244
245                 getViewVector(t, t_con_center, norm_center);
246                 cross_v3_v3v3(plane, norm_center, axis);
247
248                 project_v3_v3v3(vec, in, plane);
249                 sub_v3_v3v3(vec, in, vec);
250                 
251                 add_v3_v3v3(v, vec, t_con_center);
252                 getViewVector(t, v, norm);
253
254                 /* give arbitrary large value if projection is impossible */
255                 factor = dot_v3v3(axis, norm);
256                 if (1.0f - fabsf(factor) < 0.0002f) {
257                         copy_v3_v3(out, axis);
258                         if (factor > 0) {
259                                 mul_v3_fl(out, 1000000000.0f);
260                         }
261                         else {
262                                 mul_v3_fl(out, -1000000000.0f);
263                         }
264                 }
265                 else {
266                         add_v3_v3v3(v2, t_con_center, axis);
267                         add_v3_v3v3(v4, v, norm);
268                         
269                         isect_line_line_v3(t_con_center, v2, v, v4, i1, i2);
270                         
271                         sub_v3_v3v3(v, i2, v);
272         
273                         sub_v3_v3v3(out, i1, t_con_center);
274
275                         /* possible some values become nan when
276                          * viewpoint and object are both zero */
277                         if (!finite(out[0])) out[0] = 0.0f;
278                         if (!finite(out[1])) out[1] = 0.0f;
279                         if (!finite(out[2])) out[2] = 0.0f;
280                 }
281         }
282 }
283
284 static void planeProjection(TransInfo *t, const float in[3], float out[3])
285 {
286         float vec[3], factor, norm[3];
287
288         add_v3_v3v3(vec, in, t->con.center);
289         getViewVector(t, vec, norm);
290
291         sub_v3_v3v3(vec, out, in);
292
293         factor = dot_v3v3(vec, norm);
294         if (fabsf(factor) <= 0.001f) {
295                 return; /* prevent divide by zero */
296         }
297         factor = dot_v3v3(vec, vec) / factor;
298
299         copy_v3_v3(vec, norm);
300         mul_v3_fl(vec, factor);
301
302         add_v3_v3v3(out, in, vec);
303 }
304
305 /*
306  * Generic callback for constant spatial constraints applied to linear motion
307  *
308  * The IN vector in projected into the constrained space and then further
309  * projected along the view vector.
310  * (in perspective mode, the view vector is relative to the position on screen)
311  *
312  */
313
314 static void applyAxisConstraintVec(TransInfo *t, TransData *td, const float in[3], float out[3], float pvec[3])
315 {
316         copy_v3_v3(out, in);
317         if (!td && t->con.mode & CON_APPLY) {
318                 mul_m3_v3(t->con.pmtx, out);
319
320                 // With snap, a projection is alright, no need to correct for view alignment
321                 if (!(t->tsnap.mode != SCE_SNAP_MODE_INCREMENT && activeSnap(t))) {
322                         if (getConstraintSpaceDimension(t) == 2) {
323                                 if (out[0] != 0.0f || out[1] != 0.0f || out[2] != 0.0f) {
324                                         planeProjection(t, in, out);
325                                 }
326                         }
327                         else if (getConstraintSpaceDimension(t) == 1) {
328                                 float c[3];
329
330                                 if (t->con.mode & CON_AXIS0) {
331                                         copy_v3_v3(c, t->con.mtx[0]);
332                                 }
333                                 else if (t->con.mode & CON_AXIS1) {
334                                         copy_v3_v3(c, t->con.mtx[1]);
335                                 }
336                                 else if (t->con.mode & CON_AXIS2) {
337                                         copy_v3_v3(c, t->con.mtx[2]);
338                                 }
339                                 axisProjection(t, c, in, out);
340                         }
341                 }
342                 postConstraintChecks(t, out, pvec);
343         }
344 }
345
346 /*
347  * Generic callback for object based spatial constraints applied to linear motion
348  *
349  * At first, the following is applied to the first data in the array
350  * The IN vector in projected into the constrained space and then further
351  * projected along the view vector.
352  * (in perspective mode, the view vector is relative to the position on screen)
353  *
354  * Further down, that vector is mapped to each data's space.
355  */
356
357 static void applyObjectConstraintVec(TransInfo *t, TransData *td, const float in[3], float out[3], float pvec[3])
358 {
359         copy_v3_v3(out, in);
360         if (t->con.mode & CON_APPLY) {
361                 if (!td) {
362                         mul_m3_v3(t->con.pmtx, out);
363                         if (getConstraintSpaceDimension(t) == 2) {
364                                 if (out[0] != 0.0f || out[1] != 0.0f || out[2] != 0.0f) {
365                                         planeProjection(t, in, out);
366                                 }
367                         }
368                         else if (getConstraintSpaceDimension(t) == 1) {
369                                 float c[3];
370
371                                 if (t->con.mode & CON_AXIS0) {
372                                         copy_v3_v3(c, t->con.mtx[0]);
373                                 }
374                                 else if (t->con.mode & CON_AXIS1) {
375                                         copy_v3_v3(c, t->con.mtx[1]);
376                                 }
377                                 else if (t->con.mode & CON_AXIS2) {
378                                         copy_v3_v3(c, t->con.mtx[2]);
379                                 }
380                                 axisProjection(t, c, in, out);
381                         }
382                         postConstraintChecks(t, out, pvec);
383                         copy_v3_v3(out, pvec);
384                 }
385                 else {
386                         int i = 0;
387
388                         out[0] = out[1] = out[2] = 0.0f;
389                         if (t->con.mode & CON_AXIS0) {
390                                 out[0] = in[i++];
391                         }
392                         if (t->con.mode & CON_AXIS1) {
393                                 out[1] = in[i++];
394                         }
395                         if (t->con.mode & CON_AXIS2) {
396                                 out[2] = in[i++];
397                         }
398                         mul_m3_v3(td->axismtx, out);
399                 }
400         }
401 }
402
403 /*
404  * Generic callback for constant spatial constraints applied to resize motion
405  */
406
407 static void applyAxisConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
408 {
409         if (!td && t->con.mode & CON_APPLY) {
410                 float tmat[3][3];
411
412                 if (!(t->con.mode & CON_AXIS0)) {
413                         smat[0][0] = 1.0f;
414                 }
415                 if (!(t->con.mode & CON_AXIS1)) {
416                         smat[1][1] = 1.0f;
417                 }
418                 if (!(t->con.mode & CON_AXIS2)) {
419                         smat[2][2] = 1.0f;
420                 }
421
422                 mul_m3_m3m3(tmat, smat, t->con.imtx);
423                 mul_m3_m3m3(smat, t->con.mtx, tmat);
424         }
425 }
426
427 /*
428  * Callback for object based spatial constraints applied to resize motion
429  */
430
431 static void applyObjectConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
432 {
433         if (td && t->con.mode & CON_APPLY) {
434                 float tmat[3][3];
435                 float imat[3][3];
436
437                 invert_m3_m3(imat, td->axismtx);
438
439                 if (!(t->con.mode & CON_AXIS0)) {
440                         smat[0][0] = 1.0f;
441                 }
442                 if (!(t->con.mode & CON_AXIS1)) {
443                         smat[1][1] = 1.0f;
444                 }
445                 if (!(t->con.mode & CON_AXIS2)) {
446                         smat[2][2] = 1.0f;
447                 }
448
449                 mul_m3_m3m3(tmat, smat, imat);
450                 mul_m3_m3m3(smat, td->axismtx, tmat);
451         }
452 }
453
454 /*
455  * Generic callback for constant spatial constraints applied to rotations
456  *
457  * The rotation axis is copied into VEC.
458  *
459  * In the case of single axis constraints, the rotation axis is directly the one constrained to.
460  * For planar constraints (2 axis), the rotation axis is the normal of the plane.
461  *
462  * The following only applies when CON_NOFLIP is not set.
463  * The vector is then modified to always point away from the screen (in global space)
464  * This insures that the rotation is always logically following the mouse.
465  * (ie: not doing counterclockwise rotations when the mouse moves clockwise).
466  */
467
468 static void applyAxisConstraintRot(TransInfo *t, TransData *td, float vec[3], float *angle)
469 {
470         if (!td && t->con.mode & CON_APPLY) {
471                 int mode = t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2);
472
473                 switch (mode) {
474                         case CON_AXIS0:
475                         case (CON_AXIS1 | CON_AXIS2):
476                                 copy_v3_v3(vec, t->con.mtx[0]);
477                                 break;
478                         case CON_AXIS1:
479                         case (CON_AXIS0 | CON_AXIS2):
480                                 copy_v3_v3(vec, t->con.mtx[1]);
481                                 break;
482                         case CON_AXIS2:
483                         case (CON_AXIS0 | CON_AXIS1):
484                                 copy_v3_v3(vec, t->con.mtx[2]);
485                                 break;
486                 }
487                 /* don't flip axis if asked to or if num input */
488                 if (angle && (mode & CON_NOFLIP) == 0 && hasNumInput(&t->num) == 0) {
489                         if (dot_v3v3(vec, t->viewinv[2]) > 0.0f) {
490                                 *angle = -(*angle);
491                         }
492                 }
493         }
494 }
495
496 /*
497  * Callback for object based spatial constraints applied to rotations
498  *
499  * The rotation axis is copied into VEC.
500  *
501  * In the case of single axis constraints, the rotation axis is directly the one constrained to.
502  * For planar constraints (2 axis), the rotation axis is the normal of the plane.
503  *
504  * The following only applies when CON_NOFLIP is not set.
505  * The vector is then modified to always point away from the screen (in global space)
506  * This insures that the rotation is always logically following the mouse.
507  * (ie: not doing counterclockwise rotations when the mouse moves clockwise).
508  */
509
510 static void applyObjectConstraintRot(TransInfo *t, TransData *td, float vec[3], float *angle)
511 {
512         if (t->con.mode & CON_APPLY) {
513                 int mode = t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2);
514
515                 /* on setup call, use first object */
516                 if (td == NULL) {
517                         td = t->data;
518                 }
519
520                 switch (mode) {
521                         case CON_AXIS0:
522                         case (CON_AXIS1 | CON_AXIS2):
523                                 copy_v3_v3(vec, td->axismtx[0]);
524                                 break;
525                         case CON_AXIS1:
526                         case (CON_AXIS0 | CON_AXIS2):
527                                 copy_v3_v3(vec, td->axismtx[1]);
528                                 break;
529                         case CON_AXIS2:
530                         case (CON_AXIS0 | CON_AXIS1):
531                                 copy_v3_v3(vec, td->axismtx[2]);
532                                 break;
533                 }
534                 if (angle && (mode & CON_NOFLIP) == 0 && hasNumInput(&t->num) == 0) {
535                         if (dot_v3v3(vec, t->viewinv[2]) > 0.0f) {
536                                 *angle = -(*angle);
537                         }
538                 }
539         }
540 }
541
542 /*--------------------- INTERNAL SETUP CALLS ------------------*/
543
544 void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[])
545 {
546         BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
547         copy_m3_m3(t->con.mtx, space);
548         t->con.mode = mode;
549         getConstraintMatrix(t);
550
551         startConstraint(t);
552
553         t->con.drawExtra = NULL;
554         t->con.applyVec = applyAxisConstraintVec;
555         t->con.applySize = applyAxisConstraintSize;
556         t->con.applyRot = applyAxisConstraintRot;
557         t->redraw = 1;
558 }
559
560 void setLocalConstraint(TransInfo *t, int mode, const char text[])
561 {
562         if (t->flag & T_EDIT) {
563                 float obmat[3][3];
564                 copy_m3_m4(obmat, t->scene->obedit->obmat);
565                 normalize_m3(obmat);
566                 setConstraint(t, obmat, mode, text);
567         }
568         else {
569                 if (t->total == 1) {
570                         setConstraint(t, t->data->axismtx, mode, text);
571                 }
572                 else {
573                         BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
574                         copy_m3_m3(t->con.mtx, t->data->axismtx);
575                         t->con.mode = mode;
576                         getConstraintMatrix(t);
577
578                         startConstraint(t);
579
580                         t->con.drawExtra = drawObjectConstraint;
581                         t->con.applyVec = applyObjectConstraintVec;
582                         t->con.applySize = applyObjectConstraintSize;
583                         t->con.applyRot = applyObjectConstraintRot;
584                         t->redraw = 1;
585                 }
586         }
587 }
588
589 /*
590  * Set the constraint according to the user defined orientation
591  *
592  * ftext is a format string passed to BLI_snprintf. It will add the name of
593  * the orientation where %s is (logically).
594  */
595 void setUserConstraint(TransInfo *t, short orientation, int mode, const char ftext[])
596 {
597         char text[40];
598
599         switch (orientation) {
600                 case V3D_MANIP_GLOBAL:
601                 {
602                         float mtx[3][3] = MAT3_UNITY;
603                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("global"));
604                         setConstraint(t, mtx, mode, text);
605                 }
606                 break;
607                 case V3D_MANIP_LOCAL:
608                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("local"));
609                         setLocalConstraint(t, mode, text);
610                         break;
611                 case V3D_MANIP_NORMAL:
612                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("normal"));
613                         setConstraint(t, t->spacemtx, mode, text);
614                         break;
615                 case V3D_MANIP_VIEW:
616                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("view"));
617                         setConstraint(t, t->spacemtx, mode, text);
618                         break;
619                 case V3D_MANIP_GIMBAL:
620                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("gimbal"));
621                         setConstraint(t, t->spacemtx, mode, text);
622                         break;
623                 default: /* V3D_MANIP_CUSTOM */
624                         BLI_snprintf(text, sizeof(text), ftext, t->spacename);
625                         setConstraint(t, t->spacemtx, mode, text);
626                         break;
627         }
628
629         t->con.orientation = orientation;
630
631         t->con.mode |= CON_USER;
632 }
633
634 /*----------------- DRAWING CONSTRAINTS -------------------*/
635
636 void drawConstraint(TransInfo *t)
637 {
638         TransCon *tc = &(t->con);
639
640         if (!ELEM3(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE))
641                 return;
642         if (!(tc->mode & CON_APPLY))
643                 return;
644         if (t->flag & T_USES_MANIPULATOR)
645                 return;
646         if (t->flag & T_NO_CONSTRAINT)
647                 return;
648
649         /* nasty exception for Z constraint in camera view */
650         // TRANSFORM_FIX_ME
651 //      if ((t->flag & T_OBJECT) && G.vd->camera==OBACT && G.vd->persp==V3D_CAMOB)
652 //              return;
653
654         if (tc->drawExtra) {
655                 tc->drawExtra(t);
656         }
657         else {
658                 if (tc->mode & CON_SELECT) {
659                         float vec[3];
660                         char col2[3] = {255, 255, 255};
661                         int depth_test_enabled;
662
663                         convertViewVec(t, vec, (t->mval[0] - t->con.imval[0]), (t->mval[1] - t->con.imval[1]));
664                         add_v3_v3(vec, tc->center);
665
666                         drawLine(t, tc->center, tc->mtx[0], 'X', 0);
667                         drawLine(t, tc->center, tc->mtx[1], 'Y', 0);
668                         drawLine(t, tc->center, tc->mtx[2], 'Z', 0);
669
670                         glColor3ubv((GLubyte *)col2);
671
672                         depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
673                         if (depth_test_enabled)
674                                 glDisable(GL_DEPTH_TEST);
675
676                         setlinestyle(1);
677                         glBegin(GL_LINE_STRIP);
678                         glVertex3fv(tc->center);
679                         glVertex3fv(vec);
680                         glEnd();
681                         setlinestyle(0);
682
683                         if (depth_test_enabled)
684                                 glEnable(GL_DEPTH_TEST);
685                 }
686
687                 if (tc->mode & CON_AXIS0) {
688                         drawLine(t, tc->center, tc->mtx[0], 'X', DRAWLIGHT);
689                 }
690                 if (tc->mode & CON_AXIS1) {
691                         drawLine(t, tc->center, tc->mtx[1], 'Y', DRAWLIGHT);
692                 }
693                 if (tc->mode & CON_AXIS2) {
694                         drawLine(t, tc->center, tc->mtx[2], 'Z', DRAWLIGHT);
695                 }
696         }
697 }
698
699 /* called from drawview.c, as an extra per-window draw option */
700 void drawPropCircle(const struct bContext *C, TransInfo *t)
701 {
702         if (t->flag & T_PROP_EDIT) {
703                 RegionView3D *rv3d = CTX_wm_region_view3d(C);
704                 float tmat[4][4], imat[4][4];
705                 float center[3];
706
707                 UI_ThemeColor(TH_GRID);
708
709                 if (t->spacetype == SPACE_VIEW3D && rv3d != NULL) {
710                         copy_m4_m4(tmat, rv3d->viewmat);
711                         invert_m4_m4(imat, tmat);
712                 }
713                 else {
714                         unit_m4(tmat);
715                         unit_m4(imat);
716                 }
717
718                 glPushMatrix();
719
720                 copy_v3_v3(center, t->center);
721
722                 if ((t->spacetype == SPACE_VIEW3D) && t->obedit) {
723                         mul_m4_v3(t->obedit->obmat, center); /* because t->center is in local space */
724                 }
725                 else if (t->spacetype == SPACE_IMAGE) {
726                         float aspx, aspy;
727
728                         if (t->options & CTX_MASK) {
729                                 /* untested - mask aspect is TODO */
730                                 ED_space_image_get_aspect(t->sa->spacedata.first, &aspx, &aspy);
731                         }
732                         else {
733                                 ED_space_image_get_uv_aspect(t->sa->spacedata.first, &aspx, &aspy);
734                         }
735                         glScalef(1.0f / aspx, 1.0f / aspy, 1.0);
736                 }
737
738                 set_inverted_drawing(1);
739                 drawcircball(GL_LINE_LOOP, center, t->prop_size, imat);
740                 set_inverted_drawing(0);
741
742                 glPopMatrix();
743         }
744 }
745
746 static void drawObjectConstraint(TransInfo *t)
747 {
748         int i;
749         TransData *td = t->data;
750
751         /* Draw the first one lighter because that's the one who controls the others.
752          * Meaning the transformation is projected on that one and just copied on the others
753          * constraint space.
754          * In a nutshell, the object with light axis is controlled by the user and the others follow.
755          * Without drawing the first light, users have little clue what they are doing.
756          */
757         if (t->con.mode & CON_AXIS0) {
758                 drawLine(t, td->ob->obmat[3], td->axismtx[0], 'X', DRAWLIGHT);
759         }
760         if (t->con.mode & CON_AXIS1) {
761                 drawLine(t, td->ob->obmat[3], td->axismtx[1], 'Y', DRAWLIGHT);
762         }
763         if (t->con.mode & CON_AXIS2) {
764                 drawLine(t, td->ob->obmat[3], td->axismtx[2], 'Z', DRAWLIGHT);
765         }
766
767         td++;
768
769         for (i = 1; i < t->total; i++, td++) {
770                 if (t->con.mode & CON_AXIS0) {
771                         drawLine(t, td->ob->obmat[3], td->axismtx[0], 'X', 0);
772                 }
773                 if (t->con.mode & CON_AXIS1) {
774                         drawLine(t, td->ob->obmat[3], td->axismtx[1], 'Y', 0);
775                 }
776                 if (t->con.mode & CON_AXIS2) {
777                         drawLine(t, td->ob->obmat[3], td->axismtx[2], 'Z', 0);
778                 }
779         }
780 }
781
782 /*--------------------- START / STOP CONSTRAINTS ---------------------- */
783
784 void startConstraint(TransInfo *t)
785 {
786         t->con.mode |= CON_APPLY;
787         *t->con.text = ' ';
788         t->num.idx_max = min_ii(getConstraintSpaceDimension(t) - 1, t->idx_max);
789 }
790
791 void stopConstraint(TransInfo *t)
792 {
793         t->con.mode &= ~(CON_APPLY | CON_SELECT);
794         *t->con.text = '\0';
795         t->num.idx_max = t->idx_max;
796 }
797
798 void getConstraintMatrix(TransInfo *t)
799 {
800         float mat[3][3];
801         invert_m3_m3(t->con.imtx, t->con.mtx);
802         unit_m3(t->con.pmtx);
803
804         if (!(t->con.mode & CON_AXIS0)) {
805                 t->con.pmtx[0][0]       =
806                     t->con.pmtx[0][1]   =
807                     t->con.pmtx[0][2]   = 0.0f;
808         }
809
810         if (!(t->con.mode & CON_AXIS1)) {
811                 t->con.pmtx[1][0]       =
812                     t->con.pmtx[1][1]   =
813                     t->con.pmtx[1][2]   = 0.0f;
814         }
815
816         if (!(t->con.mode & CON_AXIS2)) {
817                 t->con.pmtx[2][0]       =
818                     t->con.pmtx[2][1]   =
819                     t->con.pmtx[2][2]   = 0.0f;
820         }
821
822         mul_m3_m3m3(mat, t->con.pmtx, t->con.imtx);
823         mul_m3_m3m3(t->con.pmtx, t->con.mtx, mat);
824 }
825
826 /*------------------------- MMB Select -------------------------------*/
827
828 void initSelectConstraint(TransInfo *t, float mtx[3][3])
829 {
830         copy_m3_m3(t->con.mtx, mtx);
831         t->con.mode |= CON_APPLY;
832         t->con.mode |= CON_SELECT;
833
834         setNearestAxis(t);
835         t->con.drawExtra = NULL;
836         t->con.applyVec = applyAxisConstraintVec;
837         t->con.applySize = applyAxisConstraintSize;
838         t->con.applyRot = applyAxisConstraintRot;
839 }
840
841 void selectConstraint(TransInfo *t)
842 {
843         if (t->con.mode & CON_SELECT) {
844                 setNearestAxis(t);
845                 startConstraint(t);
846         }
847 }
848
849 void postSelectConstraint(TransInfo *t)
850 {
851         if (!(t->con.mode & CON_SELECT))
852                 return;
853
854         t->con.mode &= ~CON_AXIS0;
855         t->con.mode &= ~CON_AXIS1;
856         t->con.mode &= ~CON_AXIS2;
857         t->con.mode &= ~CON_SELECT;
858
859         setNearestAxis(t);
860
861         startConstraint(t);
862         t->redraw = 1;
863 }
864
865 static void setNearestAxis2d(TransInfo *t)
866 {
867         /* no correction needed... just use whichever one is lower */
868         if (abs(t->mval[0] - t->con.imval[0]) < abs(t->mval[1] - t->con.imval[1]) ) {
869                 t->con.mode |= CON_AXIS1;
870                 BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along Y axis"));
871         }
872         else {
873                 t->con.mode |= CON_AXIS0;
874                 BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along X axis"));
875         }
876 }
877
878 static void setNearestAxis3d(TransInfo *t)
879 {
880         float zfac;
881         float mvec[3], axis[3], proj[3];
882         float len[3];
883         int i, icoord[2];
884
885         /* calculate mouse movement */
886         mvec[0] = (float)(t->mval[0] - t->con.imval[0]);
887         mvec[1] = (float)(t->mval[1] - t->con.imval[1]);
888         mvec[2] = 0.0f;
889
890         /* we need to correct axis length for the current zoomlevel of view,
891          * this to prevent projected values to be clipped behind the camera
892          * and to overflow the short integers.
893          * The formula used is a bit stupid, just a simplification of the subtraction
894          * of two 2D points 30 pixels apart (that's the last factor in the formula) after
895          * projecting them with window_to_3d_delta and then get the length of that vector.
896          */
897         zfac = t->persmat[0][3] * t->center[0] + t->persmat[1][3] * t->center[1] + t->persmat[2][3] * t->center[2] + t->persmat[3][3];
898         zfac = len_v3(t->persinv[0]) * 2.0f / t->ar->winx * zfac * 30.0f;
899
900         for (i = 0; i < 3; i++) {
901                 copy_v3_v3(axis, t->con.mtx[i]);
902
903                 mul_v3_fl(axis, zfac);
904                 /* now we can project to get window coordinate */
905                 add_v3_v3(axis, t->con.center);
906                 projectIntView(t, axis, icoord);
907
908                 axis[0] = (float)(icoord[0] - t->center2d[0]);
909                 axis[1] = (float)(icoord[1] - t->center2d[1]);
910                 axis[2] = 0.0f;
911
912                 if (normalize_v3(axis) != 0.0f) {
913                         project_v3_v3v3(proj, mvec, axis);
914                         sub_v3_v3v3(axis, mvec, proj);
915                         len[i] = normalize_v3(axis);
916                 }
917                 else {
918                         len[i] = 10000000000.0f;
919                 }
920         }
921
922         if (len[0] <= len[1] && len[0] <= len[2]) {
923                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
924                         t->con.mode |= (CON_AXIS1 | CON_AXIS2);
925                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s X axis"), t->spacename);
926                 }
927                 else {
928                         t->con.mode |= CON_AXIS0;
929                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s X axis"), t->spacename);
930                 }
931         }
932         else if (len[1] <= len[0] && len[1] <= len[2]) {
933                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
934                         t->con.mode |= (CON_AXIS0 | CON_AXIS2);
935                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Y axis"), t->spacename);
936                 }
937                 else {
938                         t->con.mode |= CON_AXIS1;
939                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Y axis"), t->spacename);
940                 }
941         }
942         else if (len[2] <= len[1] && len[2] <= len[0]) {
943                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
944                         t->con.mode |= (CON_AXIS0 | CON_AXIS1);
945                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Z axis"), t->spacename);
946                 }
947                 else {
948                         t->con.mode |= CON_AXIS2;
949                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Z axis"), t->spacename);
950                 }
951         }
952 }
953
954 void setNearestAxis(TransInfo *t)
955 {
956         /* clear any prior constraint flags */
957         t->con.mode &= ~CON_AXIS0;
958         t->con.mode &= ~CON_AXIS1;
959         t->con.mode &= ~CON_AXIS2;
960
961         /* constraint setting - depends on spacetype */
962         if (t->spacetype == SPACE_VIEW3D) {
963                 /* 3d-view */
964                 setNearestAxis3d(t);
965         }
966         else {
967                 /* assume that this means a 2D-Editor */
968                 setNearestAxis2d(t);
969         }
970
971         getConstraintMatrix(t);
972 }
973
974 /*-------------- HELPER FUNCTIONS ----------------*/
975
976 char constraintModeToChar(TransInfo *t)
977 {
978         if ((t->con.mode & CON_APPLY) == 0) {
979                 return '\0';
980         }
981         switch (t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2)) {
982                 case (CON_AXIS0):
983                 case (CON_AXIS1 | CON_AXIS2):
984                         return 'X';
985                 case (CON_AXIS1):
986                 case (CON_AXIS0 | CON_AXIS2):
987                         return 'Y';
988                 case (CON_AXIS2):
989                 case (CON_AXIS0 | CON_AXIS1):
990                         return 'Z';
991                 default:
992                         return '\0';
993         }
994 }
995
996
997 int isLockConstraint(TransInfo *t)
998 {
999         int mode = t->con.mode;
1000
1001         if ((mode & (CON_AXIS0 | CON_AXIS1)) == (CON_AXIS0 | CON_AXIS1))
1002                 return 1;
1003
1004         if ((mode & (CON_AXIS1 | CON_AXIS2)) == (CON_AXIS1 | CON_AXIS2))
1005                 return 1;
1006
1007         if ((mode & (CON_AXIS0 | CON_AXIS2)) == (CON_AXIS0 | CON_AXIS2))
1008                 return 1;
1009
1010         return 0;
1011 }
1012
1013 /*
1014  * Returns the dimension of the constraint space.
1015  *
1016  * For that reason, the flags always needs to be set to properly evaluate here,
1017  * even if they aren't actually used in the callback function. (Which could happen
1018  * for weird constraints not yet designed. Along a path for example.)
1019  */
1020
1021 int getConstraintSpaceDimension(TransInfo *t)
1022 {
1023         int n = 0;
1024
1025         if (t->con.mode & CON_AXIS0)
1026                 n++;
1027
1028         if (t->con.mode & CON_AXIS1)
1029                 n++;
1030
1031         if (t->con.mode & CON_AXIS2)
1032                 n++;
1033
1034         return n;
1035 /*
1036  * Someone willing to do it cryptically could do the following instead:
1037  *
1038  * return t->con & (CON_AXIS0|CON_AXIS1|CON_AXIS2);
1039  *
1040  * Based on the assumptions that the axis flags are one after the other and start at 1
1041  */
1042 }