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