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