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