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