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