source/blender/editors/space_view3d/view3d_edit.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) 2008 Blender Foundation.
  19  * All rights reserved.
  20  *
  21  *
  22  * Contributor(s): Blender Foundation
  23  *
  24  * ***** END GPL LICENSE BLOCK *****
  25  */
  26
  27 /** \file blender/editors/space_view3d/view3d_edit.c
  28  *  \ingroup spview3d
  29  */
  30
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <math.h>
  34 #include <float.h>
  35
  36 #include "DNA_armature_types.h"
  37 #include "DNA_curve_types.h"
  38 #include "DNA_object_types.h"
  39 #include "DNA_scene_types.h"
  40 #include "DNA_gpencil_types.h"
  41
  42 #include "MEM_guardedalloc.h"
  43
  44 #include "BLI_blenlib.h"
  45 #include "BLI_kdopbvh.h"
  46 #include "BLI_math.h"
  47 #include "BLI_utildefines.h"
  48
  49 #include "BKE_armature.h"
  50 #include "BKE_camera.h"
  51 #include "BKE_context.h"
  52 #include "BKE_font.h"
  53 #include "BKE_library.h"
  54 #include "BKE_object.h"
  55 #include "BKE_paint.h"
  56 #include "BKE_report.h"
  57 #include "BKE_scene.h"
  58 #include "BKE_screen.h"
  59 #include "BKE_action.h"
  60 #include "BKE_depsgraph.h" /* for ED_view3d_camera_lock_sync */
  61
  62
  63 #include "BIF_gl.h"
  64 #include "BIF_glutil.h"
  65
  66 #include "WM_api.h"
  67 #include "WM_types.h"
  68
  69 #include "RNA_access.h"
  70 #include "RNA_define.h"
  71
  72 #include "ED_armature.h"
  73 #include "ED_particle.h"
  74 #include "ED_keyframing.h"
  75 #include "ED_screen.h"
  76 #include "ED_transform.h"
  77 #include "ED_mesh.h"
  78 #include "ED_gpencil.h"
  79 #include "ED_view3d.h"
  80
  81 #include "UI_resources.h"
  82
  83 #include "PIL_time.h" /* smoothview */
  84
  85 #include "view3d_intern.h"  /* own include */
  86
  87 bool ED_view3d_offset_lock_check(const  View3D *v3d, const  RegionView3D *rv3d)
  88 {
  89         return (rv3d->persp != RV3D_CAMOB) && (v3d->ob_centre_cursor || v3d->ob_centre);
  90 }
  91
  92 static bool view3d_operator_offset_lock_check(bContext *C, wmOperator *op)
  93 {
  94         View3D *v3d = CTX_wm_view3d(C);
  95         RegionView3D *rv3d = CTX_wm_region_view3d(C);
  96         if (ED_view3d_offset_lock_check(v3d, rv3d)) {
  97                 BKE_report(op->reports, RPT_WARNING, "View offset is locked");
  98                 return true;
  99         }
 100         else {
 101                 return false;
 102         }
 103 }
 104
 105 /* ********************** view3d_edit: view manipulations ********************* */
 106
 107 /**
 108  * \return true when the view-port is locked to its camera.
 109  */
 110 bool ED_view3d_camera_lock_check(const View3D *v3d, const RegionView3D *rv3d)
 111 {
 112         return ((v3d->camera) &&
 113                 (v3d->camera->id.lib == NULL) &&
 114                 (v3d->flag2 & V3D_LOCK_CAMERA) &&
 115                 (rv3d->persp == RV3D_CAMOB));
 116 }
 117
 118 /**
 119  * Apply the camera object transformation to the view-port.
 120  * (needed so we can use regular view-port manipulation operators, that sync back to the camera).
 121  */
 122 void ED_view3d_camera_lock_init_ex(View3D *v3d, RegionView3D *rv3d, const bool calc_dist)
 123 {
 124         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
 125                 if (calc_dist) {
 126                         /* using a fallback dist is OK here since ED_view3d_from_object() compensates for it */
 127                         rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
 128                 }
 129                 ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
 130         }
 131 }
 132
 133 void ED_view3d_camera_lock_init(View3D *v3d, RegionView3D *rv3d)
 134 {
 135         ED_view3d_camera_lock_init_ex(v3d, rv3d, true);
 136 }
 137
 138 /**
 139  * Apply the view-port transformation back to the camera object.
 140  *
 141  * \return true if the camera is moved.
 142  */
 143 bool ED_view3d_camera_lock_sync(View3D *v3d, RegionView3D *rv3d)
 144 {
 145         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
 146                 ObjectTfmProtectedChannels obtfm;
 147                 Object *root_parent;
 148
 149                 if ((U.uiflag & USER_CAM_LOCK_NO_PARENT) == 0 && (root_parent = v3d->camera->parent)) {
 150                         Object *ob_update;
 151                         float tmat[4][4];
 152                         float imat[4][4];
 153                         float view_mat[4][4];
 154                         float diff_mat[4][4];
 155                         float parent_mat[4][4];
 156
 157                         while (root_parent->parent) {
 158                                 root_parent = root_parent->parent;
 159                         }
 160
 161                         ED_view3d_to_m4(view_mat, rv3d->ofs, rv3d->viewquat, rv3d->dist);
 162
 163                         normalize_m4_m4(tmat, v3d->camera->obmat);
 164
 165                         invert_m4_m4(imat, tmat);
 166                         mul_m4_m4m4(diff_mat, view_mat, imat);
 167
 168                         mul_m4_m4m4(parent_mat, diff_mat, root_parent->obmat);
 169
 170                         BKE_object_tfm_protected_backup(root_parent, &obtfm);
 171                         BKE_object_apply_mat4(root_parent, parent_mat, true, false);
 172                         BKE_object_tfm_protected_restore(root_parent, &obtfm, root_parent->protectflag);
 173
 174                         ob_update = v3d->camera;
 175                         while (ob_update) {
 176                                 DAG_id_tag_update(&ob_update->id, OB_RECALC_OB);
 177                                 WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, ob_update);
 178                                 ob_update = ob_update->parent;
 179                         }
 180                 }
 181                 else {
 182                         /* always maintain the same scale */
 183                         const short protect_scale_all = (OB_LOCK_SCALEX | OB_LOCK_SCALEY | OB_LOCK_SCALEZ);
 184                         BKE_object_tfm_protected_backup(v3d->camera, &obtfm);
 185                         ED_view3d_to_object(v3d->camera, rv3d->ofs, rv3d->viewquat, rv3d->dist);
 186                         BKE_object_tfm_protected_restore(v3d->camera, &obtfm, v3d->camera->protectflag | protect_scale_all);
 187
 188                         DAG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
 189                         WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, v3d->camera);
 190                 }
 191
 192                 return true;
 193         }
 194         else {
 195                 return false;
 196         }
 197 }
 198
 199 bool ED_view3d_camera_autokey(
 200         Scene *scene, ID *id_key,
 201         struct bContext *C, const bool do_rotate, const bool do_translate)
 202 {
 203         if (autokeyframe_cfra_can_key(scene, id_key)) {
 204                 const float cfra = (float)CFRA;
 205                 ListBase dsources = {NULL, NULL};
 206
 207                 /* add data-source override for the camera object */
 208                 ANIM_relative_keyingset_add_source(&dsources, id_key, NULL, NULL);
 209
 210                 /* insert keyframes
 211                  * 1) on the first frame
 212                  * 2) on each subsequent frame
 213                  *    TODO: need to check in future that frame changed before doing this
 214                  */
 215                 if (do_rotate) {
 216                         struct KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_ROTATION_ID);
 217                         ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, cfra);
 218                 }
 219                 if (do_translate) {
 220                         struct KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_LOCATION_ID);
 221                         ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, cfra);
 222                 }
 223
 224                 /* free temp data */
 225                 BLI_freelistN(&dsources);
 226
 227                 return true;
 228         }
 229         else {
 230                 return false;
 231         }
 232 }
 233
 234 /**
 235  * Call after modifying a locked view.
 236  *
 237  * \note Not every view edit currently auto-keys (numpad for eg),
 238  * this is complicated because of smoothview.
 239  */
 240 bool ED_view3d_camera_lock_autokey(
 241         View3D *v3d, RegionView3D *rv3d,
 242         struct bContext *C, const bool do_rotate, const bool do_translate)
 243 {
 244         /* similar to ED_view3d_cameracontrol_update */
 245         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
 246                 Scene *scene = CTX_data_scene(C);
 247                 ID *id_key;
 248                 Object *root_parent;
 249                 if ((U.uiflag & USER_CAM_LOCK_NO_PARENT) == 0 && (root_parent = v3d->camera->parent)) {
 250                         while (root_parent->parent) {
 251                                 root_parent = root_parent->parent;
 252                         }
 253                         id_key = &root_parent->id;
 254                 }
 255                 else {
 256                         id_key = &v3d->camera->id;
 257                 }
 258
 259                 return ED_view3d_camera_autokey(scene, id_key, C, do_rotate, do_translate);
 260         }
 261         else {
 262                 return false;
 263         }
 264 }
 265
 266 /**
 267  * For viewport operators that exit camera persp.
 268  *
 269  * \note This differs from simply setting ``rv3d->persp = persp`` because it
 270  * sets the ``ofs`` and ``dist`` values of the viewport so it matches the camera,
 271  * otherwise switching out of camera view may jump to a different part of the scene.
 272  */
 273 static void view3d_persp_switch_from_camera(View3D *v3d, RegionView3D *rv3d, const char persp)
 274 {
 275         BLI_assert(rv3d->persp == RV3D_CAMOB);
 276         BLI_assert(persp != RV3D_CAMOB);
 277
 278         if (v3d->camera) {
 279                 rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
 280                 ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
 281         }
 282
 283         if (!ED_view3d_camera_lock_check(v3d, rv3d)) {
 284                 rv3d->persp = persp;
 285         }
 286 }
 287
 288 /* ********************* box view support ***************** */
 289
 290 static void view3d_boxview_clip(ScrArea *sa)
 291 {
 292         ARegion *ar;
 293         BoundBox *bb = MEM_callocN(sizeof(BoundBox), "clipbb");
 294         float clip[6][4];
 295         float x1 = 0.0f, y1 = 0.0f, z1 = 0.0f, ofs[3] = {0.0f, 0.0f, 0.0f};
 296         int val;
 297
 298         /* create bounding box */
 299         for (ar = sa->regionbase.first; ar; ar = ar->next) {
 300                 if (ar->regiontype == RGN_TYPE_WINDOW) {
 301                         RegionView3D *rv3d = ar->regiondata;
 302
 303                         if (rv3d->viewlock & RV3D_BOXCLIP) {
 304                                 if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) {
 305                                         if (ar->winx > ar->winy) x1 = rv3d->dist;
 306                                         else x1 = ar->winx * rv3d->dist / ar->winy;
 307
 308                                         if (ar->winx > ar->winy) y1 = ar->winy * rv3d->dist / ar->winx;
 309                                         else y1 = rv3d->dist;
 310                                         copy_v2_v2(ofs, rv3d->ofs);
 311                                 }
 312                                 else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) {
 313                                         ofs[2] = rv3d->ofs[2];
 314
 315                                         if (ar->winx > ar->winy) z1 = ar->winy * rv3d->dist / ar->winx;
 316                                         else z1 = rv3d->dist;
 317                                 }
 318                         }
 319                 }
 320         }
 321
 322         for (val = 0; val < 8; val++) {
 323                 if (ELEM(val, 0, 3, 4, 7))
 324                         bb->vec[val][0] = -x1 - ofs[0];
 325                 else
 326                         bb->vec[val][0] =  x1 - ofs[0];
 327
 328                 if (ELEM(val, 0, 1, 4, 5))
 329                         bb->vec[val][1] = -y1 - ofs[1];
 330                 else
 331                         bb->vec[val][1] =  y1 - ofs[1];
 332
 333                 if (val > 3)
 334                         bb->vec[val][2] = -z1 - ofs[2];
 335                 else
 336                         bb->vec[val][2] =  z1 - ofs[2];
 337         }
 338
 339         /* normals for plane equations */
 340         normal_tri_v3(clip[0], bb->vec[0], bb->vec[1], bb->vec[4]);
 341         normal_tri_v3(clip[1], bb->vec[1], bb->vec[2], bb->vec[5]);
 342         normal_tri_v3(clip[2], bb->vec[2], bb->vec[3], bb->vec[6]);
 343         normal_tri_v3(clip[3], bb->vec[3], bb->vec[0], bb->vec[7]);
 344         normal_tri_v3(clip[4], bb->vec[4], bb->vec[5], bb->vec[6]);
 345         normal_tri_v3(clip[5], bb->vec[0], bb->vec[2], bb->vec[1]);
 346
 347         /* then plane equations */
 348         for (val = 0; val < 6; val++) {
 349                 clip[val][3] = -dot_v3v3(clip[val], bb->vec[val % 5]);
 350         }
 351
 352         /* create bounding box */
 353         for (ar = sa->regionbase.first; ar; ar = ar->next) {
 354                 if (ar->regiontype == RGN_TYPE_WINDOW) {
 355                         RegionView3D *rv3d = ar->regiondata;
 356
 357                         if (rv3d->viewlock & RV3D_BOXCLIP) {
 358                                 rv3d->rflag |= RV3D_CLIPPING;
 359                                 memcpy(rv3d->clip, clip, sizeof(clip));
 360                                 if (rv3d->clipbb) MEM_freeN(rv3d->clipbb);
 361                                 rv3d->clipbb = MEM_dupallocN(bb);
 362                         }
 363                 }
 364         }
 365         MEM_freeN(bb);
 366 }
 367
 368 /**
 369  * Find which axis values are shared between both views and copy to \a rv3d_dst
 370  * taking axis flipping into account.
 371  */
 372 static void view3d_boxview_sync_axis(RegionView3D *rv3d_dst, RegionView3D *rv3d_src)
 373 {
 374         /* absolute axis values above this are considered to be set (will be ~1.0f) */
 375         const float axis_eps = 0.5f;
 376         float viewinv[4];
 377
 378         /* use the view rotation to identify which axis to sync on */
 379         float view_axis_all[4][3] = {
 380             {1.0f, 0.0f, 0.0f},
 381             {0.0f, 1.0f, 0.0f},
 382             {1.0f, 0.0f, 0.0f},
 383             {0.0f, 1.0f, 0.0f}};
 384
 385         float *view_src_x = &view_axis_all[0][0];
 386         float *view_src_y = &view_axis_all[1][0];
 387
 388         float *view_dst_x = &view_axis_all[2][0];
 389         float *view_dst_y = &view_axis_all[3][0];
 390         int i;
 391
 392
 393         /* we could use rv3d->viewinv, but better not depend on view matrix being updated */
 394         if (UNLIKELY(ED_view3d_quat_from_axis_view(rv3d_src->view, viewinv) == false)) {
 395                 return;
 396         }
 397         invert_qt_normalized(viewinv);
 398         mul_qt_v3(viewinv, view_src_x);
 399         mul_qt_v3(viewinv, view_src_y);
 400
 401         if (UNLIKELY(ED_view3d_quat_from_axis_view(rv3d_dst->view, viewinv) == false)) {
 402                 return;
 403         }
 404         invert_qt_normalized(viewinv);
 405         mul_qt_v3(viewinv, view_dst_x);
 406         mul_qt_v3(viewinv, view_dst_y);
 407
 408         /* check source and dest have a matching axis */
 409         for (i = 0; i < 3; i++) {
 410                 if (((fabsf(view_src_x[i]) > axis_eps) || (fabsf(view_src_y[i]) > axis_eps)) &&
 411                     ((fabsf(view_dst_x[i]) > axis_eps) || (fabsf(view_dst_y[i]) > axis_eps)))
 412                 {
 413                         rv3d_dst->ofs[i] = rv3d_src->ofs[i];
 414                 }
 415         }
 416 }
 417
 418 /* sync center/zoom view of region to others, for view transforms */
 419 static void view3d_boxview_sync(ScrArea *sa, ARegion *ar)
 420 {
 421         ARegion *artest;
 422         RegionView3D *rv3d = ar->regiondata;
 423         short clip = 0;
 424
 425         for (artest = sa->regionbase.first; artest; artest = artest->next) {
 426                 if (artest != ar && artest->regiontype == RGN_TYPE_WINDOW) {
 427                         RegionView3D *rv3dtest = artest->regiondata;
 428
 429                         if (rv3dtest->viewlock & RV3D_LOCKED) {
 430                                 rv3dtest->dist = rv3d->dist;
 431                                 view3d_boxview_sync_axis(rv3dtest, rv3d);
 432                                 clip |= rv3dtest->viewlock & RV3D_BOXCLIP;
 433
 434                                 ED_region_tag_redraw(artest);
 435                         }
 436                 }
 437         }
 438
 439         if (clip) {
 440                 view3d_boxview_clip(sa);
 441         }
 442 }
 443
 444 /* for home, center etc */
 445 void view3d_boxview_copy(ScrArea *sa, ARegion *ar)
 446 {
 447         ARegion *artest;
 448         RegionView3D *rv3d = ar->regiondata;
 449         bool clip = false;
 450
 451         for (artest = sa->regionbase.first; artest; artest = artest->next) {
 452                 if (artest != ar && artest->regiontype == RGN_TYPE_WINDOW) {
 453                         RegionView3D *rv3dtest = artest->regiondata;
 454
 455                         if (rv3dtest->viewlock) {
 456                                 rv3dtest->dist = rv3d->dist;
 457                                 copy_v3_v3(rv3dtest->ofs, rv3d->ofs);
 458                                 ED_region_tag_redraw(artest);
 459
 460                                 clip |= ((rv3dtest->viewlock & RV3D_BOXCLIP) != 0);
 461                         }
 462                 }
 463         }
 464
 465         if (clip) {
 466                 view3d_boxview_clip(sa);
 467         }
 468 }
 469
 470 /* 'clip' is used to know if our clip setting has changed */
 471 void ED_view3d_quadview_update(ScrArea *sa, ARegion *ar, bool do_clip)
 472 {
 473         ARegion *ar_sync = NULL;
 474         RegionView3D *rv3d = ar->regiondata;
 475         short viewlock;
 476         /* this function copies flags from the first of the 3 other quadview
 477          * regions to the 2 other, so it assumes this is the region whose
 478          * properties are always being edited, weak */
 479         viewlock = rv3d->viewlock;
 480
 481         if ((viewlock & RV3D_LOCKED) == 0) {
 482                 do_clip = (viewlock & RV3D_BOXCLIP) != 0;
 483                 viewlock = 0;
 484         }
 485         else if ((viewlock & RV3D_BOXVIEW) == 0 && (viewlock & RV3D_BOXCLIP) != 0) {
 486                 do_clip = true;
 487                 viewlock &= ~RV3D_BOXCLIP;
 488         }
 489
 490         for (; ar; ar = ar->prev) {
 491                 if (ar->alignment == RGN_ALIGN_QSPLIT) {
 492                         rv3d = ar->regiondata;
 493                         rv3d->viewlock = viewlock;
 494
 495                         if (do_clip && (viewlock & RV3D_BOXCLIP) == 0) {
 496                                 rv3d->rflag &= ~RV3D_BOXCLIP;
 497                         }
 498
 499                         /* use ar_sync so we sync with one of the aligned views below
 500                          * else the view jumps on changing view settings like 'clip'
 501                          * since it copies from the perspective view */
 502                         ar_sync = ar;
 503                 }
 504         }
 505
 506         if (rv3d->viewlock & RV3D_BOXVIEW) {
 507                 view3d_boxview_sync(sa, ar_sync ? ar_sync : sa->regionbase.last);
 508         }
 509
 510         /* ensure locked regions have an axis, locked user views don't make much sense */
 511         if (viewlock & RV3D_LOCKED) {
 512                 int index_qsplit = 0;
 513                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
 514                         if (ar->alignment == RGN_ALIGN_QSPLIT) {
 515                                 rv3d = ar->regiondata;
 516                                 if (rv3d->viewlock) {
 517                                         if (!RV3D_VIEW_IS_AXIS(rv3d->view)) {
 518                                                 rv3d->view = ED_view3d_lock_view_from_index(index_qsplit);
 519                                                 rv3d->persp = RV3D_ORTHO;
 520                                                 ED_view3d_lock(rv3d);
 521                                         }
 522                                 }
 523                                 index_qsplit++;
 524                         }
 525                 }
 526         }
 527
 528         ED_area_tag_redraw(sa);
 529 }
 530
 531 /* ************************** init for view ops **********************************/
 532
 533 typedef struct ViewOpsData {
 534         /* context pointers (assigned by viewops_data_alloc) */
 535         Scene *scene;
 536         ScrArea *sa;
 537         ARegion *ar;
 538         View3D *v3d;
 539         RegionView3D *rv3d;
 540
 541         /* needed for continuous zoom */
 542         wmTimer *timer;
 543         double timer_lastdraw;
 544
 545         float oldquat[4];
 546         float viewquat[4]; /* working copy of rv3d->viewquat */
 547         float trackvec[3];
 548         float mousevec[3]; /* dolly only */
 549         float reverse;
 550         float dist_prev, camzoom_prev;
 551         float grid, far;
 552         bool axis_snap;  /* view rotate only */
 553         float zfac;
 554
 555         /* use for orbit selection and auto-dist */
 556         float ofs[3], dyn_ofs[3];
 557         bool use_dyn_ofs;
 558
 559         int origx, origy, oldx, oldy;
 560         int origkey; /* the key that triggered the operator */
 561
 562 } ViewOpsData;
 563
 564 #define TRACKBALLSIZE  (1.1f)
 565
 566 static void calctrackballvec(const rcti *rect, int mx, int my, float vec[3])
 567 {
 568         float x, y, radius, d, z, t;
 569
 570         radius = TRACKBALLSIZE;
 571
 572         /* normalize x and y */
 573         x = BLI_rcti_cent_x(rect) - mx;
 574         x /= (float)(BLI_rcti_size_x(rect) / 4);
 575         y = BLI_rcti_cent_y(rect) - my;
 576         y /= (float)(BLI_rcti_size_y(rect) / 2);
 577
 578         d = sqrtf(x * x + y * y);
 579         if (d < radius * (float)M_SQRT1_2) { /* Inside sphere */
 580                 z = sqrtf(radius * radius - d * d);
 581         }
 582         else { /* On hyperbola */
 583                 t = radius / (float)M_SQRT2;
 584                 z = t * t / d;
 585         }
 586
 587         vec[0] = x;
 588         vec[1] = y;
 589         vec[2] = -z;     /* yah yah! */
 590 }
 591
 592
 593 /* -------------------------------------------------------------------- */
 594 /* ViewOpsData */
 595
 596 /** \name Generic View Operator Custom-Data.
 597  * \{ */
 598
 599 /**
 600  * Allocate and fill in context pointers for #ViewOpsData
 601  */
 602 static void viewops_data_alloc(bContext *C, wmOperator *op)
 603 {
 604         ViewOpsData *vod = MEM_callocN(sizeof(ViewOpsData), "viewops data");
 605
 606         /* store data */
 607         op->customdata = vod;
 608         vod->scene = CTX_data_scene(C);
 609         vod->sa = CTX_wm_area(C);
 610         vod->ar = CTX_wm_region(C);
 611         vod->v3d = vod->sa->spacedata.first;
 612         vod->rv3d = vod->ar->regiondata;
 613 }
 614
 615 void view3d_orbit_apply_dyn_ofs(
 616         float r_ofs[3], const float ofs_old[3], const float viewquat_old[4],
 617         const float viewquat_new[4], const float dyn_ofs[3])
 618 {
 619         float q[4];
 620         invert_qt_qt_normalized(q, viewquat_old);
 621         mul_qt_qtqt(q, q, viewquat_new);
 622
 623         invert_qt_normalized(q);
 624
 625         sub_v3_v3v3(r_ofs, ofs_old, dyn_ofs);
 626         mul_qt_v3(q, r_ofs);
 627         add_v3_v3(r_ofs, dyn_ofs);
 628 }
 629
 630 static bool view3d_orbit_calc_center(bContext *C, float r_dyn_ofs[3])
 631 {
 632         static float lastofs[3] = {0, 0, 0};
 633         bool is_set = false;
 634
 635         Scene *scene = CTX_data_scene(C);
 636         Object *ob_act = OBACT;
 637
 638         if (ob_act && (ob_act->mode & OB_MODE_ALL_PAINT) &&
 639             /* with weight-paint + pose-mode, fall through to using calculateTransformCenter */
 640             ((ob_act->mode & OB_MODE_WEIGHT_PAINT) && BKE_object_pose_armature_get(ob_act)) == 0)
 641         {
 642                 /* in case of sculpting use last average stroke position as a rotation
 643                  * center, in other cases it's not clear what rotation center shall be
 644                  * so just rotate around object origin
 645                  */
 646                 if (ob_act->mode & (OB_MODE_SCULPT | OB_MODE_TEXTURE_PAINT | OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT)) {
 647                         float stroke[3];
 648                         BKE_paint_stroke_get_average(scene, ob_act, stroke);
 649                         copy_v3_v3(lastofs, stroke);
 650                 }
 651                 else {
 652                         copy_v3_v3(lastofs, ob_act->obmat[3]);
 653                 }
 654                 is_set = true;
 655         }
 656         else if (ob_act && (ob_act->mode & OB_MODE_EDIT) && (ob_act->type == OB_FONT)) {
 657                 Curve *cu = ob_act->data;
 658                 EditFont *ef = cu->editfont;
 659                 int i;
 660
 661                 zero_v3(lastofs);
 662                 for (i = 0; i < 4; i++) {
 663                         add_v2_v2(lastofs, ef->textcurs[i]);
 664                 }
 665                 mul_v2_fl(lastofs, 1.0f / 4.0f);
 666
 667                 mul_m4_v3(ob_act->obmat, lastofs);
 668
 669                 is_set = true;
 670         }
 671         else if (ob_act == NULL || ob_act->mode == OB_MODE_OBJECT) {
 672                 /* object mode use boundbox centers */
 673                 View3D *v3d = CTX_wm_view3d(C);
 674                 Base *base;
 675                 unsigned int tot = 0;
 676                 float select_center[3];
 677
 678                 zero_v3(select_center);
 679                 for (base = FIRSTBASE; base; base = base->next) {
 680                         if (TESTBASE(v3d, base)) {
 681                                 /* use the boundbox if we can */
 682                                 Object *ob = base->object;
 683
 684                                 if (ob->bb && !(ob->bb->flag & BOUNDBOX_DIRTY)) {
 685                                         float cent[3];
 686
 687                                         BKE_boundbox_calc_center_aabb(ob->bb, cent);
 688
 689                                         mul_m4_v3(ob->obmat, cent);
 690                                         add_v3_v3(select_center, cent);
 691                                 }
 692                                 else {
 693                                         add_v3_v3(select_center, ob->obmat[3]);
 694                                 }
 695                                 tot++;
 696                         }
 697                 }
 698                 if (tot) {
 699                         mul_v3_fl(select_center, 1.0f / (float)tot);
 700                         copy_v3_v3(lastofs, select_center);
 701                         is_set = true;
 702                 }
 703         }
 704         else {
 705                 /* If there's no selection, lastofs is unmodified and last value since static */
 706                 is_set = calculateTransformCenter(C, V3D_AROUND_CENTER_MEAN, lastofs, NULL);
 707         }
 708
 709         copy_v3_v3(r_dyn_ofs, lastofs);
 710
 711         return is_set;
 712 }
 713
 714 /**
 715  * Calculate the values for #ViewOpsData
 716  */
 717 static void viewops_data_create_ex(bContext *C, wmOperator *op, const wmEvent *event,
 718                                    const bool use_orbit_select,
 719                                    const bool use_orbit_zbuf)
 720 {
 721         ViewOpsData *vod = op->customdata;
 722         RegionView3D *rv3d = vod->rv3d;
 723
 724         /* set the view from the camera, if view locking is enabled.
 725          * we may want to make this optional but for now its needed always */
 726         ED_view3d_camera_lock_init(vod->v3d, vod->rv3d);
 727
 728         vod->dist_prev = rv3d->dist;
 729         vod->camzoom_prev = rv3d->camzoom;
 730         copy_qt_qt(vod->viewquat, rv3d->viewquat);
 731         copy_qt_qt(vod->oldquat, rv3d->viewquat);
 732         vod->origx = vod->oldx = event->x;
 733         vod->origy = vod->oldy = event->y;
 734         vod->origkey = event->type; /* the key that triggered the operator.  */
 735         vod->use_dyn_ofs = false;
 736         copy_v3_v3(vod->ofs, rv3d->ofs);
 737
 738         if (use_orbit_select) {
 739
 740                 vod->use_dyn_ofs = true;
 741
 742                 view3d_orbit_calc_center(C, vod->dyn_ofs);
 743
 744                 negate_v3(vod->dyn_ofs);
 745         }
 746         else if (use_orbit_zbuf) {
 747                 Scene *scene = CTX_data_scene(C);
 748                 float fallback_depth_pt[3];
 749
 750                 view3d_operator_needs_opengl(C); /* needed for zbuf drawing */
 751
 752                 negate_v3_v3(fallback_depth_pt, rv3d->ofs);
 753
 754                 if ((vod->use_dyn_ofs = ED_view3d_autodist(scene, vod->ar, vod->v3d,
 755                                                            event->mval, vod->dyn_ofs, true, fallback_depth_pt)))
 756                 {
 757                         if (rv3d->is_persp) {
 758                                 float my_origin[3]; /* original G.vd->ofs */
 759                                 float my_pivot[3]; /* view */
 760                                 float dvec[3];
 761
 762                                 /* locals for dist correction */
 763                                 float mat[3][3];
 764                                 float upvec[3];
 765
 766                                 negate_v3_v3(my_origin, rv3d->ofs);             /* ofs is flipped */
 767
 768                                 /* Set the dist value to be the distance from this 3d point
 769                                  * this means youll always be able to zoom into it and panning wont go bad when dist was zero */
 770
 771                                 /* remove dist value */
 772                                 upvec[0] = upvec[1] = 0;
 773                                 upvec[2] = rv3d->dist;
 774                                 copy_m3_m4(mat, rv3d->viewinv);
 775
 776                                 mul_m3_v3(mat, upvec);
 777                                 sub_v3_v3v3(my_pivot, rv3d->ofs, upvec);
 778                                 negate_v3(my_pivot);                /* ofs is flipped */
 779
 780                                 /* find a new ofs value that is along the view axis (rather than the mouse location) */
 781                                 closest_to_line_v3(dvec, vod->dyn_ofs, my_pivot, my_origin);
 782                                 vod->dist_prev = rv3d->dist = len_v3v3(my_pivot, dvec);
 783
 784                                 negate_v3_v3(rv3d->ofs, dvec);
 785                         }
 786                         else {
 787                                 const float mval_ar_mid[2] = {
 788                                     (float)vod->ar->winx / 2.0f,
 789                                     (float)vod->ar->winy / 2.0f};
 790
 791                                 ED_view3d_win_to_3d(vod->ar, vod->dyn_ofs, mval_ar_mid, rv3d->ofs);
 792                                 negate_v3(rv3d->ofs);
 793                         }
 794                         negate_v3(vod->dyn_ofs);
 795                         copy_v3_v3(vod->ofs, rv3d->ofs);
 796                 }
 797         }
 798
 799         {
 800                 /* for dolly */
 801                 const float mval_f[2] = {(float)event->mval[0],
 802                                          (float)event->mval[1]};
 803                 ED_view3d_win_to_vector(vod->ar, mval_f, vod->mousevec);
 804         }
 805
 806         /* lookup, we don't pass on v3d to prevent confusement */
 807         vod->grid = vod->v3d->grid;
 808         vod->far = vod->v3d->far;
 809
 810         calctrackballvec(&vod->ar->winrct, event->x, event->y, vod->trackvec);
 811
 812         {
 813                 float tvec[3];
 814                 negate_v3_v3(tvec, rv3d->ofs);
 815                 vod->zfac = ED_view3d_calc_zfac(rv3d, tvec, NULL);
 816         }
 817
 818         vod->reverse = 1.0f;
 819         if (rv3d->persmat[2][1] < 0.0f)
 820                 vod->reverse = -1.0f;
 821
 822         rv3d->rflag |= RV3D_NAVIGATING;
 823 }
 824
 825 static void viewops_data_create(bContext *C, wmOperator *op, const wmEvent *event)
 826 {
 827         viewops_data_create_ex(
 828                 C, op, event,
 829                 (U.uiflag & USER_ORBIT_SELECTION) != 0,
 830                 (U.uiflag & USER_ZBUF_ORBIT) != 0);
 831 }
 832
 833 static void viewops_data_free(bContext *C, wmOperator *op)
 834 {
 835         ARegion *ar;
 836         Paint *p = BKE_paint_get_active_from_context(C);
 837
 838         if (op->customdata) {
 839                 ViewOpsData *vod = op->customdata;
 840                 ar = vod->ar;
 841                 vod->rv3d->rflag &= ~RV3D_NAVIGATING;
 842
 843                 if (vod->timer)
 844                         WM_event_remove_timer(CTX_wm_manager(C), vod->timer->win, vod->timer);
 845
 846                 MEM_freeN(vod);
 847                 op->customdata = NULL;
 848         }
 849         else {
 850                 ar = CTX_wm_region(C);
 851         }
 852
 853         if (p && (p->flags & PAINT_FAST_NAVIGATE))
 854                 ED_region_tag_redraw(ar);
 855 }
 856 /** \} */
 857
 858
 859 /* ************************** viewrotate **********************************/
 860
 861 enum {
 862         VIEW_PASS = 0,
 863         VIEW_APPLY,
 864         VIEW_CONFIRM
 865 };
 866
 867 /* NOTE: these defines are saved in keymap files, do not change values but just add new ones */
 868 #define VIEW_MODAL_CONFIRM              1 /* used for all view operations */
 869 #define VIEWROT_MODAL_AXIS_SNAP_ENABLE  2
 870 #define VIEWROT_MODAL_AXIS_SNAP_DISABLE 3
 871 #define VIEWROT_MODAL_SWITCH_ZOOM       4
 872 #define VIEWROT_MODAL_SWITCH_MOVE       5
 873 #define VIEWROT_MODAL_SWITCH_ROTATE     6
 874
 875 /* called in transform_ops.c, on each regeneration of keymaps  */
 876 void viewrotate_modal_keymap(wmKeyConfig *keyconf)
 877 {
 878         static EnumPropertyItem modal_items[] = {
 879                 {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
 880
 881                 {VIEWROT_MODAL_AXIS_SNAP_ENABLE,    "AXIS_SNAP_ENABLE", 0, "Enable Axis Snap", ""},
 882                 {VIEWROT_MODAL_AXIS_SNAP_DISABLE,   "AXIS_SNAP_DISABLE", 0, "Disable Axis Snap", ""},
 883
 884                 {VIEWROT_MODAL_SWITCH_ZOOM, "SWITCH_TO_ZOOM", 0, "Switch to Zoom"},
 885                 {VIEWROT_MODAL_SWITCH_MOVE, "SWITCH_TO_MOVE", 0, "Switch to Move"},
 886
 887                 {0, NULL, 0, NULL, NULL}
 888         };
 889
 890         wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Rotate Modal");
 891
 892         /* this function is called for each spacetype, only needs to add map once */
 893         if (keymap && keymap->modal_items) return;
 894
 895         keymap = WM_modalkeymap_add(keyconf, "View3D Rotate Modal", modal_items);
 896
 897         /* items for modal map */
 898         WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 899         WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
 900
 901         WM_modalkeymap_add_item(keymap, LEFTALTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_AXIS_SNAP_ENABLE);
 902         WM_modalkeymap_add_item(keymap, LEFTALTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_AXIS_SNAP_DISABLE);
 903
 904         /* disabled mode switching for now, can re-implement better, later on */
 905 #if 0
 906         WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 907         WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
 908         WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
 909 #endif
 910
 911         /* assign map to operators */
 912         WM_modalkeymap_assign(keymap, "VIEW3D_OT_rotate");
 913
 914 }
 915
 916 static void viewrotate_apply_dyn_ofs(ViewOpsData *vod, const float viewquat_new[4])
 917 {
 918         if (vod->use_dyn_ofs) {
 919                 RegionView3D *rv3d = vod->rv3d;
 920                 view3d_orbit_apply_dyn_ofs(rv3d->ofs, vod->ofs, vod->oldquat, viewquat_new, vod->dyn_ofs);
 921         }
 922 }
 923
 924 static void viewrotate_apply_snap(ViewOpsData *vod)
 925 {
 926         const float axis_limit = DEG2RADF(45 / 3);
 927
 928         RegionView3D *rv3d = vod->rv3d;
 929
 930         float viewquat_inv[4];
 931         float zaxis[3] = {0, 0, 1};
 932         float zaxis_best[3];
 933         int x, y, z;
 934         bool found = false;
 935
 936         invert_qt_qt_normalized(viewquat_inv, vod->viewquat);
 937
 938         mul_qt_v3(viewquat_inv, zaxis);
 939         normalize_v3(zaxis);
 940
 941
 942         for (x = -1; x < 2; x++) {
 943                 for (y = -1; y < 2; y++) {
 944                         for (z = -1; z < 2; z++) {
 945                                 if (x || y || z) {
 946                                         float zaxis_test[3] = {x, y, z};
 947
 948                                         normalize_v3(zaxis_test);
 949
 950                                         if (angle_normalized_v3v3(zaxis_test, zaxis) < axis_limit) {
 951                                                 copy_v3_v3(zaxis_best, zaxis_test);
 952                                                 found = true;
 953                                         }
 954                                 }
 955                         }
 956                 }
 957         }
 958
 959         if (found) {
 960
 961                 /* find the best roll */
 962                 float quat_roll[4], quat_final[4], quat_best[4], quat_snap[4];
 963                 float viewquat_align[4]; /* viewquat aligned to zaxis_best */
 964                 float viewquat_align_inv[4]; /* viewquat aligned to zaxis_best */
 965                 float best_angle = axis_limit;
 966                 int j;
 967
 968                 /* viewquat_align is the original viewquat aligned to the snapped axis
 969                  * for testing roll */
 970                 rotation_between_vecs_to_quat(viewquat_align, zaxis_best, zaxis);
 971                 normalize_qt(viewquat_align);
 972                 mul_qt_qtqt(viewquat_align, vod->viewquat, viewquat_align);
 973                 normalize_qt(viewquat_align);
 974                 invert_qt_qt_normalized(viewquat_align_inv, viewquat_align);
 975
 976                 vec_to_quat(quat_snap, zaxis_best, OB_NEGZ, OB_POSY);
 977                 normalize_qt(quat_snap);
 978                 invert_qt_normalized(quat_snap);
 979
 980                 /* check if we can find the roll */
 981                 found = false;
 982
 983                 /* find best roll */
 984                 for (j = 0; j < 8; j++) {
 985                         float angle;
 986                         float xaxis1[3] = {1, 0, 0};
 987                         float xaxis2[3] = {1, 0, 0};
 988                         float quat_final_inv[4];
 989
 990                         axis_angle_to_quat(quat_roll, zaxis_best, (float)j * DEG2RADF(45.0f));
 991                         normalize_qt(quat_roll);
 992
 993                         mul_qt_qtqt(quat_final, quat_snap, quat_roll);
 994                         normalize_qt(quat_final);
 995
 996                         /* compare 2 vector angles to find the least roll */
 997                         invert_qt_qt_normalized(quat_final_inv, quat_final);
 998                         mul_qt_v3(viewquat_align_inv, xaxis1);
 999                         mul_qt_v3(quat_final_inv, xaxis2);
1000                         angle = angle_v3v3(xaxis1, xaxis2);
1001
1002                         if (angle <= best_angle) {
1003                                 found = true;
1004                                 best_angle = angle;
1005                                 copy_qt_qt(quat_best, quat_final);
1006                         }
1007                 }
1008
1009                 if (found) {
1010                         /* lock 'quat_best' to an axis view if we can */
1011                         rv3d->view = ED_view3d_quat_to_axis_view(quat_best, 0.01f);
1012                         if (rv3d->view != RV3D_VIEW_USER) {
1013                                 ED_view3d_quat_from_axis_view(rv3d->view, quat_best);
1014                         }
1015                 }
1016                 else {
1017                         copy_qt_qt(quat_best, viewquat_align);
1018                 }
1019
1020                 copy_qt_qt(rv3d->viewquat, quat_best);
1021
1022                 viewrotate_apply_dyn_ofs(vod, rv3d->viewquat);
1023         }
1024 }
1025
1026 static void viewrotate_apply(ViewOpsData *vod, int x, int y)
1027 {
1028         RegionView3D *rv3d = vod->rv3d;
1029
1030         rv3d->view = RV3D_VIEW_USER; /* need to reset every time because of view snapping */
1031
1032         if (U.flag & USER_TRACKBALL) {
1033                 float axis[3], q1[4], dvec[3], newvec[3];
1034                 float angle;
1035
1036                 calctrackballvec(&vod->ar->winrct, x, y, newvec);
1037
1038                 sub_v3_v3v3(dvec, newvec, vod->trackvec);
1039
1040                 angle = (len_v3(dvec) / (2.0f * TRACKBALLSIZE)) * (float)M_PI;
1041
1042                 /* Allow for rotation beyond the interval [-pi, pi] */
1043                 angle = angle_wrap_rad(angle);
1044
1045                 /* This relation is used instead of the actual angle between vectors
1046                  * so that the angle of rotation is linearly proportional to
1047                  * the distance that the mouse is dragged. */
1048
1049                 cross_v3_v3v3(axis, vod->trackvec, newvec);
1050                 axis_angle_to_quat(q1, axis, angle);
1051
1052                 mul_qt_qtqt(vod->viewquat, q1, vod->oldquat);
1053
1054                 viewrotate_apply_dyn_ofs(vod, vod->viewquat);
1055         }
1056         else {
1057                 /* New turntable view code by John Aughey */
1058                 float quat_local_x[4], quat_global_z[4];
1059                 float m[3][3];
1060                 float m_inv[3][3];
1061                 const float zvec_global[3] = {0.0f, 0.0f, 1.0f};
1062                 float xaxis[3];
1063
1064                 /* Sensitivity will control how fast the viewport rotates.  0.007 was
1065                  * obtained experimentally by looking at viewport rotation sensitivities
1066                  * on other modeling programs. */
1067                 /* Perhaps this should be a configurable user parameter. */
1068                 const float sensitivity = 0.007f;
1069
1070                 /* Get the 3x3 matrix and its inverse from the quaternion */
1071                 quat_to_mat3(m, vod->viewquat);
1072                 invert_m3_m3(m_inv, m);
1073
1074                 /* avoid gimble lock */
1075 #if 1
1076                 if (len_squared_v3v3(zvec_global, m_inv[2]) > 0.001f) {
1077                         float fac;
1078                         cross_v3_v3v3(xaxis, zvec_global, m_inv[2]);
1079                         if (dot_v3v3(xaxis, m_inv[0]) < 0) {
1080                                 negate_v3(xaxis);
1081                         }
1082                         fac = angle_normalized_v3v3(zvec_global, m_inv[2]) / (float)M_PI;
1083                         fac = fabsf(fac - 0.5f) * 2;
1084                         fac = fac * fac;
1085                         interp_v3_v3v3(xaxis, xaxis, m_inv[0], fac);
1086                 }
1087                 else {
1088                         copy_v3_v3(xaxis, m_inv[0]);
1089                 }
1090 #else
1091                 copy_v3_v3(xaxis, m_inv[0]);
1092 #endif
1093
1094                 /* Determine the direction of the x vector (for rotating up and down) */
1095                 /* This can likely be computed directly from the quaternion. */
1096
1097                 /* Perform the up/down rotation */
1098                 axis_angle_to_quat(quat_local_x, xaxis, sensitivity * -(y - vod->oldy));
1099                 mul_qt_qtqt(quat_local_x, vod->viewquat, quat_local_x);
1100
1101                 /* Perform the orbital rotation */
1102                 axis_angle_to_quat_single(quat_global_z, 'Z', sensitivity * vod->reverse * (x - vod->oldx));
1103                 mul_qt_qtqt(vod->viewquat, quat_local_x, quat_global_z);
1104
1105                 viewrotate_apply_dyn_ofs(vod, vod->viewquat);
1106         }
1107
1108         /* avoid precision loss over time */
1109         normalize_qt(vod->viewquat);
1110
1111         /* use a working copy so view rotation locking doesnt overwrite the locked
1112          * rotation back into the view we calculate with */
1113         copy_qt_qt(rv3d->viewquat, vod->viewquat);
1114
1115         /* check for view snap,
1116          * note: don't apply snap to vod->viewquat so the view wont jam up */
1117         if (vod->axis_snap) {
1118                 viewrotate_apply_snap(vod);
1119         }
1120         vod->oldx = x;
1121         vod->oldy = y;
1122
1123         ED_view3d_camera_lock_sync(vod->v3d, rv3d);
1124
1125         ED_region_tag_redraw(vod->ar);
1126 }
1127
1128 static int viewrotate_modal(bContext *C, wmOperator *op, const wmEvent *event)
1129 {
1130         ViewOpsData *vod = op->customdata;
1131         short event_code = VIEW_PASS;
1132         bool use_autokey = false;
1133         int ret = OPERATOR_RUNNING_MODAL;
1134
1135         /* execute the events */
1136         if (event->type == MOUSEMOVE) {
1137                 event_code = VIEW_APPLY;
1138         }
1139         else if (event->type == EVT_MODAL_MAP) {
1140                 switch (event->val) {
1141                         case VIEW_MODAL_CONFIRM:
1142                                 event_code = VIEW_CONFIRM;
1143                                 break;
1144                         case VIEWROT_MODAL_AXIS_SNAP_ENABLE:
1145                                 vod->axis_snap = true;
1146                                 event_code = VIEW_APPLY;
1147                                 break;
1148                         case VIEWROT_MODAL_AXIS_SNAP_DISABLE:
1149                                 vod->axis_snap = false;
1150                                 event_code = VIEW_APPLY;
1151                                 break;
1152                         case VIEWROT_MODAL_SWITCH_ZOOM:
1153                                 WM_operator_name_call(C, "VIEW3D_OT_zoom", WM_OP_INVOKE_DEFAULT, NULL);
1154                                 event_code = VIEW_CONFIRM;
1155                                 break;
1156                         case VIEWROT_MODAL_SWITCH_MOVE:
1157                                 WM_operator_name_call(C, "VIEW3D_OT_move", WM_OP_INVOKE_DEFAULT, NULL);
1158                                 event_code = VIEW_CONFIRM;
1159                                 break;
1160                 }
1161         }
1162         else if (event->type == vod->origkey && event->val == KM_RELEASE) {
1163                 event_code = VIEW_CONFIRM;
1164         }
1165
1166         if (event_code == VIEW_APPLY) {
1167                 viewrotate_apply(vod, event->x, event->y);
1168                 if (ED_screen_animation_playing(CTX_wm_manager(C))) {
1169                         use_autokey = true;
1170                 }
1171         }
1172         else if (event_code == VIEW_CONFIRM) {
1173                 ED_view3d_depth_tag_update(vod->rv3d);
1174                 use_autokey = true;
1175                 ret = OPERATOR_FINISHED;
1176         }
1177
1178         if (use_autokey) {
1179                 ED_view3d_camera_lock_autokey(vod->v3d, vod->rv3d, C, true, true);
1180         }
1181
1182         if (ret & OPERATOR_FINISHED) {
1183                 viewops_data_free(C, op);
1184         }
1185
1186         return ret;
1187 }
1188
1189 /**
1190  * Action to take when rotating the view,
1191  * handle auto-persp and logic for switching out of views.
1192  *
1193  * shared with NDOF.
1194  */
1195 static bool view3d_ensure_persp(struct View3D *v3d, ARegion *ar)
1196 {
1197         RegionView3D *rv3d = ar->regiondata;
1198         const bool autopersp = (U.uiflag & USER_AUTOPERSP) != 0;
1199
1200         BLI_assert((rv3d->viewlock & RV3D_LOCKED) == 0);
1201
1202         if (ED_view3d_camera_lock_check(v3d, rv3d))
1203                 return false;
1204
1205         if (rv3d->persp != RV3D_PERSP) {
1206                 if (rv3d->persp == RV3D_CAMOB) {
1207                         /* If autopersp and previous view was an axis one, switch back to PERSP mode, else reuse previous mode. */
1208                         char persp = (autopersp && RV3D_VIEW_IS_AXIS(rv3d->lview)) ? RV3D_PERSP : rv3d->lpersp;
1209                         view3d_persp_switch_from_camera(v3d, rv3d, persp);
1210                 }
1211                 else if (autopersp && RV3D_VIEW_IS_AXIS(rv3d->view)) {
1212                         rv3d->persp = RV3D_PERSP;
1213                 }
1214                 return true;
1215         }
1216
1217         return false;
1218 }
1219
1220 static int viewrotate_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1221 {
1222         ViewOpsData *vod;
1223
1224         /* makes op->customdata */
1225         viewops_data_alloc(C, op);
1226         vod = op->customdata;
1227
1228         /* poll should check but in some cases fails, see poll func for details */
1229         if (vod->rv3d->viewlock & RV3D_LOCKED) {
1230                 viewops_data_free(C, op);
1231                 return OPERATOR_PASS_THROUGH;
1232         }
1233
1234         ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
1235
1236         /* switch from camera view when: */
1237         if (view3d_ensure_persp(vod->v3d, vod->ar)) {
1238                 /* If we're switching from camera view to the perspective one,
1239                  * need to tag viewport update, so camera vuew and borders
1240                  * are properly updated.
1241                  */
1242                 ED_region_tag_redraw(vod->ar);
1243         }
1244
1245         viewops_data_create(C, op, event);
1246
1247         if (ELEM(event->type, MOUSEPAN, MOUSEROTATE)) {
1248                 /* Rotate direction we keep always same */
1249                 int x, y;
1250
1251                 if (event->type == MOUSEPAN) {
1252                         if (U.uiflag2 & USER_TRACKPAD_NATURAL) {
1253                                 x = 2 * event->x - event->prevx;
1254                                 y = 2 * event->y - event->prevy;
1255                         }
1256                         else {
1257                                 x = event->prevx;
1258                                 y = event->prevy;
1259                         }
1260                 }
1261                 else {
1262                         /* MOUSEROTATE performs orbital rotation, so y axis delta is set to 0 */
1263                         x = event->prevx;
1264                         y = event->y;
1265                 }
1266
1267                 viewrotate_apply(vod, x, y);
1268                 ED_view3d_depth_tag_update(vod->rv3d);
1269
1270                 viewops_data_free(C, op);
1271
1272                 return OPERATOR_FINISHED;
1273         }
1274         else {
1275                 /* add temp handler */
1276                 WM_event_add_modal_handler(C, op);
1277
1278                 return OPERATOR_RUNNING_MODAL;
1279         }
1280 }
1281
1282 /* test for unlocked camera view in quad view */
1283 static int view3d_camera_user_poll(bContext *C)
1284 {
1285         View3D *v3d;
1286         ARegion *ar;
1287
1288         if (ED_view3d_context_user_region(C, &v3d, &ar)) {
1289                 RegionView3D *rv3d = ar->regiondata;
1290                 if (rv3d->persp == RV3D_CAMOB) {
1291                         return 1;
1292                 }
1293         }
1294
1295         return 0;
1296 }
1297
1298 static int view3d_lock_poll(bContext *C)
1299 {
1300         View3D *v3d = CTX_wm_view3d(C);
1301         if (v3d) {
1302                 RegionView3D *rv3d = CTX_wm_region_view3d(C);
1303                 if (rv3d) {
1304                         return ED_view3d_offset_lock_check(v3d, rv3d);
1305                 }
1306         }
1307         return false;
1308 }
1309
1310 static void viewrotate_cancel(bContext *C, wmOperator *op)
1311 {
1312         viewops_data_free(C, op);
1313 }
1314
1315 void VIEW3D_OT_rotate(wmOperatorType *ot)
1316 {
1317         /* identifiers */
1318         ot->name = "Rotate View";
1319         ot->description = "Rotate the view";
1320         ot->idname = "VIEW3D_OT_rotate";
1321
1322         /* api callbacks */
1323         ot->invoke = viewrotate_invoke;
1324         ot->modal = viewrotate_modal;
1325         ot->poll = ED_operator_region_view3d_active;
1326         ot->cancel = viewrotate_cancel;
1327
1328         /* flags */
1329         ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
1330 }
1331
1332 /** \name NDOF Utility Functions
1333  * \{ */
1334
1335 #define NDOF_HAS_TRANSLATE ((!ED_view3d_offset_lock_check(v3d, rv3d)) && !is_zero_v3(ndof->tvec))
1336 #define NDOF_HAS_ROTATE    (((rv3d->viewlock & RV3D_LOCKED) == 0) && !is_zero_v3(ndof->rvec))
1337
1338 /**
1339  * \param depth_pt: A point to calculate the depth (in perspective mode)
1340  */
1341 static float view3d_ndof_pan_speed_calc_ex(RegionView3D *rv3d, const float depth_pt[3])
1342 {
1343         float speed = rv3d->pixsize * NDOF_PIXELS_PER_SECOND;
1344
1345         if (rv3d->is_persp) {
1346                 speed *= ED_view3d_calc_zfac(rv3d, depth_pt, NULL);
1347         }
1348
1349         return speed;
1350 }
1351
1352 static float view3d_ndof_pan_speed_calc_from_dist(RegionView3D *rv3d, const float dist)
1353 {
1354         float viewinv[4];
1355         float tvec[3];
1356
1357         BLI_assert(dist >= 0.0f);
1358
1359         copy_v3_fl3(tvec, 0.0f, 0.0f, dist);
1360         /* rv3d->viewinv isn't always valid */
1361 #if 0
1362         mul_mat3_m4_v3(rv3d->viewinv, tvec);
1363 #else
1364         invert_qt_qt_normalized(viewinv, rv3d->viewquat);
1365         mul_qt_v3(viewinv, tvec);
1366 #endif
1367
1368         return view3d_ndof_pan_speed_calc_ex(rv3d, tvec);
1369 }
1370
1371 static float view3d_ndof_pan_speed_calc(RegionView3D *rv3d)
1372 {
1373         float tvec[3];
1374         negate_v3_v3(tvec, rv3d->ofs);
1375
1376         return view3d_ndof_pan_speed_calc_ex(rv3d, tvec);
1377 }
1378
1379 /**
1380  * Zoom and pan in the same function since sometimes zoom is interpreted as dolly (pan forward).
1381  *
1382  * \param has_zoom zoom, otherwise dolly, often `!rv3d->is_persp` since it doesnt make sense to dolly in ortho.
1383  */
1384 static void view3d_ndof_pan_zoom(const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
1385                                  const bool has_translate, const bool has_zoom)
1386 {
1387         RegionView3D *rv3d = ar->regiondata;
1388         float view_inv[4];
1389         float pan_vec[3];
1390
1391         if (has_translate == false && has_zoom == false) {
1392                 return;
1393         }
1394
1395         WM_event_ndof_pan_get(ndof, pan_vec, false);
1396
1397         if (has_zoom) {
1398                 /* zoom with Z */
1399
1400                 /* Zoom!
1401                  * velocity should be proportional to the linear velocity attained by rotational motion of same strength
1402                  * [got that?]
1403                  * proportional to arclength = radius * angle
1404                  */
1405
1406                 pan_vec[2] = 0.0f;
1407
1408                 /* "zoom in" or "translate"? depends on zoom mode in user settings? */
1409                 if (ndof->tvec[2]) {
1410                         float zoom_distance = rv3d->dist * ndof->dt * ndof->tvec[2];
1411
1412                         if (U.ndof_flag & NDOF_ZOOM_INVERT)
1413                                 zoom_distance = -zoom_distance;
1414
1415                         rv3d->dist += zoom_distance;
1416                 }
1417         }
1418         else {
1419                 /* dolly with Z */
1420
1421                 /* all callers must check */
1422                 if (has_translate) {
1423                         BLI_assert(ED_view3d_offset_lock_check((View3D *)sa->spacedata.first, rv3d) == false);
1424                 }
1425         }
1426
1427         if (has_translate) {
1428                 const float speed = view3d_ndof_pan_speed_calc(rv3d);
1429
1430                 mul_v3_fl(pan_vec, speed * ndof->dt);
1431
1432                 /* transform motion from view to world coordinates */
1433                 invert_qt_qt_normalized(view_inv, rv3d->viewquat);
1434                 mul_qt_v3(view_inv, pan_vec);
1435
1436                 /* move center of view opposite of hand motion (this is camera mode, not object mode) */
1437                 sub_v3_v3(rv3d->ofs, pan_vec);
1438
1439                 if (rv3d->viewlock & RV3D_BOXVIEW) {
1440                         view3d_boxview_sync(sa, ar);
1441                 }
1442         }
1443 }
1444
1445
1446 static void view3d_ndof_orbit(const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
1447                               /* optional, can be NULL*/
1448                               ViewOpsData *vod)
1449 {
1450         View3D *v3d = sa->spacedata.first;
1451         RegionView3D *rv3d = ar->regiondata;
1452
1453         float view_inv[4];
1454
1455         BLI_assert((rv3d->viewlock & RV3D_LOCKED) == 0);
1456
1457         view3d_ensure_persp(v3d, ar);
1458
1459         rv3d->view = RV3D_VIEW_USER;
1460
1461         invert_qt_qt_normalized(view_inv, rv3d->viewquat);
1462
1463         if (U.ndof_flag & NDOF_TURNTABLE) {
1464                 float rot[3];
1465
1466                 /* turntable view code by John Aughey, adapted for 3D mouse by [mce] */
1467                 float angle, quat[4];
1468                 float xvec[3] = {1, 0, 0};
1469
1470                 /* only use XY, ignore Z */
1471                 WM_event_ndof_rotate_get(ndof, rot);
1472
1473                 /* Determine the direction of the x vector (for rotating up and down) */
1474                 mul_qt_v3(view_inv, xvec);
1475
1476                 /* Perform the up/down rotation */
1477                 angle = ndof->dt * rot[0];
1478                 axis_angle_to_quat(quat, xvec, angle);
1479                 mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, quat);
1480
1481                 /* Perform the orbital rotation */
1482                 angle = ndof->dt * rot[1];
1483
1484                 /* update the onscreen doo-dad */
1485                 rv3d->rot_angle = angle;
1486                 rv3d->rot_axis[0] = 0;
1487                 rv3d->rot_axis[1] = 0;
1488                 rv3d->rot_axis[2] = 1;
1489
1490                 axis_angle_to_quat_single(quat, 'Z', angle);
1491                 mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, quat);
1492
1493         }
1494         else {
1495                 float quat[4];
1496                 float axis[3];
1497                 float angle = WM_event_ndof_to_axis_angle(ndof, axis);
1498
1499                 /* transform rotation axis from view to world coordinates */
1500                 mul_qt_v3(view_inv, axis);
1501
1502                 /* update the onscreen doo-dad */
1503                 rv3d->rot_angle = angle;
1504                 copy_v3_v3(rv3d->rot_axis, axis);
1505
1506                 axis_angle_to_quat(quat, axis, angle);
1507
1508                 /* apply rotation */
1509                 mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, quat);
1510         }
1511
1512         if (vod) {
1513                 viewrotate_apply_dyn_ofs(vod, rv3d->viewquat);
1514         }
1515 }
1516
1517 /**
1518  * Called from both fly mode and walk mode,
1519  */
1520 void view3d_ndof_fly(
1521         const wmNDOFMotionData *ndof,
1522         View3D *v3d, RegionView3D *rv3d,
1523         const bool use_precision, const short protectflag,
1524         bool *r_has_translate, bool *r_has_rotate)
1525 {
1526         bool has_translate = NDOF_HAS_TRANSLATE;
1527         bool has_rotate = NDOF_HAS_ROTATE;
1528
1529         float view_inv[4];
1530         invert_qt_qt_normalized(view_inv, rv3d->viewquat);
1531
1532         rv3d->rot_angle = 0.0f;  /* disable onscreen rotation doo-dad */
1533
1534         if (has_translate) {
1535                 /* ignore real 'dist' since fly has its own speed settings,
1536                  * also its overwritten at this point. */
1537                 float speed = view3d_ndof_pan_speed_calc_from_dist(rv3d, 1.0f);
1538                 float trans[3], trans_orig_y;
1539
1540                 if (use_precision)
1541                         speed *= 0.2f;
1542
1543                 WM_event_ndof_pan_get(ndof, trans, false);
1544                 mul_v3_fl(trans, speed * ndof->dt);
1545                 trans_orig_y = trans[1];
1546
1547                 if (U.ndof_flag & NDOF_FLY_HELICOPTER) {
1548                         trans[1] = 0.0f;
1549                 }
1550
1551                 /* transform motion from view to world coordinates */
1552                 mul_qt_v3(view_inv, trans);
1553
1554                 if (U.ndof_flag & NDOF_FLY_HELICOPTER) {
1555                         /* replace world z component with device y (yes it makes sense) */
1556                         trans[2] = trans_orig_y;
1557                 }
1558
1559                 if (rv3d->persp == RV3D_CAMOB) {
1560                         /* respect camera position locks */
1561                         if (protectflag & OB_LOCK_LOCX) trans[0] = 0.0f;
1562                         if (protectflag & OB_LOCK_LOCY) trans[1] = 0.0f;
1563                         if (protectflag & OB_LOCK_LOCZ) trans[2] = 0.0f;
1564                 }
1565
1566                 if (!is_zero_v3(trans)) {
1567                         /* move center of view opposite of hand motion (this is camera mode, not object mode) */
1568                         sub_v3_v3(rv3d->ofs, trans);
1569                         has_translate = true;
1570                 }
1571                 else {
1572                         has_translate = false;
1573                 }
1574         }
1575
1576         if (has_rotate) {
1577                 const float turn_sensitivity = 1.0f;
1578
1579                 float rotation[4];
1580                 float axis[3];
1581                 float angle = turn_sensitivity * WM_event_ndof_to_axis_angle(ndof, axis);
1582
1583                 if (fabsf(angle) > 0.0001f) {
1584                         has_rotate = true;
1585
1586                         if (use_precision)
1587                                 angle *= 0.2f;
1588
1589                         /* transform rotation axis from view to world coordinates */
1590                         mul_qt_v3(view_inv, axis);
1591
1592                         /* apply rotation to view */
1593                         axis_angle_to_quat(rotation, axis, angle);
1594                         mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, rotation);
1595
1596                         if (U.ndof_flag & NDOF_LOCK_HORIZON) {
1597                                 /* force an upright viewpoint
1598                                  * TODO: make this less... sudden */
1599                                 float view_horizon[3] = {1.0f, 0.0f, 0.0f}; /* view +x */
1600                                 float view_direction[3] = {0.0f, 0.0f, -1.0f}; /* view -z (into screen) */
1601
1602                                 /* find new inverse since viewquat has changed */
1603                                 invert_qt_qt_normalized(view_inv, rv3d->viewquat);
1604                                 /* could apply reverse rotation to existing view_inv to save a few cycles */
1605
1606                                 /* transform view vectors to world coordinates */
1607                                 mul_qt_v3(view_inv, view_horizon);
1608                                 mul_qt_v3(view_inv, view_direction);
1609
1610
1611                                 /* find difference between view & world horizons
1612                                  * true horizon lives in world xy plane, so look only at difference in z */
1613                                 angle = -asinf(view_horizon[2]);
1614
1615                                 /* rotate view so view horizon = world horizon */
1616                                 axis_angle_to_quat(rotation, view_direction, angle);
1617                                 mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, rotation);
1618                         }
1619
1620                         rv3d->view = RV3D_VIEW_USER;
1621                 }
1622                 else {
1623                         has_rotate = false;
1624                 }
1625         }
1626
1627         *r_has_translate = has_translate;
1628         *r_has_rotate    = has_rotate;
1629 }
1630
1631 /** \} */
1632
1633
1634 /* -- "orbit" navigation (trackball/turntable)
1635  * -- zooming
1636  * -- panning in rotationally-locked views
1637  */
1638 static int ndof_orbit_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1639 {
1640
1641         if (event->type != NDOF_MOTION) {
1642                 return OPERATOR_CANCELLED;
1643         }
1644         else {
1645                 ViewOpsData *vod;
1646                 View3D *v3d;
1647                 RegionView3D *rv3d;
1648
1649                 const wmNDOFMotionData *ndof = event->customdata;
1650
1651                 viewops_data_alloc(C, op);
1652                 viewops_data_create_ex(C, op, event,
1653                                        (U.uiflag & USER_ORBIT_SELECTION) != 0, false);
1654                 vod = op->customdata;
1655
1656                 ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
1657
1658                 v3d = vod->v3d;
1659                 rv3d = vod->rv3d;
1660
1661                 /* off by default, until changed later this function */
1662                 rv3d->rot_angle = 0.0f;
1663
1664                 ED_view3d_camera_lock_init_ex(v3d, rv3d, false);
1665
1666                 if (ndof->progress != P_FINISHING) {
1667                         const bool has_rotation = NDOF_HAS_ROTATE;
1668                         /* if we can't rotate, fallback to translate (locked axis views) */
1669                         const bool has_translate = NDOF_HAS_TRANSLATE && (rv3d->viewlock & RV3D_LOCKED);
1670                         const bool has_zoom = (ndof->tvec[2] != 0.0f) && !rv3d->is_persp;
1671
1672                         if (has_translate || has_zoom) {
1673                                 view3d_ndof_pan_zoom(ndof, vod->sa, vod->ar, has_translate, has_zoom);
1674                         }
1675
1676                         if (has_rotation) {
1677                                 view3d_ndof_orbit(ndof, vod->sa, vod->ar, vod);
1678                         }
1679                 }
1680
1681                 ED_view3d_camera_lock_sync(v3d, rv3d);
1682
1683                 ED_region_tag_redraw(vod->ar);
1684
1685                 viewops_data_free(C, op);
1686
1687                 return OPERATOR_FINISHED;
1688         }
1689 }
1690
1691 void VIEW3D_OT_ndof_orbit(struct wmOperatorType *ot)
1692 {
1693         /* identifiers */
1694         ot->name = "NDOF Orbit View";
1695         ot->description = "Orbit the view using the 3D mouse";
1696         ot->idname = "VIEW3D_OT_ndof_orbit";
1697
1698         /* api callbacks */
1699         ot->invoke = ndof_orbit_invoke;
1700         ot->poll = ED_operator_view3d_active;
1701
1702         /* flags */
1703         ot->flag = 0;
1704 }
1705
1706 static int ndof_orbit_zoom_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1707 {
1708
1709         if (event->type != NDOF_MOTION) {
1710                 return OPERATOR_CANCELLED;
1711         }
1712         else {
1713                 ViewOpsData *vod;
1714                 View3D *v3d;
1715                 RegionView3D *rv3d;
1716
1717                 const wmNDOFMotionData *ndof = event->customdata;
1718
1719                 viewops_data_alloc(C, op);
1720                 viewops_data_create_ex(C, op, event,
1721                                        (U.uiflag & USER_ORBIT_SELECTION) != 0, false);
1722
1723                 vod = op->customdata;
1724
1725                 ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
1726
1727                 v3d = vod->v3d;
1728                 rv3d = vod->rv3d;
1729
1730                 /* off by default, until changed later this function */
1731                 rv3d->rot_angle = 0.0f;
1732
1733                 ED_view3d_camera_lock_init_ex(v3d, rv3d, false);
1734
1735                 if (ndof->progress == P_FINISHING) {
1736                         /* pass */
1737                 }
1738                 else if ((rv3d->persp == RV3D_ORTHO) && RV3D_VIEW_IS_AXIS(rv3d->view)) {
1739                         /* if we can't rotate, fallback to translate (locked axis views) */
1740                         const bool has_translate = NDOF_HAS_TRANSLATE;
1741                         const bool has_zoom = (ndof->tvec[2] != 0.0f) && ED_view3d_offset_lock_check(v3d, rv3d);
1742
1743                         if (has_translate || has_zoom) {
1744                                 view3d_ndof_pan_zoom(ndof, vod->sa, vod->ar, has_translate, true);
1745                         }
1746                 }
1747                 else if ((U.ndof_flag & NDOF_MODE_ORBIT) ||
1748                          ED_view3d_offset_lock_check(v3d, rv3d))
1749                 {
1750                         const bool has_rotation = NDOF_HAS_ROTATE;
1751                         const bool has_zoom = (ndof->tvec[2] != 0.0f);
1752
1753                         if (has_zoom) {
1754                                 view3d_ndof_pan_zoom(ndof, vod->sa, vod->ar, false, has_zoom);
1755                         }
1756
1757                         if (has_rotation) {
1758                                 view3d_ndof_orbit(ndof, vod->sa, vod->ar, vod);
1759                         }
1760                 }
1761                 else {  /* free/explore (like fly mode) */
1762                         const bool has_rotation = NDOF_HAS_ROTATE;
1763                         const bool has_translate = NDOF_HAS_TRANSLATE;
1764                         const bool has_zoom = (ndof->tvec[2] != 0.0f) && !rv3d->is_persp;
1765
1766                         float dist_backup;
1767
1768                         if (has_translate || has_zoom) {
1769                                 view3d_ndof_pan_zoom(ndof, vod->sa, vod->ar, has_translate, has_zoom);
1770                         }
1771
1772                         dist_backup = rv3d->dist;
1773                         ED_view3d_distance_set(rv3d, 0.0f);
1774
1775                         if (has_rotation) {
1776                                 view3d_ndof_orbit(ndof, vod->sa, vod->ar, NULL);
1777                         }
1778
1779                         ED_view3d_distance_set(rv3d, dist_backup);
1780                 }
1781
1782                 ED_view3d_camera_lock_sync(v3d, rv3d);
1783
1784                 ED_region_tag_redraw(vod->ar);
1785
1786                 viewops_data_free(C, op);
1787
1788                 return OPERATOR_FINISHED;
1789         }
1790 }
1791
1792 void VIEW3D_OT_ndof_orbit_zoom(struct wmOperatorType *ot)
1793 {
1794         /* identifiers */
1795         ot->name = "NDOF Orbit View with Zoom";
1796         ot->description = "Orbit and zoom the view using the 3D mouse";
1797         ot->idname = "VIEW3D_OT_ndof_orbit_zoom";
1798
1799         /* api callbacks */
1800         ot->invoke = ndof_orbit_zoom_invoke;
1801         ot->poll = ED_operator_view3d_active;
1802
1803         /* flags */
1804         ot->flag = 0;
1805 }
1806
1807 /* -- "pan" navigation
1808  * -- zoom or dolly?
1809  */
1810 static int ndof_pan_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *event)
1811 {
1812         if (event->type != NDOF_MOTION) {
1813                 return OPERATOR_CANCELLED;
1814         }
1815         else {
1816                 View3D *v3d = CTX_wm_view3d(C);
1817                 RegionView3D *rv3d = CTX_wm_region_view3d(C);
1818                 const wmNDOFMotionData *ndof = event->customdata;
1819
1820                 const bool has_translate = NDOF_HAS_TRANSLATE;
1821                 const bool has_zoom = (ndof->tvec[2] != 0.0f) && !rv3d->is_persp;
1822
1823                 /* we're panning here! so erase any leftover rotation from other operators */
1824                 rv3d->rot_angle = 0.0f;
1825
1826                 if (!(has_translate || has_zoom))
1827                         return OPERATOR_CANCELLED;
1828
1829                 ED_view3d_camera_lock_init_ex(v3d, rv3d, false);
1830
1831                 if (ndof->progress != P_FINISHING) {
1832                         ScrArea *sa = CTX_wm_area(C);
1833                         ARegion *ar = CTX_wm_region(C);
1834
1835                         if (has_translate || has_zoom) {
1836                                 view3d_ndof_pan_zoom(ndof, sa, ar, has_translate, has_zoom);
1837                         }
1838                 }
1839
1840                 ED_view3d_camera_lock_sync(v3d, rv3d);
1841
1842                 ED_region_tag_redraw(CTX_wm_region(C));
1843
1844                 return OPERATOR_FINISHED;
1845         }
1846 }
1847
1848 void VIEW3D_OT_ndof_pan(struct wmOperatorType *ot)
1849 {
1850         /* identifiers */
1851         ot->name = "NDOF Pan View";
1852         ot->description = "Pan the view with the 3D mouse";
1853         ot->idname = "VIEW3D_OT_ndof_pan";
1854
1855         /* api callbacks */
1856         ot->invoke = ndof_pan_invoke;
1857         ot->poll = ED_operator_view3d_active;
1858
1859         /* flags */
1860         ot->flag = 0;
1861 }
1862
1863
1864 /**
1865  * wraps #ndof_orbit_zoom but never restrict to orbit.
1866  */
1867 static int ndof_all_invoke(bContext *C, wmOperator *op, const wmEvent *event)
1868 {
1869         /* weak!, but it works */
1870         const int ndof_flag = U.ndof_flag;
1871         int ret;
1872
1873         U.ndof_flag &= ~NDOF_MODE_ORBIT;
1874
1875         ret = ndof_orbit_zoom_invoke(C, op, event);
1876
1877         U.ndof_flag = ndof_flag;
1878
1879         return ret;
1880 }
1881
1882 void VIEW3D_OT_ndof_all(struct wmOperatorType *ot)
1883 {
1884         /* identifiers */
1885         ot->name = "NDOF Move View";
1886         ot->description = "Pan and rotate the view with the 3D mouse";
1887         ot->idname = "VIEW3D_OT_ndof_all";
1888
1889         /* api callbacks */
1890         ot->invoke = ndof_all_invoke;
1891         ot->poll = ED_operator_view3d_active;
1892
1893         /* flags */
1894         ot->flag = 0;
1895 }
1896
1897 /* ************************ viewmove ******************************** */
1898
1899
1900 /* NOTE: these defines are saved in keymap files, do not change values but just add new ones */
1901
1902 /* called in transform_ops.c, on each regeneration of keymaps  */
1903 void viewmove_modal_keymap(wmKeyConfig *keyconf)
1904 {
1905         static EnumPropertyItem modal_items[] = {
1906                 {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
1907
1908                 {VIEWROT_MODAL_SWITCH_ZOOM, "SWITCH_TO_ZOOM", 0, "Switch to Zoom"},
1909                 {VIEWROT_MODAL_SWITCH_ROTATE, "SWITCH_TO_ROTATE", 0, "Switch to Rotate"},
1910
1911                 {0, NULL, 0, NULL, NULL}
1912         };
1913
1914         wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Move Modal");
1915
1916         /* this function is called for each spacetype, only needs to add map once */
1917         if (keymap && keymap->modal_items) return;
1918
1919         keymap = WM_modalkeymap_add(keyconf, "View3D Move Modal", modal_items);
1920
1921         /* items for modal map */
1922         WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
1923         WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
1924
1925         /* disabled mode switching for now, can re-implement better, later on */
1926 #if 0
1927         WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
1928         WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ZOOM);
1929         WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
1930 #endif
1931
1932         /* assign map to operators */
1933         WM_modalkeymap_assign(keymap, "VIEW3D_OT_move");
1934 }
1935
1936
1937 static void viewmove_apply(ViewOpsData *vod, int x, int y)
1938 {
1939         if (ED_view3d_offset_lock_check(vod->v3d, vod->rv3d)) {
1940                 vod->rv3d->ofs_lock[0] -= ((vod->oldx - x) * 2.0f) / (float)vod->ar->winx;
1941                 vod->rv3d->ofs_lock[1] -= ((vod->oldy - y) * 2.0f) / (float)vod->ar->winy;
1942         }
1943         else if ((vod->rv3d->persp == RV3D_CAMOB) && !ED_view3d_camera_lock_check(vod->v3d, vod->rv3d)) {
1944                 const float zoomfac = BKE_screen_view3d_zoom_to_fac(vod->rv3d->camzoom) * 2.0f;
1945                 vod->rv3d->camdx += (vod->oldx - x) / (vod->ar->winx * zoomfac);
1946                 vod->rv3d->camdy += (vod->oldy - y) / (vod->ar->winy * zoomfac);
1947                 CLAMP(vod->rv3d->camdx, -1.0f, 1.0f);
1948                 CLAMP(vod->rv3d->camdy, -1.0f, 1.0f);
1949         }
1950         else {
1951                 float dvec[3];
1952                 float mval_f[2];
1953
1954                 mval_f[0] = x - vod->oldx;
1955                 mval_f[1] = y - vod->oldy;
1956                 ED_view3d_win_to_delta(vod->ar, mval_f, dvec, vod->zfac);
1957
1958                 add_v3_v3(vod->rv3d->ofs, dvec);
1959
1960                 if (vod->rv3d->viewlock & RV3D_BOXVIEW)
1961                         view3d_boxview_sync(vod->sa, vod->ar);
1962         }
1963
1964         vod->oldx = x;
1965         vod->oldy = y;
1966
1967         ED_view3d_camera_lock_sync(vod->v3d, vod->rv3d);
1968
1969         ED_region_tag_redraw(vod->ar);
1970 }
1971
1972
1973 static int viewmove_modal(bContext *C, wmOperator *op, const wmEvent *event)
1974 {
1975
1976         ViewOpsData *vod = op->customdata;
1977         short event_code = VIEW_PASS;
1978         bool use_autokey = false;
1979         int ret = OPERATOR_RUNNING_MODAL;
1980
1981         /* execute the events */
1982         if (event->type == MOUSEMOVE) {
1983                 event_code = VIEW_APPLY;
1984         }
1985         else if (event->type == EVT_MODAL_MAP) {
1986                 switch (event->val) {
1987                         case VIEW_MODAL_CONFIRM:
1988                                 event_code = VIEW_CONFIRM;
1989                                 break;
1990                         case VIEWROT_MODAL_SWITCH_ZOOM:
1991                                 WM_operator_name_call(C, "VIEW3D_OT_zoom", WM_OP_INVOKE_DEFAULT, NULL);
1992                                 event_code = VIEW_CONFIRM;
1993                                 break;
1994                         case VIEWROT_MODAL_SWITCH_ROTATE:
1995                                 WM_operator_name_call(C, "VIEW3D_OT_rotate", WM_OP_INVOKE_DEFAULT, NULL);
1996                                 event_code = VIEW_CONFIRM;
1997                                 break;
1998                 }
1999         }
2000         else if (event->type == vod->origkey && event->val == KM_RELEASE) {
2001                 event_code = VIEW_CONFIRM;
2002         }
2003
2004         if (event_code == VIEW_APPLY) {
2005                 viewmove_apply(vod, event->x, event->y);
2006                 if (ED_screen_animation_playing(CTX_wm_manager(C))) {
2007                         use_autokey = true;
2008                 }
2009         }
2010         else if (event_code == VIEW_CONFIRM) {
2011                 ED_view3d_depth_tag_update(vod->rv3d);
2012                 use_autokey = true;
2013                 ret = OPERATOR_FINISHED;
2014         }
2015
2016         if (use_autokey) {
2017                 ED_view3d_camera_lock_autokey(vod->v3d, vod->rv3d, C, false, true);
2018         }
2019
2020         if (ret & OPERATOR_FINISHED) {
2021                 viewops_data_free(C, op);
2022         }
2023
2024         return ret;
2025 }
2026
2027 static int viewmove_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2028 {
2029         ViewOpsData *vod;
2030
2031         /* makes op->customdata */
2032         viewops_data_alloc(C, op);
2033         viewops_data_create(C, op, event);
2034         vod = op->customdata;
2035
2036         ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
2037
2038         if (event->type == MOUSEPAN) {
2039                 /* invert it, trackpad scroll follows same principle as 2d windows this way */
2040                 viewmove_apply(vod, 2 * event->x - event->prevx, 2 * event->y - event->prevy);
2041                 ED_view3d_depth_tag_update(vod->rv3d);
2042
2043                 viewops_data_free(C, op);
2044
2045                 return OPERATOR_FINISHED;
2046         }
2047         else {
2048                 /* add temp handler */
2049                 WM_event_add_modal_handler(C, op);
2050
2051                 return OPERATOR_RUNNING_MODAL;
2052         }
2053 }
2054
2055 static void viewmove_cancel(bContext *C, wmOperator *op)
2056 {
2057         viewops_data_free(C, op);
2058 }
2059
2060 void VIEW3D_OT_move(wmOperatorType *ot)
2061 {
2062
2063         /* identifiers */
2064         ot->name = "Move View";
2065         ot->description = "Move the view";
2066         ot->idname = "VIEW3D_OT_move";
2067
2068         /* api callbacks */
2069         ot->invoke = viewmove_invoke;
2070         ot->modal = viewmove_modal;
2071         ot->poll = ED_operator_view3d_active;
2072         ot->cancel = viewmove_cancel;
2073
2074         /* flags */
2075         ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
2076 }
2077
2078 /* ************************ viewzoom ******************************** */
2079
2080 /* viewdolly_modal_keymap has an exact copy of this, apply fixes to both */
2081 /* called in transform_ops.c, on each regeneration of keymaps  */
2082 void viewzoom_modal_keymap(wmKeyConfig *keyconf)
2083 {
2084         static EnumPropertyItem modal_items[] = {
2085                 {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
2086
2087                 {VIEWROT_MODAL_SWITCH_ROTATE, "SWITCH_TO_ROTATE", 0, "Switch to Rotate"},
2088                 {VIEWROT_MODAL_SWITCH_MOVE, "SWITCH_TO_MOVE", 0, "Switch to Move"},
2089
2090                 {0, NULL, 0, NULL, NULL}
2091         };
2092
2093         wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Zoom Modal");
2094
2095         /* this function is called for each spacetype, only needs to add map once */
2096         if (keymap && keymap->modal_items) return;
2097
2098         keymap = WM_modalkeymap_add(keyconf, "View3D Zoom Modal", modal_items);
2099
2100         /* items for modal map */
2101         WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
2102         WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
2103
2104         /* disabled mode switching for now, can re-implement better, later on */
2105 #if 0
2106         WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
2107         WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
2108         WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
2109 #endif
2110
2111         /* assign map to operators */
2112         WM_modalkeymap_assign(keymap, "VIEW3D_OT_zoom");
2113 }
2114
2115 static void view_zoom_mouseloc_camera(
2116         Scene *scene, View3D *v3d,
2117         ARegion *ar, float dfac, int mx, int my)
2118 {
2119         RegionView3D *rv3d = ar->regiondata;
2120         const float zoomfac = BKE_screen_view3d_zoom_to_fac(rv3d->camzoom);
2121         const float zoomfac_new = CLAMPIS(zoomfac * (1.0f / dfac), RV3D_CAMZOOM_MIN_FACTOR, RV3D_CAMZOOM_MAX_FACTOR);
2122         const float camzoom_new = BKE_screen_view3d_zoom_from_fac(zoomfac_new);
2123
2124
2125         if (U.uiflag & USER_ZOOM_TO_MOUSEPOS) {
2126                 float zoomfac_px;
2127                 rctf camera_frame_old;
2128                 rctf camera_frame_new;
2129
2130                 const float pt_src[2] = {mx, my};
2131                 float pt_dst[2];
2132                 float delta_px[2];
2133
2134                 ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &camera_frame_old, false);
2135                 BLI_rctf_translate(&camera_frame_old, ar->winrct.xmin, ar->winrct.ymin);
2136
2137                 rv3d->camzoom = camzoom_new;
2138                 CLAMP(rv3d->camzoom, RV3D_CAMZOOM_MIN, RV3D_CAMZOOM_MAX);
2139
2140                 ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &camera_frame_new, false);
2141                 BLI_rctf_translate(&camera_frame_new, ar->winrct.xmin, ar->winrct.ymin);
2142
2143                 BLI_rctf_transform_pt_v(&camera_frame_new, &camera_frame_old, pt_dst, pt_src);
2144                 sub_v2_v2v2(delta_px, pt_dst, pt_src);
2145
2146                 /* translate the camera offset using pixel space delta
2147                  * mapped back to the camera (same logic as panning in camera view) */
2148                 zoomfac_px = BKE_screen_view3d_zoom_to_fac(rv3d->camzoom) * 2.0f;
2149
2150                 rv3d->camdx += delta_px[0] / (ar->winx * zoomfac_px);
2151                 rv3d->camdy += delta_px[1] / (ar->winy * zoomfac_px);
2152                 CLAMP(rv3d->camdx, -1.0f, 1.0f);
2153                 CLAMP(rv3d->camdy, -1.0f, 1.0f);
2154         }
2155         else {
2156                 rv3d->camzoom = camzoom_new;
2157                 CLAMP(rv3d->camzoom, RV3D_CAMZOOM_MIN, RV3D_CAMZOOM_MAX);
2158         }
2159 }
2160
2161 static void view_zoom_mouseloc_3d(ARegion *ar, float dfac, int mx, int my)
2162 {
2163         RegionView3D *rv3d = ar->regiondata;
2164         const float dist_new = rv3d->dist * dfac;
2165
2166         if (U.uiflag & USER_ZOOM_TO_MOUSEPOS) {
2167                 float dvec[3];
2168                 float tvec[3];
2169                 float tpos[3];
2170                 float mval_f[2];
2171
2172                 float zfac;
2173
2174                 negate_v3_v3(tpos, rv3d->ofs);
2175
2176                 mval_f[0] = (float)(((mx - ar->winrct.xmin) * 2) - ar->winx) / 2.0f;
2177                 mval_f[1] = (float)(((my - ar->winrct.ymin) * 2) - ar->winy) / 2.0f;
2178
2179                 /* Project cursor position into 3D space */
2180                 zfac = ED_view3d_calc_zfac(rv3d, tpos, NULL);
2181                 ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
2182
2183                 /* Calculate view target position for dolly */
2184                 add_v3_v3v3(tvec, tpos, dvec);
2185                 negate_v3(tvec);
2186
2187                 /* Offset to target position and dolly */
2188                 copy_v3_v3(rv3d->ofs, tvec);
2189                 rv3d->dist = dist_new;
2190
2191                 /* Calculate final offset */
2192                 madd_v3_v3v3fl(rv3d->ofs, tvec, dvec, dfac);
2193         }
2194         else {
2195                 rv3d->dist = dist_new;
2196         }
2197 }
2198
2199 static float viewzoom_scale_value(
2200         const rcti *winrct,
2201         const short viewzoom,
2202         const bool zoom_invert, const bool zoom_invert_force,
2203         const int xy[2], const int xy_orig[2],
2204         const float val, const float val_orig,
2205         double *r_timer_lastdraw)
2206 {
2207         float zfac;
2208
2209         if (viewzoom == USER_ZOOM_CONT) {
2210                 double time = PIL_check_seconds_timer();
2211                 float time_step = (float)(time - *r_timer_lastdraw);
2212                 float fac;
2213
2214                 if (U.uiflag & USER_ZOOM_HORIZ) {
2215                         fac = (float)(xy_orig[0] - xy[0]);
2216                 }
2217                 else {
2218                         fac = (float)(xy_orig[1] - xy[1]);
2219                 }
2220
2221                 if (zoom_invert != zoom_invert_force) {
2222                         fac = -fac;
2223                 }
2224
2225                 /* oldstyle zoom */
2226                 zfac = 1.0f + ((fac / 20.0f) * time_step);
2227                 *r_timer_lastdraw = time;
2228         }
2229         else if (viewzoom == USER_ZOOM_SCALE) {
2230                 /* method which zooms based on how far you move the mouse */
2231
2232                 const int ctr[2] = {
2233                     BLI_rcti_cent_x(winrct),
2234                     BLI_rcti_cent_y(winrct),
2235                 };
2236                 float len_new = 5 + len_v2v2_int(ctr, xy);
2237                 float len_old = 5 + len_v2v2_int(ctr, xy_orig);
2238
2239                 /* intentionally ignore 'zoom_invert' for scale */
2240                 if (zoom_invert_force) {
2241                         SWAP(float, len_new, len_old);
2242                 }
2243
2244                 zfac = val_orig * (len_old / max_ff(len_new, 1.0f)) / val;
2245         }
2246         else {  /* USER_ZOOM_DOLLY */
2247                 float len_new = 5;
2248                 float len_old = 5;
2249
2250                 if (U.uiflag & USER_ZOOM_HORIZ) {
2251                         len_new += (winrct->xmax - xy[0]);
2252                         len_old += (winrct->xmax - xy_orig[0]);
2253                 }
2254                 else {
2255                         len_new += (winrct->ymax - xy[1]);
2256                         len_old += (winrct->ymax - xy_orig[1]);
2257                 }
2258
2259                 if (zoom_invert != zoom_invert_force) {
2260                         SWAP(float, len_new, len_old);
2261                 }
2262
2263                 zfac = val_orig * (2.0f * ((len_new / max_ff(len_old, 1.0f)) - 1.0f) + 1.0f) / val;
2264         }
2265
2266
2267         return zfac;
2268 }
2269
2270 static void viewzoom_apply_camera(
2271         ViewOpsData *vod, const int xy[2],
2272         const short viewzoom, const bool zoom_invert)
2273 {
2274         float zfac;
2275         float zoomfac_prev = BKE_screen_view3d_zoom_to_fac(vod->camzoom_prev) * 2.0f;
2276         float zoomfac =      BKE_screen_view3d_zoom_to_fac(vod->rv3d->camzoom) * 2.0f;
2277
2278         zfac = viewzoom_scale_value(
2279                &vod->ar->winrct, viewzoom, zoom_invert, true, xy, &vod->origx,
2280                zoomfac, zoomfac_prev,
2281                &vod->timer_lastdraw);
2282
2283         if (zfac != 1.0f && zfac != 0.0f) {
2284                 /* calculate inverted, then invert again (needed because of camera zoom scaling) */
2285                 zfac = 1.0f / zfac;
2286                 view_zoom_mouseloc_camera(
2287                         vod->scene, vod->v3d,
2288                         vod->ar, zfac, vod->oldx, vod->oldy);
2289         }
2290
2291         ED_region_tag_redraw(vod->ar);
2292 }
2293
2294 static void viewzoom_apply_3d(
2295         ViewOpsData *vod, const int xy[2],
2296         const short viewzoom, const bool zoom_invert)
2297 {
2298         float zfac;
2299         float dist_range[2];
2300
2301         ED_view3d_dist_range_get(vod->v3d, dist_range);
2302
2303         zfac = viewzoom_scale_value(
2304                &vod->ar->winrct, viewzoom, zoom_invert, false, xy, &vod->origx,
2305                vod->rv3d->dist, vod->dist_prev,
2306                &vod->timer_lastdraw);
2307
2308         if (zfac != 1.0f) {
2309                 const float zfac_min = dist_range[0] / vod->rv3d->dist;
2310                 const float zfac_max = dist_range[1] / vod->rv3d->dist;
2311                 CLAMP(zfac, zfac_min, zfac_max);
2312
2313                 view_zoom_mouseloc_3d(
2314                         vod->ar, zfac, vod->oldx, vod->oldy);
2315         }
2316
2317         /* these limits were in old code too */
2318         CLAMP(vod->rv3d->dist, dist_range[0], dist_range[1]);
2319
2320         if (vod->rv3d->viewlock & RV3D_BOXVIEW)
2321                 view3d_boxview_sync(vod->sa, vod->ar);
2322
2323         ED_view3d_camera_lock_sync(vod->v3d, vod->rv3d);
2324
2325         ED_region_tag_redraw(vod->ar);
2326 }
2327
2328 static void viewzoom_apply(
2329         ViewOpsData *vod, const int xy[2],
2330         const short viewzoom, const bool zoom_invert)
2331 {
2332         if ((vod->rv3d->persp == RV3D_CAMOB) &&
2333             (vod->rv3d->is_persp && ED_view3d_camera_lock_check(vod->v3d, vod->rv3d)) == 0)
2334         {
2335                 viewzoom_apply_camera(vod, xy, viewzoom, zoom_invert);
2336         }
2337         else {
2338                 viewzoom_apply_3d(vod, xy, viewzoom, zoom_invert);
2339         }
2340 }
2341
2342 static int viewzoom_modal(bContext *C, wmOperator *op, const wmEvent *event)
2343 {
2344         ViewOpsData *vod = op->customdata;
2345         short event_code = VIEW_PASS;
2346         bool use_autokey = false;
2347         int ret = OPERATOR_RUNNING_MODAL;
2348
2349         /* execute the events */
2350         if (event->type == TIMER && event->customdata == vod->timer) {
2351                 /* continuous zoom */
2352                 event_code = VIEW_APPLY;
2353         }
2354         else if (event->type == MOUSEMOVE) {
2355                 event_code = VIEW_APPLY;
2356         }
2357         else if (event->type == EVT_MODAL_MAP) {
2358                 switch (event->val) {
2359                         case VIEW_MODAL_CONFIRM:
2360                                 event_code = VIEW_CONFIRM;
2361                                 break;
2362                         case VIEWROT_MODAL_SWITCH_MOVE:
2363                                 WM_operator_name_call(C, "VIEW3D_OT_move", WM_OP_INVOKE_DEFAULT, NULL);
2364                                 event_code = VIEW_CONFIRM;
2365                                 break;
2366                         case VIEWROT_MODAL_SWITCH_ROTATE:
2367                                 WM_operator_name_call(C, "VIEW3D_OT_rotate", WM_OP_INVOKE_DEFAULT, NULL);
2368                                 event_code = VIEW_CONFIRM;
2369                                 break;
2370                 }
2371         }
2372         else if (event->type == vod->origkey && event->val == KM_RELEASE) {
2373                 event_code = VIEW_CONFIRM;
2374         }
2375
2376         if (event_code == VIEW_APPLY) {
2377                 viewzoom_apply(vod, &event->x, U.viewzoom, (U.uiflag & USER_ZOOM_INVERT) != 0);
2378                 if (ED_screen_animation_playing(CTX_wm_manager(C))) {
2379                         use_autokey = true;
2380                 }
2381         }
2382         else if (event_code == VIEW_CONFIRM) {
2383                 ED_view3d_depth_tag_update(vod->rv3d);
2384                 use_autokey = true;
2385                 ret = OPERATOR_FINISHED;
2386         }
2387
2388         if (use_autokey) {
2389                 ED_view3d_camera_lock_autokey(vod->v3d, vod->rv3d, C, false, true);
2390         }
2391
2392         if (ret & OPERATOR_FINISHED) {
2393                 viewops_data_free(C, op);
2394         }
2395
2396         return ret;
2397 }
2398
2399 static int viewzoom_exec(bContext *C, wmOperator *op)
2400 {
2401         Scene *scene = CTX_data_scene(C);
2402         View3D *v3d;
2403         RegionView3D *rv3d;
2404         ScrArea *sa;
2405         ARegion *ar;
2406         bool use_cam_zoom;
2407         float dist_range[2];
2408
2409         const int delta = RNA_int_get(op->ptr, "delta");
2410         int mx, my;
2411
2412         if (op->customdata) {
2413                 ViewOpsData *vod = op->customdata;
2414
2415                 sa = vod->sa;
2416                 ar = vod->ar;
2417         }
2418         else {
2419                 sa = CTX_wm_area(C);
2420                 ar = CTX_wm_region(C);
2421         }
2422
2423         v3d = sa->spacedata.first;
2424         rv3d = ar->regiondata;
2425
2426         mx = RNA_struct_property_is_set(op->ptr, "mx") ? RNA_int_get(op->ptr, "mx") : ar->winx / 2;
2427         my = RNA_struct_property_is_set(op->ptr, "my") ? RNA_int_get(op->ptr, "my") : ar->winy / 2;
2428
2429         use_cam_zoom = (rv3d->persp == RV3D_CAMOB) && !(rv3d->is_persp && ED_view3d_camera_lock_check(v3d, rv3d));
2430
2431         ED_view3d_dist_range_get(v3d, dist_range);
2432
2433         if (delta < 0) {
2434                 const float step = 1.2f;
2435                 /* this min and max is also in viewmove() */
2436                 if (use_cam_zoom) {
2437                         view_zoom_mouseloc_camera(scene, v3d, ar, step, mx, my);
2438                 }
2439                 else {
2440                         if (rv3d->dist < dist_range[1]) {
2441                                 view_zoom_mouseloc_3d(ar, step, mx, my);
2442                         }
2443                 }
2444         }
2445         else {
2446                 const float step = 1.0f / 1.2f;
2447                 if (use_cam_zoom) {
2448                         view_zoom_mouseloc_camera(scene, v3d, ar, step, mx, my);
2449                 }
2450                 else {
2451                         if (rv3d->dist > dist_range[0]) {
2452                                 view_zoom_mouseloc_3d(ar, step, mx, my);
2453                         }
2454                 }
2455         }
2456
2457         if (rv3d->viewlock & RV3D_BOXVIEW)
2458                 view3d_boxview_sync(sa, ar);
2459
2460         ED_view3d_depth_tag_update(rv3d);
2461
2462         ED_view3d_camera_lock_sync(v3d, rv3d);
2463         ED_view3d_camera_lock_autokey(v3d, rv3d, C, false, true);
2464
2465         ED_region_tag_redraw(ar);
2466
2467         viewops_data_free(C, op);
2468
2469         return OPERATOR_FINISHED;
2470 }
2471
2472 /* this is an exact copy of viewzoom_modal_keymap */
2473 /* called in transform_ops.c, on each regeneration of keymaps  */
2474 void viewdolly_modal_keymap(wmKeyConfig *keyconf)
2475 {
2476         static EnumPropertyItem modal_items[] = {
2477                 {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
2478
2479                 {VIEWROT_MODAL_SWITCH_ROTATE, "SWITCH_TO_ROTATE", 0, "Switch to Rotate"},
2480                 {VIEWROT_MODAL_SWITCH_MOVE, "SWITCH_TO_MOVE", 0, "Switch to Move"},
2481
2482                 {0, NULL, 0, NULL, NULL}
2483         };
2484
2485         wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Dolly Modal");
2486
2487         /* this function is called for each spacetype, only needs to add map once */
2488         if (keymap && keymap->modal_items) return;
2489
2490         keymap = WM_modalkeymap_add(keyconf, "View3D Dolly Modal", modal_items);
2491
2492         /* items for modal map */
2493         WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
2494         WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
2495
2496         /* disabled mode switching for now, can re-implement better, later on */
2497 #if 0
2498         WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
2499         WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
2500         WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
2501 #endif
2502
2503         /* assign map to operators */
2504         WM_modalkeymap_assign(keymap, "VIEW3D_OT_dolly");
2505 }
2506
2507 /* viewdolly_invoke() copied this function, changes here may apply there */
2508 static int viewzoom_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2509 {
2510         ViewOpsData *vod;
2511
2512         /* makes op->customdata */
2513         viewops_data_alloc(C, op);
2514         viewops_data_create(C, op, event);
2515         vod = op->customdata;
2516
2517         ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
2518
2519         /* if one or the other zoom position aren't set, set from event */
2520         if (!RNA_struct_property_is_set(op->ptr, "mx") || !RNA_struct_property_is_set(op->ptr, "my")) {
2521                 RNA_int_set(op->ptr, "mx", event->x);
2522                 RNA_int_set(op->ptr, "my", event->y);
2523         }
2524
2525         if (RNA_struct_property_is_set(op->ptr, "delta")) {
2526                 viewzoom_exec(C, op);
2527         }
2528         else {
2529                 if (event->type == MOUSEZOOM || event->type == MOUSEPAN) {
2530
2531                         if (U.uiflag & USER_ZOOM_HORIZ) {
2532                                 vod->origx = vod->oldx = event->x;
2533                                 viewzoom_apply(vod, &event->prevx, USER_ZOOM_DOLLY, (U.uiflag & USER_ZOOM_INVERT) != 0);
2534                         }
2535                         else {
2536                                 /* Set y move = x move as MOUSEZOOM uses only x axis to pass magnification value */
2537                                 vod->origy = vod->oldy = vod->origy + event->x - event->prevx;
2538                                 viewzoom_apply(vod, &event->prevx, USER_ZOOM_DOLLY, (U.uiflag & USER_ZOOM_INVERT) != 0);
2539                         }
2540                         ED_view3d_camera_lock_autokey(vod->v3d, vod->rv3d, C, false, true);
2541
2542                         ED_view3d_depth_tag_update(vod->rv3d);
2543
2544                         viewops_data_free(C, op);
2545                         return OPERATOR_FINISHED;
2546                 }
2547                 else {
2548                         if (U.viewzoom == USER_ZOOM_CONT) {
2549                                 /* needs a timer to continue redrawing */
2550                                 vod->timer = WM_event_add_timer(CTX_wm_manager(C), CTX_wm_window(C), TIMER, 0.01f);
2551                                 vod->timer_lastdraw = PIL_check_seconds_timer();
2552                         }
2553
2554                         /* add temp handler */
2555                         WM_event_add_modal_handler(C, op);
2556
2557                         return OPERATOR_RUNNING_MODAL;
2558                 }
2559         }
2560         return OPERATOR_FINISHED;
2561 }
2562
2563 static void viewzoom_cancel(bContext *C, wmOperator *op)
2564 {
2565         viewops_data_free(C, op);
2566 }
2567
2568 void VIEW3D_OT_zoom(wmOperatorType *ot)
2569 {
2570         PropertyRNA *prop;
2571
2572         /* identifiers */
2573         ot->name = "Zoom View";
2574         ot->description = "Zoom in/out in the view";
2575         ot->idname = "VIEW3D_OT_zoom";
2576
2577         /* api callbacks */
2578         ot->invoke = viewzoom_invoke;
2579         ot->exec = viewzoom_exec;
2580         ot->modal = viewzoom_modal;
2581         ot->poll = ED_operator_region_view3d_active;
2582         ot->cancel = viewzoom_cancel;
2583
2584         /* flags */
2585         ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
2586
2587         RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
2588         prop = RNA_def_int(ot->srna, "mx", 0, 0, INT_MAX, "Zoom Position X", "", 0, INT_MAX);
2589         RNA_def_property_flag(prop, PROP_HIDDEN);
2590         prop = RNA_def_int(ot->srna, "my", 0, 0, INT_MAX, "Zoom Position Y", "", 0, INT_MAX);
2591         RNA_def_property_flag(prop, PROP_HIDDEN);
2592 }
2593
2594
2595 /* ************************ viewdolly ******************************** */
2596 static void view_dolly_mouseloc(ARegion *ar, float orig_ofs[3], float dvec[3], float dfac)
2597 {
2598         RegionView3D *rv3d = ar->regiondata;
2599         madd_v3_v3v3fl(rv3d->ofs, orig_ofs, dvec, -(1.0f - dfac));
2600 }
2601
2602 static void viewdolly_apply(ViewOpsData *vod, int x, int y, const short zoom_invert)
2603 {
2604         float zfac = 1.0;
2605
2606         {
2607                 float len1, len2;
2608
2609                 if (U.uiflag & USER_ZOOM_HORIZ) {
2610                         len1 = (vod->ar->winrct.xmax - x) + 5;
2611                         len2 = (vod->ar->winrct.xmax - vod->origx) + 5;
2612                 }
2613                 else {
2614                         len1 = (vod->ar->winrct.ymax - y) + 5;
2615                         len2 = (vod->ar->winrct.ymax - vod->origy) + 5;
2616                 }
2617                 if (zoom_invert)
2618                         SWAP(float, len1, len2);
2619
2620                 zfac =  1.0f + ((len1 - len2) * 0.01f * vod->rv3d->dist);
2621         }
2622
2623         if (zfac != 1.0f)
2624                 view_dolly_mouseloc(vod->ar, vod->ofs, vod->mousevec, zfac);
2625
2626         if (vod->rv3d->viewlock & RV3D_BOXVIEW)
2627                 view3d_boxview_sync(vod->sa, vod->ar);
2628
2629         ED_view3d_camera_lock_sync(vod->v3d, vod->rv3d);
2630
2631         ED_region_tag_redraw(vod->ar);
2632 }
2633
2634
2635 static int viewdolly_modal(bContext *C, wmOperator *op, const wmEvent *event)
2636 {
2637         ViewOpsData *vod = op->customdata;
2638         short event_code = VIEW_PASS;
2639         bool use_autokey = false;
2640         int ret = OPERATOR_RUNNING_MODAL;
2641
2642         /* execute the events */
2643         if (event->type == MOUSEMOVE) {
2644                 event_code = VIEW_APPLY;
2645         }
2646         else if (event->type == EVT_MODAL_MAP) {
2647                 switch (event->val) {
2648                         case VIEW_MODAL_CONFIRM:
2649                                 event_code = VIEW_CONFIRM;
2650                                 break;
2651                         case VIEWROT_MODAL_SWITCH_MOVE:
2652                                 WM_operator_name_call(C, "VIEW3D_OT_move", WM_OP_INVOKE_DEFAULT, NULL);
2653                                 event_code = VIEW_CONFIRM;
2654                                 break;
2655                         case VIEWROT_MODAL_SWITCH_ROTATE:
2656                                 WM_operator_name_call(C, "VIEW3D_OT_rotate", WM_OP_INVOKE_DEFAULT, NULL);
2657                                 event_code = VIEW_CONFIRM;
2658                                 break;
2659                 }
2660         }
2661         else if (event->type == vod->origkey && event->val == KM_RELEASE) {
2662                 event_code = VIEW_CONFIRM;
2663         }
2664
2665         if (event_code == VIEW_APPLY) {
2666                 viewdolly_apply(vod, event->x, event->y, (U.uiflag & USER_ZOOM_INVERT) != 0);
2667                 if (ED_screen_animation_playing(CTX_wm_manager(C))) {
2668                         use_autokey = true;
2669                 }
2670         }
2671         else if (event_code == VIEW_CONFIRM) {
2672                 ED_view3d_depth_tag_update(vod->rv3d);
2673                 use_autokey = true;
2674                 ret = OPERATOR_FINISHED;
2675         }
2676
2677         if (use_autokey) {
2678                 ED_view3d_camera_lock_autokey(vod->v3d, vod->rv3d, C, false, true);
2679         }
2680
2681         if (ret & OPERATOR_FINISHED) {
2682                 viewops_data_free(C, op);
2683         }
2684
2685         return ret;
2686 }
2687
2688 static int viewdolly_exec(bContext *C, wmOperator *op)
2689 {
2690         View3D *v3d;
2691         RegionView3D *rv3d;
2692         ScrArea *sa;
2693         ARegion *ar;
2694         float mousevec[3];
2695
2696         const int delta = RNA_int_get(op->ptr, "delta");
2697
2698         if (op->customdata) {
2699                 ViewOpsData *vod = op->customdata;
2700
2701                 sa = vod->sa;
2702                 ar = vod->ar;
2703                 copy_v3_v3(mousevec, vod->mousevec);
2704         }
2705         else {
2706                 sa = CTX_wm_area(C);
2707                 ar = CTX_wm_region(C);
2708                 negate_v3_v3(mousevec, ((RegionView3D *)ar->regiondata)->viewinv[2]);
2709                 normalize_v3(mousevec);
2710         }
2711
2712         v3d = sa->spacedata.first;
2713         rv3d = ar->regiondata;
2714
2715         /* overwrite the mouse vector with the view direction (zoom into the center) */
2716         if ((U.uiflag & USER_ZOOM_TO_MOUSEPOS) == 0) {
2717                 normalize_v3_v3(mousevec, rv3d->viewinv[2]);
2718         }
2719
2720         if (delta < 0) {
2721                 view_dolly_mouseloc(ar, rv3d->ofs, mousevec, 0.2f);
2722         }
2723         else {
2724                 view_dolly_mouseloc(ar, rv3d->ofs, mousevec, 1.8f);
2725         }
2726
2727         if (rv3d->viewlock & RV3D_BOXVIEW)
2728                 view3d_boxview_sync(sa, ar);
2729
2730         ED_view3d_depth_tag_update(rv3d);
2731
2732         ED_view3d_camera_lock_sync(v3d, rv3d);
2733
2734         ED_region_tag_redraw(ar);
2735
2736         viewops_data_free(C, op);
2737
2738         return OPERATOR_FINISHED;
2739 }
2740
2741 /* copied from viewzoom_invoke(), changes here may apply there */
2742 static int viewdolly_invoke(bContext *C, wmOperator *op, const wmEvent *event)
2743 {
2744         ViewOpsData *vod;
2745
2746         if (view3d_operator_offset_lock_check(C, op))
2747                 return OPERATOR_CANCELLED;
2748
2749         /* makes op->customdata */
2750         viewops_data_alloc(C, op);
2751         vod = op->customdata;
2752
2753         /* poll should check but in some cases fails, see poll func for details */
2754         if (vod->rv3d->viewlock & RV3D_LOCKED) {
2755                 viewops_data_free(C, op);
2756                 return OPERATOR_PASS_THROUGH;
2757         }
2758
2759         ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
2760
2761         /* needs to run before 'viewops_data_create' so the backup 'rv3d->ofs' is correct */
2762         /* switch from camera view when: */
2763         if (vod->rv3d->persp != RV3D_PERSP) {
2764                 if (vod->rv3d->persp == RV3D_CAMOB) {
2765                         /* ignore rv3d->lpersp because dolly only makes sense in perspective mode */
2766                         view3d_persp_switch_from_camera(vod->v3d, vod->rv3d, RV3D_PERSP);
2767                 }
2768                 else {
2769                         vod->rv3d->persp = RV3D_PERSP;
2770                 }
2771                 ED_region_tag_redraw(vod->ar);
2772         }
2773
2774         viewops_data_create(C, op, event);
2775
2776
2777         /* if one or the other zoom position aren't set, set from event */
2778         if (!RNA_struct_property_is_set(op->ptr, "mx") || !RNA_struct_property_is_set(op->ptr, "my")) {
2779                 RNA_int_set(op->ptr, "mx", event->x);
2780                 RNA_int_set(op->ptr, "my", event->y);
2781         }
2782
2783         if (RNA_struct_property_is_set(op->ptr, "delta")) {
2784                 viewdolly_exec(C, op);
2785         }
2786         else {
2787                 /* overwrite the mouse vector with the view direction (zoom into the center) */
2788                 if ((U.uiflag & USER_ZOOM_TO_MOUSEPOS) == 0) {
2789                         negate_v3_v3(vod->mousevec, vod->rv3d->viewinv[2]);
2790                         normalize_v3(vod->mousevec);
2791                 }
2792
2793                 if (event->type == MOUSEZOOM) {
2794                         /* Bypass Zoom invert flag for track pads (pass false always) */
2795
2796                         if (U.uiflag & USER_ZOOM_HORIZ) {
2797                                 vod->origx = vod->oldx = event->x;
2798                                 viewdolly_apply(vod, event->prevx, event->prevy, (U.uiflag & USER_ZOOM_INVERT) == 0);
2799                         }
2800                         else {
2801
2802                                 /* Set y move = x move as MOUSEZOOM uses only x axis to pass magnification value */
2803                                 vod->origy = vod->oldy = vod->origy + event->x - event->prevx;
2804                                 viewdolly_apply(vod, event->prevx, event->prevy, (U.uiflag & USER_ZOOM_INVERT) == 0);
2805                         }
2806                         ED_view3d_depth_tag_update(vod->rv3d);
2807
2808                         viewops_data_free(C, op);
2809                         return OPERATOR_FINISHED;
2810                 }
2811                 else {
2812                         /* add temp handler */
2813                         WM_event_add_modal_handler(C, op);
2814
2815                         return OPERATOR_RUNNING_MODAL;
2816                 }
2817         }
2818         return OPERATOR_FINISHED;
2819 }
2820
2821 static void viewdolly_cancel(bContext *C, wmOperator *op)
2822 {
2823         viewops_data_free(C, op);
2824 }
2825
2826 void VIEW3D_OT_dolly(wmOperatorType *ot)
2827 {
2828         /* identifiers */
2829         ot->name = "Dolly View";
2830         ot->description = "Dolly in/out in the view";
2831         ot->idname = "VIEW3D_OT_dolly";
2832
2833         /* api callbacks */
2834         ot->invoke = viewdolly_invoke;
2835         ot->exec = viewdolly_exec;
2836         ot->modal = viewdolly_modal;
2837         ot->poll = ED_operator_region_view3d_active;
2838         ot->cancel = viewdolly_cancel;
2839
2840         /* flags */
2841         ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
2842
2843         RNA_def_int(ot->srna, "delta", 0, INT_MIN, INT_MAX, "Delta", "", INT_MIN, INT_MAX);
2844         RNA_def_int(ot->srna, "mx", 0, 0, INT_MAX, "Zoom Position X", "", 0, INT_MAX);
2845         RNA_def_int(ot->srna, "my", 0, 0, INT_MAX, "Zoom Position Y", "", 0, INT_MAX);
2846 }
2847
2848 static void view3d_from_minmax(bContext *C, View3D *v3d, ARegion *ar,
2849                                const float min[3], const float max[3],
2850                                bool ok_dist, const int smooth_viewtx)
2851 {
2852         RegionView3D *rv3d = ar->regiondata;
2853         float afm[3];
2854         float size;
2855
2856         ED_view3d_smooth_view_force_finish(C, v3d, ar);
2857
2858         /* SMOOTHVIEW */
2859         float new_ofs[3];
2860         float new_dist;
2861
2862         sub_v3_v3v3(afm, max, min);
2863         size = max_fff(afm[0], afm[1], afm[2]);
2864
2865         if (ok_dist) {
2866                 char persp;
2867
2868                 if (rv3d->is_persp) {
2869                         if (rv3d->persp == RV3D_CAMOB && ED_view3d_camera_lock_check(v3d, rv3d)) {
2870                                 persp = RV3D_CAMOB;
2871                         }
2872                         else {
2873                                 persp = RV3D_PERSP;
2874                         }
2875                 }
2876                 else { /* ortho */
2877                         if (size < 0.0001f) {
2878                                 /* bounding box was a single point so do not zoom */
2879                                 ok_dist = false;
2880                         }
2881                         else {
2882                                 /* adjust zoom so it looks nicer */
2883                                 persp = RV3D_ORTHO;
2884                         }
2885                 }
2886
2887                 if (ok_dist) {
2888                         new_dist = ED_view3d_radius_to_dist(v3d, ar, persp, true, (size / 2) * VIEW3D_MARGIN);
2889                         if (rv3d->is_persp) {
2890                                 /* don't zoom closer than the near clipping plane */
2891                                 new_dist = max_ff(new_dist, v3d->near * 1.5f);
2892                         }
2893                 }
2894         }
2895
2896         mid_v3_v3v3(new_ofs, min, max);
2897         negate_v3(new_ofs);
2898
2899         if (rv3d->persp == RV3D_CAMOB && !ED_view3d_camera_lock_check(v3d, rv3d)) {
2900                 rv3d->persp = RV3D_PERSP;
2901                 ED_view3d_smooth_view(
2902                         C, v3d, ar, smooth_viewtx,
2903                         &(const V3D_SmoothParams) {
2904                             .camera_old = v3d->camera, .ofs = new_ofs,
2905                             .dist = ok_dist ? &new_dist : NULL});
2906         }
2907         else {
2908                 ED_view3d_smooth_view(
2909                         C, v3d, ar, smooth_viewtx,
2910                         &(const V3D_SmoothParams) {.ofs = new_ofs, .dist = ok_dist ? &new_dist : NULL});
2911         }
2912
2913         /* smooth view does viewlock RV3D_BOXVIEW copy */
2914 }
2915
2916 /* same as view3d_from_minmax but for all regions (except cameras) */
2917 static void view3d_from_minmax_multi(bContext *C, View3D *v3d,
2918                                      const float min[3], const float max[3],
2919                                      const bool ok_dist, const int smooth_viewtx)
2920 {
2921         ScrArea *sa = CTX_wm_area(C);
2922         ARegion *ar;
2923         for (ar = sa->regionbase.first; ar; ar = ar->next) {
2924                 if (ar->regiontype == RGN_TYPE_WINDOW) {
2925                         RegionView3D *rv3d = ar->regiondata;
2926                         /* when using all regions, don't jump out of camera view,
2927                          * but _do_ allow locked cameras to be moved */
2928                         if ((rv3d->persp != RV3D_CAMOB) || ED_view3d_camera_lock_check(v3d, rv3d)) {
2929                                 view3d_from_minmax(C, v3d, ar, min, max, ok_dist, smooth_viewtx);
2930                         }
2931                 }
2932         }
2933 }
2934
2935 static int view3d_all_exec(bContext *C, wmOperator *op) /* was view3d_home() in 2.4x */
2936 {
2937         ARegion *ar = CTX_wm_region(C);
2938         View3D *v3d = CTX_wm_view3d(C);
2939         Scene *scene = CTX_data_scene(C);
2940         Base *base;
2941         float *curs;
2942         const bool use_all_regions = RNA_boolean_get(op->ptr, "use_all_regions");
2943         const bool skip_camera = (ED_view3d_camera_lock_check(v3d, ar->regiondata) ||
2944                                   /* any one of the regions may be locked */
2945                                   (use_all_regions && v3d->flag2 & V3D_LOCK_CAMERA));
2946         const bool center = RNA_boolean_get(op->ptr, "center");
2947         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
2948
2949         float min[3], max[3];
2950         bool changed = false;
2951
2952         if (center) {
2953                 /* in 2.4x this also move the cursor to (0, 0, 0) (with shift+c). */
2954                 curs = ED_view3d_cursor3d_get(scene, v3d);
2955                 zero_v3(min);
2956                 zero_v3(max);
2957                 zero_v3(curs);
2958         }
2959         else {
2960                 INIT_MINMAX(min, max);
2961         }
2962
2963         for (base = scene->base.first; base; base = base->next) {
2964                 if (BASE_VISIBLE(v3d, base)) {
2965                         changed = true;
2966
2967                         if (skip_camera && base->object == v3d->camera) {
2968                                 continue;
2969                         }
2970
2971                         BKE_object_minmax(base->object, min, max, false);
2972                 }
2973         }
2974         if (!changed) {
2975                 ED_region_tag_redraw(ar);
2976                 /* TODO - should this be cancel?
2977                  * I think no, because we always move the cursor, with or without
2978                  * object, but in this case there is no change in the scene,
2979                  * only the cursor so I choice a ED_region_tag like
2980                  * view3d_smooth_view do for the center_cursor.
2981                  * See bug #22640
2982                  */
2983                 return OPERATOR_FINISHED;
2984         }
2985
2986         if (use_all_regions) {
2987                 view3d_from_minmax_multi(C, v3d, min, max, true, smooth_viewtx);
2988         }
2989         else {
2990                 view3d_from_minmax(C, v3d, ar, min, max, true, smooth_viewtx);
2991         }
2992
2993         return OPERATOR_FINISHED;
2994 }
2995
2996
2997 void VIEW3D_OT_view_all(wmOperatorType *ot)
2998 {
2999         PropertyRNA *prop;
3000
3001         /* identifiers */
3002         ot->name = "View All";
3003         ot->description = "View all objects in scene";
3004         ot->idname = "VIEW3D_OT_view_all";
3005
3006         /* api callbacks */
3007         ot->exec = view3d_all_exec;
3008         ot->poll = ED_operator_region_view3d_active;
3009
3010         /* flags */
3011         ot->flag = 0;
3012
3013         prop = RNA_def_boolean(ot->srna, "use_all_regions", 0, "All Regions", "View selected for all regions");
3014         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3015         RNA_def_boolean(ot->srna, "center", 0, "Center", "");
3016 }
3017
3018 /* like a localview without local!, was centerview() in 2.4x */
3019 static int viewselected_exec(bContext *C, wmOperator *op)
3020 {
3021         ARegion *ar = CTX_wm_region(C);
3022         View3D *v3d = CTX_wm_view3d(C);
3023         Scene *scene = CTX_data_scene(C);
3024         bGPdata *gpd = CTX_data_gpencil_data(C);
3025         const bool is_gp_edit = ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE));
3026         Object *ob = OBACT;
3027         Object *obedit = CTX_data_edit_object(C);
3028         float min[3], max[3];
3029         bool ok = false, ok_dist = true;
3030         const bool use_all_regions = RNA_boolean_get(op->ptr, "use_all_regions");
3031         const bool skip_camera = (ED_view3d_camera_lock_check(v3d, ar->regiondata) ||
3032                                   /* any one of the regions may be locked */
3033                                   (use_all_regions && v3d->flag2 & V3D_LOCK_CAMERA));
3034         const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
3035
3036         INIT_MINMAX(min, max);
3037
3038         if (is_gp_edit) {
3039                 ob = NULL;
3040         }
3041
3042         if (ob && (ob->mode & OB_MODE_WEIGHT_PAINT)) {
3043                 /* hard-coded exception, we look for the one selected armature */
3044                 /* this is weak code this way, we should make a generic active/selection callback interface once... */
3045                 Base *base;
3046                 for (base = scene->base.first; base; base = base->next) {
3047                         if (TESTBASELIB(v3d, base)) {
3048                                 if (base->object->type == OB_ARMATURE)
3049                                         if (base->object->mode & OB_MODE_POSE)
3050                                                 break;
3051                         }
3052                 }
3053                 if (base)
3054                         ob = base->object;
3055         }
3056
3057
3058         if (is_gp_edit) {
3059                 CTX_DATA_BEGIN(C, bGPDstroke *, gps, editable_gpencil_strokes)
3060                 {
3061                         /* we're only interested in selected points here... */
3062                         if ((gps->flag & GP_STROKE_SELECT) && (gps->flag & GP_STROKE_3DSPACE)) {
3063                                 if (ED_gpencil_stroke_minmax(gps, true, min, max)) {
3064                                         ok = true;
3065                                 }
3066                         }
3067                 }
3068                 CTX_DATA_END;
3069         }
3070         else if (obedit) {
3071                 ok = ED_view3d_minmax_verts(obedit, min, max);    /* only selected */
3072         }
3073         else if (ob && (ob->mode & OB_MODE_POSE)) {
3074                 ok = BKE_pose_minmax(ob, min, max, true, true);
3075         }
3076         else if (BKE_paint_select_face_test(ob)) {
3077                 ok = paintface_minmax(ob, min, max);
3078         }
3079         else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
3080                 ok = PE_minmax(scene, min, max);
3081         }
3082         else if (ob && (ob->mode & (OB_MODE_SCULPT | OB_MODE_TEXTURE_PAINT))) {
3083                 BKE_paint_stroke_get_average(scene, ob, min);
3084                 copy_v3_v3(max, min);
3085                 ok = true;
3086                 ok_dist = 0; /* don't zoom */
3087         }
3088         else {
3089                 Base *base;
3090                 for (base = FIRSTBASE; base; base = base->next) {
3091                         if (TESTBASE(v3d, base)) {
3092
3093                                 if (skip_camera && base->object == v3d->camera) {
3094                                         continue;
3095                                 }
3096
3097                                 /* account for duplis */
3098                                 if (BKE_object_minmax_dupli(scene, base->object, min, max, false) == 0)
3099                                         BKE_object_minmax(base->object, min, max, false);  /* use if duplis not found */
3100
3101                                 ok = 1;
3102                         }
3103                 }
3104         }
3105
3106         if (ok == 0) {
3107                 return OPERATOR_FINISHED;
3108         }
3109
3110         if (use_all_regions) {
3111                 view3d_from_minmax_multi(C, v3d, min, max, ok_dist, smooth_viewtx);
3112         }
3113         else {
3114                 view3d_from_minmax(C, v3d, ar, min, max, ok_dist, smooth_viewtx);
3115         }
3116
3117         return OPERATOR_FINISHED;
3118 }
3119
3120 void VIEW3D_OT_view_selected(wmOperatorType *ot)
3121 {
3122         PropertyRNA *prop;
3123
3124         /* identifiers */
3125         ot->name = "View Selected";
3126         ot->description = "Move the view to the selection center";
3127         ot->idname = "VIEW3D_OT_view_selected";
3128
3129         /* api callbacks */
3130         ot->exec = viewselected_exec;
3131         ot->poll = ED_operator_region_view3d_active;
3132
3133         /* flags */
3134         ot->flag = 0;
3135
3136         /* rna later */
3137         prop = RNA_def_boolean(ot->srna, "use_all_regions", 0, "All Regions", "View selected for all regions");
3138         RNA_def_property_flag(prop, PROP_SKIP_SAVE);
3139 }
3140
3141 static int view_lock_clear_exec(bContext *C, wmOperator *UNUSED(op))
3142 {
3143         View3D *v3d = CTX_wm_view3d(C);
3144
3145         if (v3d) {
3146                 ED_view3D_lock_clear(v3d);
3147
3148                 WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
3149
3150                 return OPERATOR_FINISHED;
3151         }
3152         else {
3153                 return OPERATOR_CANCELLED;
3154         }
3155 }
3156
3157 void VIEW3D_OT_view_lock_clear(wmOperatorType *ot)
3158 {
3159
3160         /* identifiers */
3161         ot->name = "View Lock Clear";
3162         ot->description = "Clear all view locking";
3163         ot->idname = "VIEW3D_OT_view_lock_clear";
3164
3165         /* api callbacks */
3166         ot->exec = view_lock_clear_exec;
3167         ot->poll = ED_operator_region_view3d_active;
3168
3169         /* flags */
3170         ot->flag = 0;
3171 }
3172
3173 static int view_lock_to_active_exec(bContext *C, wmOperator *UNUSED(op))
3174 {
3175         View3D *v3d = CTX_wm_view3d(C);
3176         Object *obact = CTX_data_active_object(C);
3177
3178         if (v3d) {
3179
3180                 ED_view3D_lock_clear(v3d);
3181
3182                 v3d->ob_centre = obact; /* can be NULL */
3183
3184                 if (obact && obact->type == OB_ARMATURE) {
3185                         if (obact->mode & OB_MODE_POSE) {
3186                                 bPoseChannel *pcham_act = BKE_pose_channel_active(obact);
3187                                 if (pcham_act) {
3188                                         BLI_strncpy(v3d->ob_centre_bone, pcham_act->name, sizeof(v3d->ob_centre_bone));
3189                                 }
3190                         }
3191                         else {
3192                                 EditBone *ebone_act = ((bArmature *)obact->data)->act_edbone;
3193                                 if (ebone_act) {
3194                          &n