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(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[256];
 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                 case V3D_MANIP_CUSTOM:
 689                 {
 690                         char orientation_str[128];
 691                         BLI_snprintf(orientation_str, sizeof(orientation_str), "%s \"%s\"",
 692                                      IFACE_("custom orientation"), t->custom_orientation->name);
 693                         BLI_snprintf(text, sizeof(text), ftext, orientation_str);
 694                         setConstraint(t, t->spacemtx, mode, text);
 695                         break;
 696                 }
 697         }
 698
 699         t->con.orientation = orientation;
 700
 701         t->con.mode |= CON_USER;
 702 }
 703
 704 /*----------------- DRAWING CONSTRAINTS -------------------*/
 705
 706 void drawConstraint(TransInfo *t)
 707 {
 708         TransCon *tc = &(t->con);
 709
 710         if (!ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE))
 711                 return;
 712         if (!(tc->mode & CON_APPLY))
 713                 return;
 714         if (t->flag & T_NO_CONSTRAINT)
 715                 return;
 716
 717         if (tc->drawExtra) {
 718                 tc->drawExtra(t);
 719         }
 720         else {
 721                 if (tc->mode & CON_SELECT) {
 722                         float vec[3];
 723                         int depth_test_enabled;
 724
 725                         convertViewVec(t, vec, (t->mval[0] - t->con.imval[0]), (t->mval[1] - t->con.imval[1]));
 726                         add_v3_v3(vec, t->center_global);
 727
 728                         drawLine(t, t->center_global, tc->mtx[0], 'X', 0);
 729                         drawLine(t, t->center_global, tc->mtx[1], 'Y', 0);
 730                         drawLine(t, t->center_global, tc->mtx[2], 'Z', 0);
 731
 732                         depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
 733                         if (depth_test_enabled)
 734                                 glDisable(GL_DEPTH_TEST);
 735
 736                         const uint shdr_pos = GWN_vertformat_attr_add(immVertexFormat(), "pos", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
 737
 738                         immBindBuiltinProgram(GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR);
 739
 740                         float viewport_size[4];
 741                         glGetFloatv(GL_VIEWPORT, viewport_size);
 742                         immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
 743
 744                         immUniform1i("num_colors", 0);  /* "simple" mode */
 745                         immUniformColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 746                         immUniform1f("dash_width", 2.0f);
 747                         immUniform1f("dash_factor", 0.5f);
 748
 749                         immBegin(GWN_PRIM_LINES, 2);
 750                         immVertex3fv(shdr_pos, t->center_global);
 751                         immVertex3fv(shdr_pos, vec);
 752                         immEnd();
 753
 754                         immUnbindProgram();
 755
 756                         if (depth_test_enabled)
 757                                 glEnable(GL_DEPTH_TEST);
 758                 }
 759
 760                 if (tc->mode & CON_AXIS0) {
 761                         drawLine(t, t->center_global, tc->mtx[0], 'X', DRAWLIGHT);
 762                 }
 763                 if (tc->mode & CON_AXIS1) {
 764                         drawLine(t, t->center_global, tc->mtx[1], 'Y', DRAWLIGHT);
 765                 }
 766                 if (tc->mode & CON_AXIS2) {
 767                         drawLine(t, t->center_global, tc->mtx[2], 'Z', DRAWLIGHT);
 768                 }
 769         }
 770 }
 771
 772 /* called from drawview.c, as an extra per-window draw option */
 773 void drawPropCircle(const struct bContext *C, TransInfo *t)
 774 {
 775         if (t->flag & T_PROP_EDIT) {
 776                 RegionView3D *rv3d = CTX_wm_region_view3d(C);
 777                 float tmat[4][4], imat[4][4];
 778                 int depth_test_enabled;
 779
 780                 if (t->spacetype == SPACE_VIEW3D && rv3d != NULL) {
 781                         copy_m4_m4(tmat, rv3d->viewmat);
 782                         invert_m4_m4(imat, tmat);
 783                 }
 784                 else {
 785                         unit_m4(tmat);
 786                         unit_m4(imat);
 787                 }
 788
 789                 gpuPushMatrix();
 790
 791                 if (t->spacetype == SPACE_VIEW3D) {
 792                         /* pass */
 793                 }
 794                 else if (t->spacetype == SPACE_IMAGE) {
 795                         gpuScale2f(1.0f / t->aspect[0], 1.0f / t->aspect[1]);
 796                 }
 797                 else if (ELEM(t->spacetype, SPACE_IPO, SPACE_ACTION)) {
 798                         /* only scale y */
 799                         rcti *mask = &t->ar->v2d.mask;
 800                         rctf *datamask = &t->ar->v2d.cur;
 801                         float xsize = BLI_rctf_size_x(datamask);
 802                         float ysize = BLI_rctf_size_y(datamask);
 803                         float xmask = BLI_rcti_size_x(mask);
 804                         float ymask = BLI_rcti_size_y(mask);
 805                         gpuScale2f(1.0f, (ysize / xsize) * (xmask / ymask));
 806                 }
 807
 808                 depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
 809                 if (depth_test_enabled)
 810                         glDisable(GL_DEPTH_TEST);
 811
 812                 unsigned int pos = GWN_vertformat_attr_add(immVertexFormat(), "pos", GWN_COMP_F32, 3, GWN_FETCH_FLOAT);
 813
 814                 immBindBuiltinProgram(GPU_SHADER_3D_UNIFORM_COLOR);
 815                 immUniformThemeColor(TH_GRID);
 816
 817                 set_inverted_drawing(1);
 818                 imm_drawcircball(t->center_global, t->prop_size, imat, pos);
 819                 set_inverted_drawing(0);
 820
 821                 immUnbindProgram();
 822
 823                 if (depth_test_enabled)
 824                         glEnable(GL_DEPTH_TEST);
 825
 826                 gpuPopMatrix();
 827         }
 828 }
 829
 830 static void drawObjectConstraint(TransInfo *t)
 831 {
 832         /* Draw the first one lighter because that's the one who controls the others.
 833          * Meaning the transformation is projected on that one and just copied on the others
 834          * constraint space.
 835          * In a nutshell, the object with light axis is controlled by the user and the others follow.
 836          * Without drawing the first light, users have little clue what they are doing.
 837          */
 838         short options = DRAWLIGHT;
 839         TransData *td = t->data;
 840         int i;
 841         float tmp_axismtx[3][3];
 842
 843         for (i = 0; i < t->total; i++, td++) {
 844                 float co[3];
 845                 float (*axismtx)[3];
 846
 847                 if (t->flag & T_PROP_EDIT) {
 848                         /* we're sorted, so skip the rest */
 849                         if (td->factor == 0.0f) {
 850                                 break;
 851                         }
 852                 }
 853
 854                 if (t->flag & T_OBJECT) {
 855                         copy_v3_v3(co, td->ob->obmat[3]);
 856                         axismtx = td->axismtx;
 857                 }
 858                 else if (t->flag & T_EDIT) {
 859                         mul_v3_m4v3(co, t->obedit->obmat, td->center);
 860
 861                         mul_m3_m3m3(tmp_axismtx, t->obedit_mat, td->axismtx);
 862                         axismtx = tmp_axismtx;
 863                 }
 864                 else if (t->flag & T_POSE) {
 865                         mul_v3_m4v3(co, t->poseobj->obmat, td->center);
 866                         axismtx = td->axismtx;
 867                 }
 868                 else {
 869                         copy_v3_v3(co, td->center);
 870                         axismtx = td->axismtx;
 871                 }
 872
 873                 if (t->con.mode & CON_AXIS0) {
 874                         drawLine(t, co, axismtx[0], 'X', options);
 875                 }
 876                 if (t->con.mode & CON_AXIS1) {
 877                         drawLine(t, co, axismtx[1], 'Y', options);
 878                 }
 879                 if (t->con.mode & CON_AXIS2) {
 880                         drawLine(t, co, axismtx[2], 'Z', options);
 881                 }
 882                 options &= ~DRAWLIGHT;
 883         }
 884 }
 885
 886 /*--------------------- START / STOP CONSTRAINTS ---------------------- */
 887
 888 void startConstraint(TransInfo *t)
 889 {
 890         t->con.mode |= CON_APPLY;
 891         *t->con.text = ' ';
 892         t->num.idx_max = min_ii(getConstraintSpaceDimension(t) - 1, t->idx_max);
 893 }
 894
 895 void stopConstraint(TransInfo *t)
 896 {
 897         t->con.mode &= ~(CON_APPLY | CON_SELECT);
 898         *t->con.text = '\0';
 899         t->num.idx_max = t->idx_max;
 900 }
 901
 902 void getConstraintMatrix(TransInfo *t)
 903 {
 904         float mat[3][3];
 905         invert_m3_m3(t->con.imtx, t->con.mtx);
 906         unit_m3(t->con.pmtx);
 907
 908         if (!(t->con.mode & CON_AXIS0)) {
 909                 zero_v3(t->con.pmtx[0]);
 910         }
 911
 912         if (!(t->con.mode & CON_AXIS1)) {
 913                 zero_v3(t->con.pmtx[1]);
 914         }
 915
 916         if (!(t->con.mode & CON_AXIS2)) {
 917                 zero_v3(t->con.pmtx[2]);
 918         }
 919
 920         mul_m3_m3m3(mat, t->con.pmtx, t->con.imtx);
 921         mul_m3_m3m3(t->con.pmtx, t->con.mtx, mat);
 922 }
 923
 924 /*------------------------- MMB Select -------------------------------*/
 925
 926 void initSelectConstraint(TransInfo *t, float mtx[3][3])
 927 {
 928         copy_m3_m3(t->con.mtx, mtx);
 929         t->con.mode |= CON_APPLY;
 930         t->con.mode |= CON_SELECT;
 931
 932         setNearestAxis(t);
 933         t->con.drawExtra = NULL;
 934         t->con.applyVec = applyAxisConstraintVec;
 935         t->con.applySize = applyAxisConstraintSize;
 936         t->con.applyRot = applyAxisConstraintRot;
 937 }
 938
 939 void selectConstraint(TransInfo *t)
 940 {
 941         if (t->con.mode & CON_SELECT) {
 942                 setNearestAxis(t);
 943                 startConstraint(t);
 944         }
 945 }
 946
 947 void postSelectConstraint(TransInfo *t)
 948 {
 949         if (!(t->con.mode & CON_SELECT))
 950                 return;
 951
 952         t->con.mode &= ~CON_AXIS0;
 953         t->con.mode &= ~CON_AXIS1;
 954         t->con.mode &= ~CON_AXIS2;
 955         t->con.mode &= ~CON_SELECT;
 956
 957         setNearestAxis(t);
 958
 959         startConstraint(t);
 960         t->redraw = TREDRAW_HARD;
 961 }
 962
 963 static void setNearestAxis2d(TransInfo *t)
 964 {
 965         /* no correction needed... just use whichever one is lower */
 966         if (abs(t->mval[0] - t->con.imval[0]) < abs(t->mval[1] - t->con.imval[1])) {
 967                 t->con.mode |= CON_AXIS1;
 968                 BLI_strncpy(t->con.text, IFACE_(" along Y axis"), sizeof(t->con.text));
 969         }
 970         else {
 971                 t->con.mode |= CON_AXIS0;
 972                 BLI_strncpy(t->con.text, IFACE_(" along X axis"), sizeof(t->con.text));
 973         }
 974 }
 975
 976 static void setNearestAxis3d(TransInfo *t)
 977 {
 978         float zfac;
 979         float mvec[3], proj[3];
 980         float len[3];
 981         int i;
 982
 983         /* calculate mouse movement */
 984         mvec[0] = (float)(t->mval[0] - t->con.imval[0]);
 985         mvec[1] = (float)(t->mval[1] - t->con.imval[1]);
 986         mvec[2] = 0.0f;
 987
 988         /* we need to correct axis length for the current zoomlevel of view,
 989          * this to prevent projected values to be clipped behind the camera
 990          * and to overflow the short integers.
 991          * The formula used is a bit stupid, just a simplification of the subtraction
 992          * of two 2D points 30 pixels apart (that's the last factor in the formula) after
 993          * projecting them with ED_view3d_win_to_delta and then get the length of that vector.
 994          */
 995         zfac = mul_project_m4_v3_zfac(t->persmat, t->center);
 996         zfac = len_v3(t->persinv[0]) * 2.0f / t->ar->winx * zfac * 30.0f;
 997
 998         for (i = 0; i < 3; i++) {
 999                 float axis[3], axis_2d[2];
1000
1001                 copy_v3_v3(axis, t->con.mtx[i]);
1002
1003                 mul_v3_fl(axis, zfac);
1004                 /* now we can project to get window coordinate */
1005                 add_v3_v3(axis, t->center_global);
1006                 projectFloatView(t, axis, axis_2d);
1007
1008                 sub_v2_v2v2(axis, axis_2d, t->center2d);
1009                 axis[2] = 0.0f;
1010
1011                 if (normalize_v3(axis) > 1e-3f) {
1012                         project_v3_v3v3(proj, mvec, axis);
1013                         sub_v3_v3v3(axis, mvec, proj);
1014                         len[i] = normalize_v3(axis);
1015                 }
1016                 else {
1017                         len[i] = 1e10f;
1018                 }
1019         }
1020
1021         if (len[0] <= len[1] && len[0] <= len[2]) {
1022                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
1023                         t->con.mode |= (CON_AXIS1 | CON_AXIS2);
1024                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s X axis"), t->spacename);
1025                 }
1026                 else {
1027                         t->con.mode |= CON_AXIS0;
1028                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s X axis"), t->spacename);
1029                 }
1030         }
1031         else if (len[1] <= len[0] && len[1] <= len[2]) {
1032                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
1033                         t->con.mode |= (CON_AXIS0 | CON_AXIS2);
1034                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Y axis"), t->spacename);
1035                 }
1036                 else {
1037                         t->con.mode |= CON_AXIS1;
1038                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Y axis"), t->spacename);
1039                 }
1040         }
1041         else if (len[2] <= len[1] && len[2] <= len[0]) {
1042                 if (t->modifiers & MOD_CONSTRAINT_PLANE) {
1043                         t->con.mode |= (CON_AXIS0 | CON_AXIS1);
1044                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" locking %s Z axis"), t->spacename);
1045                 }
1046                 else {
1047                         t->con.mode |= CON_AXIS2;
1048                         BLI_snprintf(t->con.text, sizeof(t->con.text), IFACE_(" along %s Z axis"), t->spacename);
1049                 }
1050         }
1051 }
1052
1053 void setNearestAxis(TransInfo *t)
1054 {
1055         /* clear any prior constraint flags */
1056         t->con.mode &= ~CON_AXIS0;
1057         t->con.mode &= ~CON_AXIS1;
1058         t->con.mode &= ~CON_AXIS2;
1059
1060         /* constraint setting - depends on spacetype */
1061         if (t->spacetype == SPACE_VIEW3D) {
1062                 /* 3d-view */
1063                 setNearestAxis3d(t);
1064         }
1065         else {
1066                 /* assume that this means a 2D-Editor */
1067                 setNearestAxis2d(t);
1068         }
1069
1070         getConstraintMatrix(t);
1071 }
1072
1073 /*-------------- HELPER FUNCTIONS ----------------*/
1074
1075 char constraintModeToChar(TransInfo *t)
1076 {
1077         if ((t->con.mode & CON_APPLY) == 0) {
1078                 return '\0';
1079         }
1080         switch (t->con.mode & (CON_AXIS0 | CON_AXIS1 | CON_AXIS2)) {
1081                 case (CON_AXIS0):
1082                 case (CON_AXIS1 | CON_AXIS2):
1083                         return 'X';
1084                 case (CON_AXIS1):
1085                 case (CON_AXIS0 | CON_AXIS2):
1086                         return 'Y';
1087                 case (CON_AXIS2):
1088                 case (CON_AXIS0 | CON_AXIS1):
1089                         return 'Z';
1090                 default:
1091                         return '\0';
1092         }
1093 }
1094
1095
1096 bool isLockConstraint(TransInfo *t)
1097 {
1098         int mode = t->con.mode;
1099
1100         if ((mode & (CON_AXIS0 | CON_AXIS1)) == (CON_AXIS0 | CON_AXIS1))
1101                 return true;
1102
1103         if ((mode & (CON_AXIS1 | CON_AXIS2)) == (CON_AXIS1 | CON_AXIS2))
1104                 return true;
1105
1106         if ((mode & (CON_AXIS0 | CON_AXIS2)) == (CON_AXIS0 | CON_AXIS2))
1107                 return true;
1108
1109         return false;
1110 }
1111
1112 /*
1113  * Returns the dimension of the constraint space.
1114  *
1115  * For that reason, the flags always needs to be set to properly evaluate here,
1116  * even if they aren't actually used in the callback function. (Which could happen
1117  * for weird constraints not yet designed. Along a path for example.)
1118  */
1119
1120 int getConstraintSpaceDimension(TransInfo *t)
1121 {
1122         int n = 0;
1123
1124         if (t->con.mode & CON_AXIS0)
1125                 n++;
1126
1127         if (t->con.mode & CON_AXIS1)
1128                 n++;
1129
1130         if (t->con.mode & CON_AXIS2)
1131                 n++;
1132
1133         return n;
1134 /*
1135  * Someone willing to do it cryptically could do the following instead:
1136  *
1137  * return t->con & (CON_AXIS0|CON_AXIS1|CON_AXIS2);
1138  *
1139  * Based on the assumptions that the axis flags are one after the other and start at 1
1140  */
1141 }