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