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