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