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