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