Fix T39479: Transform mouse constraint fails in some situations.
[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 #include <stdlib.h>
33 #include <stdio.h>
34 #include <string.h>
35 #include <math.h>
36
37 #ifndef WIN32
38 #  include <unistd.h>
39 #else
40 #  include <io.h>
41 #endif
42
43 #include "DNA_object_types.h"
44 #include "DNA_scene_types.h"
45 #include "DNA_screen_types.h"
46 #include "DNA_space_types.h"
47 #include "DNA_view3d_types.h"
48
49 #include "BIF_gl.h"
50 #include "BIF_glutil.h"
51
52 #include "BLI_math.h"
53 #include "BLI_utildefines.h"
54 #include "BLI_string.h"
55
56 #include "BKE_context.h"
57
58 #include "ED_image.h"
59 #include "ED_view3d.h"
60
61 #include "BLF_translation.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         snapGridIncrement(t, vec);
139
140         if (t->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 (applyNumInput(&t->num, vec)) {
152                 constraintNumInput(t, vec);
153                 removeAspectRatio(t, vec);
154         }
155
156         /* autovalues is operator param, use that directly but not if snapping is forced */
157         if (t->flag & T_AUTOVALUES && (t->tsnap.status & SNAP_FORCED) == 0) {
158                 mul_v3_m3v3(vec, t->con.imtx, t->auto_values);
159                 constraintAutoValues(t, vec);
160                 /* inverse transformation at the end */
161         }
162
163         if (t->con.mode & CON_AXIS0) {
164                 pvec[i++] = vec[0];
165         }
166         if (t->con.mode & CON_AXIS1) {
167                 pvec[i++] = vec[1];
168         }
169         if (t->con.mode & CON_AXIS2) {
170                 pvec[i++] = vec[2];
171         }
172
173         mul_m3_v3(t->con.mtx, vec);
174 }
175
176 static void viewAxisCorrectCenter(TransInfo *t, float t_con_center[3])
177 {
178         if (t->spacetype == SPACE_VIEW3D) {
179                 // View3D *v3d = t->sa->spacedata.first;
180                 const float min_dist = 1.0f;  /* v3d->near; */
181                 float dir[3];
182                 float l;
183
184                 sub_v3_v3v3(dir, t_con_center, t->viewinv[3]);
185                 if (dot_v3v3(dir, t->viewinv[2]) < 0.0f) {
186                         negate_v3(dir);
187                 }
188                 project_v3_v3v3(dir, dir, t->viewinv[2]);
189
190                 l = len_v3(dir);
191
192                 if (l < min_dist) {
193                         float diff[3];
194                         normalize_v3_v3(diff, t->viewinv[2]);
195                         mul_v3_fl(diff, min_dist - l);
196
197                         sub_v3_v3(t_con_center, diff);
198                 }
199         }
200 }
201
202 static void axisProjection(TransInfo *t, const float axis[3], const float in[3], float out[3])
203 {
204         float norm[3], vec[3], factor, angle;
205         float t_con_center[3];
206
207         if (is_zero_v3(in)) {
208                 return;
209         }
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, const 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 (fabsf(factor) <= 0.001f) {
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, const 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, const 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
396                         mul_m3_v3(td->axismtx, out);
397                         if (t->flag & T_EDIT) {
398                                 mul_m3_v3(t->obedit_mat, out);
399                         }
400                 }
401         }
402 }
403
404 /*
405  * Generic callback for constant spatial constraints applied to resize motion
406  */
407
408 static void applyAxisConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
409 {
410         if (!td && t->con.mode & CON_APPLY) {
411                 float tmat[3][3];
412
413                 if (!(t->con.mode & CON_AXIS0)) {
414                         smat[0][0] = 1.0f;
415                 }
416                 if (!(t->con.mode & CON_AXIS1)) {
417                         smat[1][1] = 1.0f;
418                 }
419                 if (!(t->con.mode & CON_AXIS2)) {
420                         smat[2][2] = 1.0f;
421                 }
422
423                 mul_m3_m3m3(tmat, smat, t->con.imtx);
424                 mul_m3_m3m3(smat, t->con.mtx, tmat);
425         }
426 }
427
428 /*
429  * Callback for object based spatial constraints applied to resize motion
430  */
431
432 static void applyObjectConstraintSize(TransInfo *t, TransData *td, float smat[3][3])
433 {
434         if (td && t->con.mode & CON_APPLY) {
435                 float tmat[3][3];
436                 float imat[3][3];
437
438                 invert_m3_m3(imat, td->axismtx);
439
440                 if (!(t->con.mode & CON_AXIS0)) {
441                         smat[0][0] = 1.0f;
442                 }
443                 if (!(t->con.mode & CON_AXIS1)) {
444                         smat[1][1] = 1.0f;
445                 }
446                 if (!(t->con.mode & CON_AXIS2)) {
447                         smat[2][2] = 1.0f;
448                 }
449
450                 mul_m3_m3m3(tmat, smat, imat);
451                 if (t->flag & T_EDIT) {
452                         mul_m3_m3m3(smat, t->obedit_mat, smat);
453                 }
454                 mul_m3_m3m3(smat, td->axismtx, tmat);
455         }
456 }
457
458 /*
459  * Generic callback for constant spatial constraints applied to rotations
460  *
461  * The rotation axis is copied into VEC.
462  *
463  * In the case of single axis constraints, the rotation axis is directly the one constrained to.
464  * For planar constraints (2 axis), the rotation axis is the normal of the plane.
465  *
466  * The following only applies when CON_NOFLIP is not set.
467  * The vector is then modified to always point away from the screen (in global space)
468  * This insures that the rotation is always logically following the mouse.
469  * (ie: not doing counterclockwise rotations when the mouse moves clockwise).
470  */
471
472 static void applyAxisConstraintRot(TransInfo *t, TransData *td, float vec[3], float *angle)
473 {
474         if (!td && t->con.mode & CON_APPLY) {
475                 int mode = t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2);
476
477                 switch (mode) {
478                         case CON_AXIS0:
479                         case (CON_AXIS1 | CON_AXIS2):
480                                 copy_v3_v3(vec, t->con.mtx[0]);
481                                 break;
482                         case CON_AXIS1:
483                         case (CON_AXIS0 | CON_AXIS2):
484                                 copy_v3_v3(vec, t->con.mtx[1]);
485                                 break;
486                         case CON_AXIS2:
487                         case (CON_AXIS0 | CON_AXIS1):
488                                 copy_v3_v3(vec, t->con.mtx[2]);
489                                 break;
490                 }
491                 /* don't flip axis if asked to or if num input */
492                 if (angle && (mode & CON_NOFLIP) == 0 && hasNumInput(&t->num) == 0) {
493                         if (dot_v3v3(vec, t->viewinv[2]) > 0.0f) {
494                                 *angle = -(*angle);
495                         }
496                 }
497         }
498 }
499
500 /*
501  * Callback for object based spatial constraints applied to rotations
502  *
503  * The rotation axis is copied into VEC.
504  *
505  * In the case of single axis constraints, the rotation axis is directly the one constrained to.
506  * For planar constraints (2 axis), the rotation axis is the normal of the plane.
507  *
508  * The following only applies when CON_NOFLIP is not set.
509  * The vector is then modified to always point away from the screen (in global space)
510  * This insures that the rotation is always logically following the mouse.
511  * (ie: not doing counterclockwise rotations when the mouse moves clockwise).
512  */
513
514 static void applyObjectConstraintRot(TransInfo *t, TransData *td, float vec[3], float *angle)
515 {
516         if (t->con.mode & CON_APPLY) {
517                 int mode = t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2);
518                 float tmp_axismtx[3][3];
519                 float (*axismtx)[3];
520
521                 /* on setup call, use first object */
522                 if (td == NULL) {
523                         td = t->data;
524                 }
525
526                 if (t->flag & T_EDIT) {
527                         mul_m3_m3m3(tmp_axismtx, t->obedit_mat, td->axismtx);
528                         axismtx = tmp_axismtx;
529                 }
530                 else {
531                         axismtx = td->axismtx;
532                 }
533
534                 switch (mode) {
535                         case CON_AXIS0:
536                         case (CON_AXIS1 | CON_AXIS2):
537                                 copy_v3_v3(vec, axismtx[0]);
538                                 break;
539                         case CON_AXIS1:
540                         case (CON_AXIS0 | CON_AXIS2):
541                                 copy_v3_v3(vec, axismtx[1]);
542                                 break;
543                         case CON_AXIS2:
544                         case (CON_AXIS0 | CON_AXIS1):
545                                 copy_v3_v3(vec, axismtx[2]);
546                                 break;
547                 }
548                 if (angle && (mode & CON_NOFLIP) == 0 && hasNumInput(&t->num) == 0) {
549                         if (dot_v3v3(vec, t->viewinv[2]) > 0.0f) {
550                                 *angle = -(*angle);
551                         }
552                 }
553         }
554 }
555
556 /*--------------------- INTERNAL SETUP CALLS ------------------*/
557
558 void setConstraint(TransInfo *t, float space[3][3], int mode, const char text[])
559 {
560         BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
561         copy_m3_m3(t->con.mtx, space);
562         t->con.mode = mode;
563         getConstraintMatrix(t);
564
565         startConstraint(t);
566
567         t->con.drawExtra = NULL;
568         t->con.applyVec = applyAxisConstraintVec;
569         t->con.applySize = applyAxisConstraintSize;
570         t->con.applyRot = applyAxisConstraintRot;
571         t->redraw = TREDRAW_HARD;
572 }
573
574 /* applies individual td->axismtx constraints */
575 void setAxisMatrixConstraint(TransInfo *t, int mode, const char text[])
576 {
577         if (t->total == 1) {
578                 float axismtx[3][3];
579                 if (t->flag & T_EDIT) {
580                         mul_m3_m3m3(axismtx, t->obedit_mat, t->data->axismtx);
581                 }
582                 else {
583                         copy_m3_m3(axismtx, t->data->axismtx);
584                 }
585
586                 setConstraint(t, axismtx, mode, text);
587         }
588         else {
589                 BLI_strncpy(t->con.text + 1, text, sizeof(t->con.text) - 1);
590                 copy_m3_m3(t->con.mtx, t->data->axismtx);
591                 t->con.mode = mode;
592                 getConstraintMatrix(t);
593
594                 startConstraint(t);
595
596                 t->con.drawExtra = drawObjectConstraint;
597                 t->con.applyVec = applyObjectConstraintVec;
598                 t->con.applySize = applyObjectConstraintSize;
599                 t->con.applyRot = applyObjectConstraintRot;
600                 t->redraw = TREDRAW_HARD;
601         }
602 }
603
604 void setLocalConstraint(TransInfo *t, int mode, const char text[])
605 {
606         /* edit-mode now allows local transforms too */
607         if (t->flag & T_EDIT) {
608                 setConstraint(t, t->obedit_mat, mode, text);
609         }
610         else {
611                 setAxisMatrixConstraint(t, mode, text);
612         }
613 }
614
615 /*
616  * Set the constraint according to the user defined orientation
617  *
618  * ftext is a format string passed to BLI_snprintf. It will add the name of
619  * the orientation where %s is (logically).
620  */
621 void setUserConstraint(TransInfo *t, short orientation, int mode, const char ftext[])
622 {
623         char text[40];
624
625         switch (orientation) {
626                 case V3D_MANIP_GLOBAL:
627                 {
628                         float mtx[3][3] = MAT3_UNITY;
629                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("global"));
630                         setConstraint(t, mtx, mode, text);
631                         break;
632                 }
633                 case V3D_MANIP_LOCAL:
634                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("local"));
635                         setLocalConstraint(t, mode, text);
636                         break;
637                 case V3D_MANIP_NORMAL:
638                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("normal"));
639                         if (checkUseAxisMatrix(t)) {
640                                 setAxisMatrixConstraint(t, mode, text);
641                         }
642                         else {
643                                 setConstraint(t, t->spacemtx, mode, text);
644                         }
645                         break;
646                 case V3D_MANIP_VIEW:
647                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("view"));
648                         setConstraint(t, t->spacemtx, mode, text);
649                         break;
650                 case V3D_MANIP_GIMBAL:
651                         BLI_snprintf(text, sizeof(text), ftext, IFACE_("gimbal"));
652                         setConstraint(t, t->spacemtx, mode, text);
653                         break;
654                 default: /* V3D_MANIP_CUSTOM */
655                         BLI_snprintf(text, sizeof(text), ftext, t->spacename);
656                         setConstraint(t, t->spacemtx, mode, text);
657                         break;
658         }
659
660         t->con.orientation = orientation;
661
662         t->con.mode |= CON_USER;
663 }
664
665 /*----------------- DRAWING CONSTRAINTS -------------------*/
666
667 void drawConstraint(TransInfo *t)
668 {
669         TransCon *tc = &(t->con);
670
671         if (!ELEM3(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE))
672                 return;
673         if (!(tc->mode & CON_APPLY))
674                 return;
675         if (t->flag & T_USES_MANIPULATOR)
676                 return;
677         if (t->flag & T_NO_CONSTRAINT)
678                 return;
679
680         /* nasty exception for Z constraint in camera view */
681         // TRANSFORM_FIX_ME
682 //      if ((t->flag & T_OBJECT) && G.vd->camera==OBACT && G.vd->persp==V3D_CAMOB)
683 //              return;
684
685         if (tc->drawExtra) {
686                 tc->drawExtra(t);
687         }
688         else {
689                 if (tc->mode & CON_SELECT) {
690                         float vec[3];
691                         char col2[3] = {255, 255, 255};
692                         int depth_test_enabled;
693
694                         convertViewVec(t, vec, (t->mval[0] - t->con.imval[0]), (t->mval[1] - t->con.imval[1]));
695                         add_v3_v3(vec, tc->center);
696
697                         drawLine(t, tc->center, tc->mtx[0], 'X', 0);
698                         drawLine(t, tc->center, tc->mtx[1], 'Y', 0);
699                         drawLine(t, tc->center, tc->mtx[2], 'Z', 0);
700
701                         glColor3ubv((GLubyte *)col2);
702
703                         depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
704                         if (depth_test_enabled)
705                                 glDisable(GL_DEPTH_TEST);
706
707                         setlinestyle(1);
708                         glBegin(GL_LINE_STRIP);
709                         glVertex3fv(tc->center);
710                         glVertex3fv(vec);
711                         glEnd();
712                         setlinestyle(0);
713
714                         if (depth_test_enabled)
715                                 glEnable(GL_DEPTH_TEST);
716                 }
717
718                 if (tc->mode & CON_AXIS0) {
719                         drawLine(t, tc->center, tc->mtx[0], 'X', DRAWLIGHT);
720                 }
721                 if (tc->mode & CON_AXIS1) {
722                         drawLine(t, tc->center, tc->mtx[1], 'Y', DRAWLIGHT);
723                 }
724                 if (tc->mode & CON_AXIS2) {
725                         drawLine(t, tc->center, tc->mtx[2], 'Z', DRAWLIGHT);
726                 }
727         }
728 }
729
730 /* called from drawview.c, as an extra per-window draw option */
731 void drawPropCircle(const struct bContext *C, TransInfo *t)
732 {
733         if (t->flag & T_PROP_EDIT) {
734                 RegionView3D *rv3d = CTX_wm_region_view3d(C);
735                 float tmat[4][4], imat[4][4];
736                 float center[3];
737                 int depth_test_enabled;
738
739                 UI_ThemeColor(TH_GRID);
740
741                 if (t->spacetype == SPACE_VIEW3D && rv3d != NULL) {
742                         copy_m4_m4(tmat, rv3d->viewmat);
743                         invert_m4_m4(imat, tmat);
744                 }
745                 else {
746                         unit_m4(tmat);
747                         unit_m4(imat);
748                 }
749
750                 glPushMatrix();
751
752                 copy_v3_v3(center, t->center);
753
754                 if ((t->spacetype == SPACE_VIEW3D) && t->obedit) {
755                         mul_m4_v3(t->obedit->obmat, center); /* because t->center is in local space */
756                 }
757                 else if (t->spacetype == SPACE_IMAGE) {
758                         float aspx, aspy;
759
760                         if (t->options & CTX_MASK) {
761                                 /* untested - mask aspect is TODO */
762                                 ED_space_image_get_aspect(t->sa->spacedata.first, &aspx, &aspy);
763                         }
764                         else {
765                                 ED_space_image_get_uv_aspect(t->sa->spacedata.first, &aspx, &aspy);
766                         }
767                         glScalef(1.0f / aspx, 1.0f / aspy, 1.0);
768                 }
769
770                 depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
771                 if (depth_test_enabled)
772                         glDisable(GL_DEPTH_TEST);
773
774                 set_inverted_drawing(1);
775                 drawcircball(GL_LINE_LOOP, center, t->prop_size, imat);
776                 set_inverted_drawing(0);
777
778                 if (depth_test_enabled)
779                         glEnable(GL_DEPTH_TEST);
780
781                 glPopMatrix();
782         }
783 }
784
785 static void drawObjectConstraint(TransInfo *t)
786 {
787         /* Draw the first one lighter because that's the one who controls the others.
788          * Meaning the transformation is projected on that one and just copied on the others
789          * constraint space.
790          * In a nutshell, the object with light axis is controlled by the user and the others follow.
791          * Without drawing the first light, users have little clue what they are doing.
792          */
793         short options = DRAWLIGHT;
794         TransData *td = t->data;
795         int i;
796         float tmp_axismtx[3][3];
797
798         for (i = 0; i < t->total; i++, td++) {
799                 float co[3];
800                 float (*axismtx)[3];
801
802                 if (t->flag & T_PROP_EDIT) {
803                         /* we're sorted, so skip the rest */
804                         if (td->factor == 0.0f) {
805                                 break;
806                         }
807                 }
808
809                 if (t->flag & T_OBJECT) {
810                         copy_v3_v3(co, td->ob->obmat[3]);
811                         axismtx = td->axismtx;
812                 }
813                 else if (t->flag & T_EDIT) {
814                         mul_v3_m4v3(co, t->obedit->obmat, td->center);
815
816                         mul_m3_m3m3(tmp_axismtx, t->obedit_mat, td->axismtx);
817                         axismtx = tmp_axismtx;
818                 }
819                 else if (t->flag & T_POSE) {
820                         mul_v3_m4v3(co, t->poseobj->obmat, td->center);
821                         axismtx = td->axismtx;
822                 }
823                 else {
824                         copy_v3_v3(co, td->center);
825                         axismtx = td->axismtx;
826                 }
827
828                 if (t->con.mode & CON_AXIS0) {
829                         drawLine(t, co, axismtx[0], 'X', options);
830                 }
831                 if (t->con.mode & CON_AXIS1) {
832                         drawLine(t, co, axismtx[1], 'Y', options);
833                 }
834                 if (t->con.mode & CON_AXIS2) {
835                         drawLine(t, co, axismtx[2], 'Z', options);
836                 }
837                 options &= ~DRAWLIGHT;
838         }
839 }
840
841 /*--------------------- START / STOP CONSTRAINTS ---------------------- */
842
843 void startConstraint(TransInfo *t)
844 {
845         t->con.mode |= CON_APPLY;
846         *t->con.text = ' ';
847         t->num.idx_max = min_ii(getConstraintSpaceDimension(t) - 1, t->idx_max);
848 }
849
850 void stopConstraint(TransInfo *t)
851 {
852         t->con.mode &= ~(CON_APPLY | CON_SELECT);
853         *t->con.text = '\0';
854         t->num.idx_max = t->idx_max;
855 }
856
857 void getConstraintMatrix(TransInfo *t)
858 {
859         float mat[3][3];
860         invert_m3_m3(t->con.imtx, t->con.mtx);
861         unit_m3(t->con.pmtx);
862
863         if (!(t->con.mode & CON_AXIS0)) {
864                 t->con.pmtx[0][0]       =
865                     t->con.pmtx[0][1]   =
866                     t->con.pmtx[0][2]   = 0.0f;
867         }
868
869         if (!(t->con.mode & CON_AXIS1)) {
870                 t->con.pmtx[1][0]       =
871                     t->con.pmtx[1][1]   =
872                     t->con.pmtx[1][2]   = 0.0f;
873         }
874
875         if (!(t->con.mode & CON_AXIS2)) {
876                 t->con.pmtx[2][0]       =
877                     t->con.pmtx[2][1]   =
878                     t->con.pmtx[2][2]   = 0.0f;
879         }
880
881         mul_m3_m3m3(mat, t->con.pmtx, t->con.imtx);
882         mul_m3_m3m3(t->con.pmtx, t->con.mtx, mat);
883 }
884
885 /*------------------------- MMB Select -------------------------------*/
886
887 void initSelectConstraint(TransInfo *t, float mtx[3][3])
888 {
889         copy_m3_m3(t->con.mtx, mtx);
890         t->con.mode |= CON_APPLY;
891         t->con.mode |= CON_SELECT;
892
893         setNearestAxis(t);
894         t->con.drawExtra = NULL;
895         t->con.applyVec = applyAxisConstraintVec;
896         t->con.applySize = applyAxisConstraintSize;
897         t->con.applyRot = applyAxisConstraintRot;
898 }
899
900 void selectConstraint(TransInfo *t)
901 {
902         if (t->con.mode & CON_SELECT) {
903                 setNearestAxis(t);
904                 startConstraint(t);
905         }
906 }
907
908 void postSelectConstraint(TransInfo *t)
909 {
910         if (!(t->con.mode & CON_SELECT))
911                 return;
912
913         t->con.mode &= ~CON_AXIS0;
914         t->con.mode &= ~CON_AXIS1;
915         t->con.mode &= ~CON_AXIS2;
916         t->con.mode &= ~CON_SELECT;
917
918         setNearestAxis(t);
919
920         startConstraint(t);
921         t->redraw = TREDRAW_HARD;
922 }
923
924 static void setNearestAxis2d(TransInfo *t)
925 {
926         /* no correction needed... just use whichever one is lower */
927         if (abs(t->mval[0] - t->con.imval[0]) < abs(t->mval[1] - t->con.imval[1])) {
928                 t->con.mode |= CON_AXIS1;
929                 BLI_strncpy(t->con.text, IFACE_(" along Y axis"), sizeof(t->con.text));
930         }
931         else {
932                 t->con.mode |= CON_AXIS0;
933                 BLI_strncpy(t->con.text, IFACE_(" along X axis"), sizeof(t->con.text));
934         }
935 }
936
937 static void setNearestAxis3d(TransInfo *t)
938 {
939         float zfac;
940         float mvec[3], proj[3];
941         float len[3];
942         int i;
943
944         /* calculate mouse movement */
945         mvec[0] = (float)(t->mval[0] - t->con.imval[0]);
946         mvec[1] = (float)(t->mval[1] - t->con.imval[1]);
947         mvec[2] = 0.0f;
948
949         /* we need to correct axis length for the current zoomlevel of view,
950          * this to prevent projected values to be clipped behind the camera
951          * and to overflow the short integers.
952          * The formula used is a bit stupid, just a simplification of the subtraction
953          * of two 2D points 30 pixels apart (that's the last factor in the formula) after
954          * projecting them with ED_view3d_win_to_delta and then get the length of that vector.
955          */
956         zfac = mul_project_m4_v3_zfac(t->persmat, t->center);
957         zfac = len_v3(t->persinv[0]) * 2.0f / t->ar->winx * zfac * 30.0f;
958
959         for (i = 0; i < 3; i++) {
960                 float axis[3], axis_2d[2];
961
962                 copy_v3_v3(axis, t->con.mtx[i]);
963
964                 mul_v3_fl(axis, zfac);
965                 /* now we can project to get window coordinate */
966                 add_v3_v3(axis, t->con.center);
967                 projectFloatView(t, axis, axis_2d);
968
969                 sub_v2_v2v2(axis, axis_2d, t->center2d);
970                 axis[2] = 0.0f;
971
972                 if (normalize_v3(axis) > 1e-3f) {
973                         project_v3_v3v3(proj, mvec, axis);
974                         sub_v3_v3v3(axis, mvec, proj);
975                         len[i] = normalize_v3(axis);
976                 }
977                 else {
978                         len[i] = 1e10f;
979                 }
980         }
981
982         if (len[0] <= len[1] && len[0] <= len[2]) {
983                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
984                         t->con.mode |= (CON_AXIS1 | CON_AXIS2);
985                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s X axis"), t->spacename);
986                 }
987                 else {
988                         t->con.mode |= CON_AXIS0;
989                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s X axis"), t->spacename);
990                 }
991         }
992         else if (len[1] <= len[0] && len[1] <= len[2]) {
993                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
994                         t->con.mode |= (CON_AXIS0 | CON_AXIS2);
995                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Y axis"), t->spacename);
996                 }
997                 else {
998                         t->con.mode |= CON_AXIS1;
999                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Y axis"), t->spacename);
1000                 }
1001         }
1002         else if (len[2] <= len[1] && len[2] <= len[0]) {
1003                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
1004                         t->con.mode |= (CON_AXIS0 | CON_AXIS1);
1005                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Z axis"), t->spacename);
1006                 }
1007                 else {
1008                         t->con.mode |= CON_AXIS2;
1009                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Z axis"), t->spacename);
1010                 }
1011         }
1012 }
1013
1014 void setNearestAxis(TransInfo *t)
1015 {
1016         /* clear any prior constraint flags */
1017         t->con.mode &= ~CON_AXIS0;
1018         t->con.mode &= ~CON_AXIS1;
1019         t->con.mode &= ~CON_AXIS2;
1020
1021         /* constraint setting - depends on spacetype */
1022         if (t->spacetype == SPACE_VIEW3D) {
1023                 /* 3d-view */
1024                 setNearestAxis3d(t);
1025         }
1026         else {
1027                 /* assume that this means a 2D-Editor */
1028                 setNearestAxis2d(t);
1029         }
1030
1031         getConstraintMatrix(t);
1032 }
1033
1034 /*-------------- HELPER FUNCTIONS ----------------*/
1035
1036 char constraintModeToChar(TransInfo *t)
1037 {
1038         if ((t->con.mode & CON_APPLY) == 0) {
1039                 return '\0';
1040         }
1041         switch (t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2)) {
1042                 case (CON_AXIS0):
1043                 case (CON_AXIS1 | CON_AXIS2):
1044                         return 'X';
1045                 case (CON_AXIS1):
1046                 case (CON_AXIS0 | CON_AXIS2):
1047                         return 'Y';
1048                 case (CON_AXIS2):
1049                 case (CON_AXIS0 | CON_AXIS1):
1050                         return 'Z';
1051                 default:
1052                         return '\0';
1053         }
1054 }
1055
1056
1057 bool isLockConstraint(TransInfo *t)
1058 {
1059         int mode = t->con.mode;
1060
1061         if ((mode & (CON_AXIS0 | CON_AXIS1)) == (CON_AXIS0 | CON_AXIS1))
1062                 return true;
1063
1064         if ((mode & (CON_AXIS1 | CON_AXIS2)) == (CON_AXIS1 | CON_AXIS2))
1065                 return true;
1066
1067         if ((mode & (CON_AXIS0 | CON_AXIS2)) == (CON_AXIS0 | CON_AXIS2))
1068                 return true;
1069
1070         return false;
1071 }
1072
1073 /*
1074  * Returns the dimension of the constraint space.
1075  *
1076  * For that reason, the flags always needs to be set to properly evaluate here,
1077  * even if they aren't actually used in the callback function. (Which could happen
1078  * for weird constraints not yet designed. Along a path for example.)
1079  */
1080
1081 int getConstraintSpaceDimension(TransInfo *t)
1082 {
1083         int n = 0;
1084
1085         if (t->con.mode & CON_AXIS0)
1086                 n++;
1087
1088         if (t->con.mode & CON_AXIS1)
1089                 n++;
1090
1091         if (t->con.mode & CON_AXIS2)
1092                 n++;
1093
1094         return n;
1095 /*
1096  * Someone willing to do it cryptically could do the following instead:
1097  *
1098  * return t->con & (CON_AXIS0|CON_AXIS1|CON_AXIS2);
1099  *
1100  * Based on the assumptions that the axis flags are one after the other and start at 1
1101  */
1102 }