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