source/blender/editors/transform/transform_input.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  * Contributor(s): none yet.
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file blender/editors/transform/transform_input.c
  24  *  \ingroup edtransform
  25  */
  26
  27
  28 #include <stdlib.h>
  29 #include <math.h>
  30
  31 #include "DNA_screen_types.h"
  32
  33 #include "BLI_math.h"
  34 #include "BLI_utildefines.h"
  35
  36 #include "WM_types.h"
  37
  38 #include "transform.h"
  39
  40 #include "MEM_guardedalloc.h"
  41
  42 /* ************************** INPUT FROM MOUSE *************************** */
  43
  44 static void InputVector(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
  45 {
  46         float vec[3], dvec[3];
  47         if(mi->precision)
  48         {
  49                 /* calculate the main translation and the precise one separate */
  50                 convertViewVec(t, dvec, (mval[0] - mi->precision_mval[0]), (mval[1] - mi->precision_mval[1]));
  51                 mul_v3_fl(dvec, 0.1f);
  52                 convertViewVec(t, vec, (mi->precision_mval[0] - t->imval[0]), (mi->precision_mval[1] - t->imval[1]));
  53                 add_v3_v3v3(output, vec, dvec);
  54         }
  55         else
  56         {
  57                 convertViewVec(t, output, (mval[0] - t->imval[0]), (mval[1] - t->imval[1]));
  58         }
  59
  60 }
  61
  62 static void InputSpring(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
  63 {
  64         float ratio, precise_ratio, dx, dy;
  65         if(mi->precision)
  66         {
  67                 /* calculate ratio for shiftkey pos, and for total, and blend these for precision */
  68                 dx = (float)(mi->center[0] - mi->precision_mval[0]);
  69                 dy = (float)(mi->center[1] - mi->precision_mval[1]);
  70                 ratio = (float)sqrt( dx*dx + dy*dy);
  71
  72                 dx= (float)(mi->center[0] - mval[0]);
  73                 dy= (float)(mi->center[1] - mval[1]);
  74                 precise_ratio = (float)sqrt( dx*dx + dy*dy);
  75
  76                 ratio = (ratio + (precise_ratio - ratio) / 10.0f) / mi->factor;
  77         }
  78         else
  79         {
  80                 dx = (float)(mi->center[0] - mval[0]);
  81                 dy = (float)(mi->center[1] - mval[1]);
  82                 ratio = (float)sqrt( dx*dx + dy*dy) / mi->factor;
  83         }
  84
  85         output[0] = ratio;
  86 }
  87
  88 static void InputSpringFlip(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
  89 {
  90         InputSpring(t, mi, mval, output);
  91
  92         /* flip scale */
  93         /* values can become really big when zoomed in so use longs [#26598] */
  94         if      ((long long int)(mi->center[0] - mval[0]) * (long long int)(mi->center[0] - mi->imval[0]) +
  95                  (long long int)(mi->center[1] - mval[1]) * (long long int)(mi->center[1] - mi->imval[1]) < 0)
  96          {
  97                 output[0] *= -1.0f;
  98          }
  99 }
 100
 101 static void InputTrackBall(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
 102 {
 103
 104         if(mi->precision)
 105         {
 106                 output[0] = ( mi->imval[1] - mi->precision_mval[1] ) + ( mi->precision_mval[1] - mval[1] ) * 0.1f;
 107                 output[1] = ( mi->precision_mval[0] - mi->imval[0] ) + ( mval[0] - mi->precision_mval[0] ) * 0.1f;
 108         }
 109         else
 110         {
 111                 output[0] = (float)( mi->imval[1] - mval[1] );
 112                 output[1] = (float)( mval[0] - mi->imval[0] );
 113         }
 114
 115         output[0] *= mi->factor;
 116         output[1] *= mi->factor;
 117 }
 118
 119 static void InputHorizontalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
 120 {
 121         float x, pad;
 122
 123         pad = t->ar->winx / 10;
 124
 125         if (mi->precision)
 126         {
 127                 /* deal with Shift key by adding motion / 10 to motion before shift press */
 128                 x = mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f;
 129         }
 130         else {
 131                 x = mval[0];
 132         }
 133
 134         output[0] = (x - pad) / (t->ar->winx - 2 * pad);
 135 }
 136
 137 static void InputHorizontalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
 138 {
 139         float vec[3];
 140
 141         InputVector(t, mi, mval, vec);
 142         project_v3_v3v3(vec, vec, t->viewinv[0]);
 143
 144         output[0] = dot_v3v3(t->viewinv[0], vec) * 2.0f;
 145 }
 146
 147 static void InputVerticalRatio(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
 148 {
 149         float y, pad;
 150
 151         pad = t->ar->winy / 10;
 152
 153         if (mi->precision) {
 154                 /* deal with Shift key by adding motion / 10 to motion before shift press */
 155                 y = mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f;
 156         }
 157         else {
 158                 y = mval[0];
 159         }
 160
 161         output[0] = (y - pad) / (t->ar->winy - 2 * pad);
 162 }
 163
 164 static void InputVerticalAbsolute(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
 165 {
 166         float vec[3];
 167
 168         InputVector(t, mi, mval, vec);
 169         project_v3_v3v3(vec, vec, t->viewinv[1]);
 170
 171         output[0] = dot_v3v3(t->viewinv[1], vec) * 2.0f;
 172 }
 173
 174 void setCustomPoints(TransInfo *UNUSED(t), MouseInput *mi, int start[2], int end[2])
 175 {
 176         int *data;
 177
 178         if (mi->data == NULL) {
 179                 mi->data = MEM_callocN(sizeof(int) * 4, "custom points");
 180         }
 181
 182         data = mi->data;
 183
 184         data[0] = start[0];
 185         data[1] = start[1];
 186         data[2] = end[0];
 187         data[3] = end[1];
 188 }
 189
 190 static void InputCustomRatio(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
 191 {
 192         double length;
 193         double distance;
 194         double dx, dy;
 195         int *data = mi->data;
 196
 197         if (data) {
 198                 dx = data[2] - data[0];
 199                 dy = data[3] - data[1];
 200
 201                 length = sqrt(dx*dx + dy*dy);
 202
 203                 if (mi->precision) {
 204                         /* deal with Shift key by adding motion / 10 to motion before shift press */
 205                         int mdx, mdy;
 206                         mdx = (mi->precision_mval[0] + (float)(mval[0] - mi->precision_mval[0]) / 10.0f) - data[2];
 207                         mdy = (mi->precision_mval[1] + (float)(mval[1] - mi->precision_mval[1]) / 10.0f) - data[3];
 208
 209                         distance = (length != 0.0f)? (mdx*dx + mdy*dy) / length: 0.0f;
 210                 }
 211                 else {
 212                         int mdx, mdy;
 213                         mdx = mval[0] - data[2];
 214                         mdy = mval[1] - data[3];
 215
 216                         distance = (length != 0.0f)? (mdx*dx + mdy*dy) / length: 0.0f;
 217                 }
 218
 219                 output[0] = (float)((length != 0.0f)? distance / length: 0.0f);
 220         }
 221 }
 222
 223 static void InputAngle(TransInfo *UNUSED(t), MouseInput *mi, const int mval[2], float output[3])
 224 {
 225         double dx2 = mval[0] - mi->center[0];
 226         double dy2 = mval[1] - mi->center[1];
 227         double B = sqrt(dx2*dx2+dy2*dy2);
 228
 229         double dx1 = mi->imval[0] - mi->center[0];
 230         double dy1 = mi->imval[1] - mi->center[1];
 231         double A = sqrt(dx1*dx1+dy1*dy1);
 232
 233         double dx3 = mval[0] - mi->imval[0];
 234         double dy3 = mval[1] - mi->imval[1];
 235
 236         double *angle = mi->data;
 237
 238         /* use doubles here, to make sure a "1.0" (no rotation) doesnt become 9.999999e-01, which gives 0.02 for acos */
 239         double deler = ((dx1*dx1+dy1*dy1)+(dx2*dx2+dy2*dy2)-(dx3*dx3+dy3*dy3))
 240                 / (2.0 * ((A*B)?(A*B):1.0));
 241         /* ((A*B)?(A*B):1.0) this takes care of potential divide by zero errors */
 242
 243         float dphi;
 244
 245         dphi = saacos((float)deler);
 246         if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
 247
 248         /* If the angle is zero, because of lack of precision close to the 1.0 value in acos
 249          * approximate the angle with the opposite side of the normalized triangle
 250          * This is a good approximation here since the smallest acos value seems to be around
 251          * 0.02 degree and lower values don't even have a 0.01% error compared to the approximation
 252          * */
 253         if (dphi == 0)
 254         {
 255                 double dx, dy;
 256
 257                 dx2 /= A;
 258                 dy2 /= A;
 259
 260                 dx1 /= B;
 261                 dy1 /= B;
 262
 263                 dx = dx1 - dx2;
 264                 dy = dy1 - dy2;
 265
 266                 dphi = sqrt(dx*dx + dy*dy);
 267                 if( (dx1*dy2-dx2*dy1)>0.0 ) dphi= -dphi;
 268         }
 269
 270         if(mi->precision) dphi = dphi/30.0f;
 271
 272         /* if no delta angle, don't update initial position */
 273         if (dphi != 0)
 274         {
 275                 mi->imval[0] = mval[0];
 276                 mi->imval[1] = mval[1];
 277         }
 278
 279         *angle += (double)dphi;
 280
 281         output[0] = *angle;
 282 }
 283
 284 void initMouseInput(TransInfo *UNUSED(t), MouseInput *mi, int center[2], int mval[2])
 285 {
 286         mi->factor = 0;
 287         mi->precision = 0;
 288
 289         mi->center[0] = center[0];
 290         mi->center[1] = center[1];
 291
 292         mi->imval[0] = mval[0];
 293         mi->imval[1] = mval[1];
 294
 295         mi->post = NULL;
 296 }
 297
 298 static void calcSpringFactor(MouseInput *mi)
 299 {
 300         mi->factor = (float)sqrt(
 301                 (
 302                         ((float)(mi->center[1] - mi->imval[1]))*((float)(mi->center[1] - mi->imval[1]))
 303                 +
 304                         ((float)(mi->center[0] - mi->imval[0]))*((float)(mi->center[0] - mi->imval[0]))
 305                 ) );
 306
 307         if (mi->factor==0.0f)
 308                 mi->factor= 1.0f; /* prevent Inf */
 309 }
 310
 311 void initMouseInputMode(TransInfo *t, MouseInput *mi, MouseInputMode mode)
 312 {
 313         /* may have been allocated previously */
 314         /* TODO, holding R-key can cause mem leak, but this causes [#28903]
 315          * disable for now. */
 316 #if 0
 317         if(mi->data) {
 318                 MEM_freeN(mi->data);
 319                 mi->data= NULL;
 320         }
 321 #endif
 322
 323         switch(mode)
 324         {
 325         case INPUT_VECTOR:
 326                 mi->apply = InputVector;
 327                 t->helpline = HLP_NONE;
 328                 break;
 329         case INPUT_SPRING:
 330                 calcSpringFactor(mi);
 331                 mi->apply = InputSpring;
 332                 t->helpline = HLP_SPRING;
 333                 break;
 334         case INPUT_SPRING_FLIP:
 335                 calcSpringFactor(mi);
 336                 mi->apply = InputSpringFlip;
 337                 t->helpline = HLP_SPRING;
 338                 break;
 339         case INPUT_ANGLE:
 340                 mi->data = MEM_callocN(sizeof(double), "angle accumulator");
 341                 mi->apply = InputAngle;
 342                 t->helpline = HLP_ANGLE;
 343                 break;
 344         case INPUT_TRACKBALL:
 345                 /* factor has to become setting or so */
 346                 mi->factor = 0.01f;
 347                 mi->apply = InputTrackBall;
 348                 t->helpline = HLP_TRACKBALL;
 349                 break;
 350         case INPUT_HORIZONTAL_RATIO:
 351                 mi->factor = (float)(mi->center[0] - mi->imval[0]);
 352                 mi->apply = InputHorizontalRatio;
 353                 t->helpline = HLP_HARROW;
 354                 break;
 355         case INPUT_HORIZONTAL_ABSOLUTE:
 356                 mi->apply = InputHorizontalAbsolute;
 357                 t->helpline = HLP_HARROW;
 358                 break;
 359         case INPUT_VERTICAL_RATIO:
 360                 mi->apply = InputVerticalRatio;
 361                 t->helpline = HLP_VARROW;
 362                 break;
 363         case INPUT_VERTICAL_ABSOLUTE:
 364                 mi->apply = InputVerticalAbsolute;
 365                 t->helpline = HLP_VARROW;
 366                 break;
 367         case INPUT_CUSTOM_RATIO:
 368                 mi->apply = InputCustomRatio;
 369                 t->helpline = HLP_NONE;
 370                 break;
 371         case INPUT_NONE:
 372         default:
 373                 mi->apply = NULL;
 374                 break;
 375         }
 376
 377         /* bootstrap mouse input with initial values */
 378         applyMouseInput(t, mi, mi->imval, t->values);
 379 }
 380
 381 void setInputPostFct(MouseInput *mi, void       (*post)(struct TransInfo *, float [3]))
 382 {
 383         mi->post = post;
 384 }
 385
 386 void applyMouseInput(TransInfo *t, MouseInput *mi, const int mval[2], float output[3])
 387 {
 388         if (mi->apply != NULL)
 389         {
 390                 mi->apply(t, mi, mval, output);
 391         }
 392
 393         if (mi->post)
 394         {
 395                 mi->post(t, output);
 396         }
 397 }
 398
 399 int handleMouseInput(TransInfo *t, MouseInput *mi, wmEvent *event)
 400 {
 401         int redraw = TREDRAW_NOTHING;
 402
 403         switch (event->type)
 404         {
 405         case LEFTSHIFTKEY:
 406         case RIGHTSHIFTKEY:
 407                 if (event->val==KM_PRESS)
 408                 {
 409                         t->modifiers |= MOD_PRECISION;
 410                         /* shift is modifier for higher precision transform
 411                          * store the mouse position where the normal movement ended */
 412                         copy_v2_v2_int(mi->precision_mval, event->mval);
 413                         mi->precision = 1;
 414                 }
 415                 else
 416                 {
 417                         t->modifiers &= ~MOD_PRECISION;
 418                         mi->precision = 0;
 419                 }
 420                 redraw = TREDRAW_HARD;
 421                 break;
 422         }
 423
 424         return redraw;
 425 }