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