Merge branch 'master' into blender2.8
[blender.git] / source / blender / editors / space_view3d / view3d_utils.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  * ***** END GPL LICENSE BLOCK *****
22  */
23
24 /** \file blender/editors/space_view3d/view3d_utils.c
25  *  \ingroup spview3d
26  *
27  * 3D View checks and manipulation (no operators).
28  */
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <math.h>
33 #include <float.h>
34
35 #include "DNA_camera_types.h"
36 #include "DNA_curve_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39
40 #include "MEM_guardedalloc.h"
41
42 #include "BLI_bitmap_draw_2d.h"
43 #include "BLI_blenlib.h"
44 #include "BLI_math.h"
45 #include "BLI_utildefines.h"
46
47 #include "BKE_camera.h"
48 #include "BKE_context.h"
49 #include "BKE_object.h"
50 #include "BKE_screen.h"
51
52 #include "DEG_depsgraph.h"
53 #include "DEG_depsgraph_query.h"
54
55 #include "BIF_gl.h"
56 #include "BIF_glutil.h"
57
58 #include "WM_api.h"
59 #include "WM_types.h"
60
61 #include "ED_keyframing.h"
62 #include "ED_screen.h"
63 #include "ED_view3d.h"
64
65 #include "view3d_intern.h"  /* own include */
66
67 /* -------------------------------------------------------------------- */
68 /** \name View Data Access Utilities
69  *
70  * \{ */
71
72 float *ED_view3d_cursor3d_get(Scene *scene, View3D *v3d)
73 {
74         if (v3d && v3d->localvd) return v3d->cursor;
75         else return scene->cursor;
76 }
77
78 Camera *ED_view3d_camera_data_get(View3D *v3d, RegionView3D *rv3d)
79 {
80         /* establish the camera object, so we can default to view mapping if anything is wrong with it */
81         if ((rv3d->persp == RV3D_CAMOB) && v3d->camera && (v3d->camera->type == OB_CAMERA)) {
82                 return v3d->camera->data;
83         }
84         else {
85                 return NULL;
86         }
87 }
88
89 void ED_view3d_dist_range_get(
90         const View3D *v3d,
91         float r_dist_range[2])
92 {
93         r_dist_range[0] = v3d->grid * 0.001f;
94         r_dist_range[1] = v3d->far * 10.0f;
95 }
96
97 /**
98  * \note copies logic of #ED_view3d_viewplane_get(), keep in sync.
99  */
100 bool ED_view3d_clip_range_get(
101         const Depsgraph *depsgraph,
102         const View3D *v3d, const RegionView3D *rv3d,
103         float *r_clipsta, float *r_clipend,
104         const bool use_ortho_factor)
105 {
106         CameraParams params;
107
108         BKE_camera_params_init(&params);
109         BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
110
111         if (use_ortho_factor && params.is_ortho) {
112                 const float fac = 2.0f / (params.clipend - params.clipsta);
113                 params.clipsta *= fac;
114                 params.clipend *= fac;
115         }
116
117         if (r_clipsta) *r_clipsta = params.clipsta;
118         if (r_clipend) *r_clipend = params.clipend;
119
120         return params.is_ortho;
121 }
122
123 bool ED_view3d_viewplane_get(
124         const Depsgraph *depsgraph,
125         const View3D *v3d, const RegionView3D *rv3d, int winx, int winy,
126         rctf *r_viewplane, float *r_clipsta, float *r_clipend, float *r_pixsize)
127 {
128         CameraParams params;
129
130         BKE_camera_params_init(&params);
131         BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
132         BKE_camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
133
134         if (r_viewplane) *r_viewplane = params.viewplane;
135         if (r_clipsta) *r_clipsta = params.clipsta;
136         if (r_clipend) *r_clipend = params.clipend;
137         if (r_pixsize) *r_pixsize = params.viewdx;
138
139         return params.is_ortho;
140 }
141
142 /** \} */
143
144
145 /* -------------------------------------------------------------------- */
146 /** \name View State/Context Utilities
147  *
148  * \{ */
149
150 /**
151  * Use instead of: ``bglPolygonOffset(rv3d->dist, ...)`` see bug [#37727]
152  */
153 void ED_view3d_polygon_offset(const RegionView3D *rv3d, const float dist)
154 {
155         float viewdist;
156
157         if (rv3d->rflag & RV3D_ZOFFSET_DISABLED) {
158                 return;
159         }
160
161         viewdist = rv3d->dist;
162
163         /* special exception for ortho camera (viewdist isnt used for perspective cameras) */
164         if (dist != 0.0f) {
165                 if (rv3d->persp == RV3D_CAMOB) {
166                         if (rv3d->is_persp == false) {
167                                 viewdist = 1.0f / max_ff(fabsf(rv3d->winmat[0][0]), fabsf(rv3d->winmat[1][1]));
168                         }
169                 }
170         }
171
172         bglPolygonOffset(viewdist, dist);
173 }
174
175 bool ED_view3d_context_activate(bContext *C)
176 {
177         bScreen *sc = CTX_wm_screen(C);
178         ScrArea *sa = CTX_wm_area(C);
179         ARegion *ar;
180
181         /* sa can be NULL when called from python */
182         if (sa == NULL || sa->spacetype != SPACE_VIEW3D) {
183                 sa = BKE_screen_find_big_area(sc, SPACE_VIEW3D, 0);
184         }
185
186         if (sa == NULL) {
187                 return false;
188         }
189
190         ar = BKE_area_find_region_active_win(sa);
191         if (ar == NULL) {
192                 return false;
193         }
194
195         /* bad context switch .. */
196         CTX_wm_area_set(C, sa);
197         CTX_wm_region_set(C, ar);
198
199         return true;
200 }
201
202 /** \} */
203
204 /* -------------------------------------------------------------------- */
205 /** \name View Clipping Utilities
206  *
207  * \{ */
208
209 void ED_view3d_clipping_calc_from_boundbox(float clip[4][4], const BoundBox *bb, const bool is_flip)
210 {
211         int val;
212
213         for (val = 0; val < 4; val++) {
214                 normal_tri_v3(clip[val], bb->vec[val], bb->vec[val == 3 ? 0 : val + 1], bb->vec[val + 4]);
215                 if (UNLIKELY(is_flip)) {
216                         negate_v3(clip[val]);
217                 }
218
219                 clip[val][3] = -dot_v3v3(clip[val], bb->vec[val]);
220         }
221 }
222
223 void ED_view3d_clipping_calc(BoundBox *bb, float planes[4][4], const ARegion *ar, const Object *ob, const rcti *rect)
224 {
225         /* init in case unproject fails */
226         memset(bb->vec, 0, sizeof(bb->vec));
227
228         /* four clipping planes and bounding volume */
229         /* first do the bounding volume */
230         for (int val = 0; val < 4; val++) {
231                 float xs = (val == 0 || val == 3) ? rect->xmin : rect->xmax;
232                 float ys = (val == 0 || val == 1) ? rect->ymin : rect->ymax;
233
234                 ED_view3d_unproject(ar, xs, ys, 0.0, bb->vec[val]);
235                 ED_view3d_unproject(ar, xs, ys, 1.0, bb->vec[4 + val]);
236         }
237
238         /* optionally transform to object space */
239         if (ob) {
240                 float imat[4][4];
241                 invert_m4_m4(imat, ob->obmat);
242
243                 for (int val = 0; val < 8; val++) {
244                         mul_m4_v3(imat, bb->vec[val]);
245                 }
246         }
247
248         /* verify if we have negative scale. doing the transform before cross
249          * product flips the sign of the vector compared to doing cross product
250          * before transform then, so we correct for that. */
251         int flip_sign = (ob) ? is_negative_m4(ob->obmat) : false;
252
253         ED_view3d_clipping_calc_from_boundbox(planes, bb, flip_sign);
254 }
255
256 /** \} */
257
258 /* -------------------------------------------------------------------- */
259 /** \name View Bound-Box Utilities
260  *
261  * \{ */
262
263 static bool view3d_boundbox_clip_m4(const BoundBox *bb, float persmatob[4][4])
264 {
265         int a, flag = -1, fl;
266
267         for (a = 0; a < 8; a++) {
268                 float vec[4], min, max;
269                 copy_v3_v3(vec, bb->vec[a]);
270                 vec[3] = 1.0;
271                 mul_m4_v4(persmatob, vec);
272                 max = vec[3];
273                 min = -vec[3];
274
275                 fl = 0;
276                 if (vec[0] < min) fl += 1;
277                 if (vec[0] > max) fl += 2;
278                 if (vec[1] < min) fl += 4;
279                 if (vec[1] > max) fl += 8;
280                 if (vec[2] < min) fl += 16;
281                 if (vec[2] > max) fl += 32;
282
283                 flag &= fl;
284                 if (flag == 0) return true;
285         }
286
287         return false;
288 }
289
290 bool ED_view3d_boundbox_clip_ex(const RegionView3D *rv3d, const BoundBox *bb, float obmat[4][4])
291 {
292         /* return 1: draw */
293
294         float persmatob[4][4];
295
296         if (bb == NULL) return true;
297         if (bb->flag & BOUNDBOX_DISABLED) return true;
298
299         mul_m4_m4m4(persmatob, (float(*)[4])rv3d->persmat, obmat);
300
301         return view3d_boundbox_clip_m4(bb, persmatob);
302 }
303
304 bool ED_view3d_boundbox_clip(RegionView3D *rv3d, const BoundBox *bb)
305 {
306         if (bb == NULL) return true;
307         if (bb->flag & BOUNDBOX_DISABLED) return true;
308
309         return view3d_boundbox_clip_m4(bb, rv3d->persmatob);
310 }
311
312 /** \} */
313
314 /* -------------------------------------------------------------------- */
315 /** \name View Perspective & Mode Switching
316  *
317  * Misc view utility functions.
318  * \{ */
319
320 bool ED_view3d_offset_lock_check(const  View3D *v3d, const  RegionView3D *rv3d)
321 {
322         return (rv3d->persp != RV3D_CAMOB) && (v3d->ob_centre_cursor || v3d->ob_centre);
323 }
324
325 /**
326  * Use to store the last view, before entering camera view.
327  */
328 void ED_view3d_lastview_store(RegionView3D *rv3d)
329 {
330         copy_qt_qt(rv3d->lviewquat, rv3d->viewquat);
331         rv3d->lview = rv3d->view;
332         if (rv3d->persp != RV3D_CAMOB) {
333                 rv3d->lpersp = rv3d->persp;
334         }
335 }
336
337 void ED_view3d_lock_clear(View3D *v3d)
338 {
339         v3d->ob_centre = NULL;
340         v3d->ob_centre_bone[0] = '\0';
341         v3d->ob_centre_cursor = false;
342         v3d->flag2 &= ~V3D_LOCK_CAMERA;
343 }
344
345 /**
346  * For viewport operators that exit camera perspective.
347  *
348  * \note This differs from simply setting ``rv3d->persp = persp`` because it
349  * sets the ``ofs`` and ``dist`` values of the viewport so it matches the camera,
350  * otherwise switching out of camera view may jump to a different part of the scene.
351  */
352 void ED_view3d_persp_switch_from_camera(View3D *v3d, RegionView3D *rv3d, const char persp)
353 {
354         BLI_assert(rv3d->persp == RV3D_CAMOB);
355         BLI_assert(persp != RV3D_CAMOB);
356
357         if (v3d->camera) {
358                 rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
359                 ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
360         }
361
362         if (!ED_view3d_camera_lock_check(v3d, rv3d)) {
363                 rv3d->persp = persp;
364         }
365 }
366 /**
367  * Action to take when rotating the view,
368  * handle auto-persp and logic for switching out of views.
369  *
370  * shared with NDOF.
371  */
372 bool ED_view3d_persp_ensure(struct View3D *v3d, ARegion *ar)
373 {
374         RegionView3D *rv3d = ar->regiondata;
375         const bool autopersp = (U.uiflag & USER_AUTOPERSP) != 0;
376
377         BLI_assert((rv3d->viewlock & RV3D_LOCKED) == 0);
378
379         if (ED_view3d_camera_lock_check(v3d, rv3d))
380                 return false;
381
382         if (rv3d->persp != RV3D_PERSP) {
383                 if (rv3d->persp == RV3D_CAMOB) {
384                         /* If autopersp and previous view was an axis one, switch back to PERSP mode, else reuse previous mode. */
385                         char persp = (autopersp && RV3D_VIEW_IS_AXIS(rv3d->lview)) ? RV3D_PERSP : rv3d->lpersp;
386                         ED_view3d_persp_switch_from_camera(v3d, rv3d, persp);
387                 }
388                 else if (autopersp && RV3D_VIEW_IS_AXIS(rv3d->view)) {
389                         rv3d->persp = RV3D_PERSP;
390                 }
391                 return true;
392         }
393
394         return false;
395 }
396
397 /** \} */
398
399 /* -------------------------------------------------------------------- */
400 /** \name Camera Lock API
401  *
402  * Lock the camera to the view-port, allowing view manipulation to transform the camera.
403  * \{ */
404
405 /**
406  * \return true when the view-port is locked to its camera.
407  */
408 bool ED_view3d_camera_lock_check(const View3D *v3d, const RegionView3D *rv3d)
409 {
410         return ((v3d->camera) &&
411                 (!ID_IS_LINKED(v3d->camera)) &&
412                 (v3d->flag2 & V3D_LOCK_CAMERA) &&
413                 (rv3d->persp == RV3D_CAMOB));
414 }
415
416 /**
417  * Apply the camera object transformation to the view-port.
418  * (needed so we can use regular view-port manipulation operators, that sync back to the camera).
419  */
420 void ED_view3d_camera_lock_init_ex(View3D *v3d, RegionView3D *rv3d, const bool calc_dist)
421 {
422         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
423                 if (calc_dist) {
424                         /* using a fallback dist is OK here since ED_view3d_from_object() compensates for it */
425                         rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
426                 }
427                 ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
428         }
429 }
430
431 void ED_view3d_camera_lock_init(View3D *v3d, RegionView3D *rv3d)
432 {
433         ED_view3d_camera_lock_init_ex(v3d, rv3d, true);
434 }
435
436 /**
437  * Apply the view-port transformation back to the camera object.
438  *
439  * \return true if the camera is moved.
440  */
441 bool ED_view3d_camera_lock_sync(View3D *v3d, RegionView3D *rv3d)
442 {
443         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
444                 ObjectTfmProtectedChannels obtfm;
445                 Object *root_parent;
446
447                 if ((U.uiflag & USER_CAM_LOCK_NO_PARENT) == 0 && (root_parent = v3d->camera->parent)) {
448                         Object *ob_update;
449                         float tmat[4][4];
450                         float imat[4][4];
451                         float view_mat[4][4];
452                         float diff_mat[4][4];
453                         float parent_mat[4][4];
454
455                         while (root_parent->parent) {
456                                 root_parent = root_parent->parent;
457                         }
458
459                         ED_view3d_to_m4(view_mat, rv3d->ofs, rv3d->viewquat, rv3d->dist);
460
461                         normalize_m4_m4(tmat, v3d->camera->obmat);
462
463                         invert_m4_m4(imat, tmat);
464                         mul_m4_m4m4(diff_mat, view_mat, imat);
465
466                         mul_m4_m4m4(parent_mat, diff_mat, root_parent->obmat);
467
468                         BKE_object_tfm_protected_backup(root_parent, &obtfm);
469                         BKE_object_apply_mat4(root_parent, parent_mat, true, false);
470                         BKE_object_tfm_protected_restore(root_parent, &obtfm, root_parent->protectflag);
471
472                         ob_update = v3d->camera;
473                         while (ob_update) {
474                                 DEG_id_tag_update(&ob_update->id, OB_RECALC_OB);
475                                 WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, ob_update);
476                                 ob_update = ob_update->parent;
477                         }
478                 }
479                 else {
480                         /* always maintain the same scale */
481                         const short protect_scale_all = (OB_LOCK_SCALEX | OB_LOCK_SCALEY | OB_LOCK_SCALEZ);
482                         BKE_object_tfm_protected_backup(v3d->camera, &obtfm);
483                         ED_view3d_to_object(v3d->camera, rv3d->ofs, rv3d->viewquat, rv3d->dist);
484                         BKE_object_tfm_protected_restore(v3d->camera, &obtfm, v3d->camera->protectflag | protect_scale_all);
485
486                         DEG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
487                         WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, v3d->camera);
488                 }
489
490                 return true;
491         }
492         else {
493                 return false;
494         }
495 }
496
497 bool ED_view3d_camera_autokey(
498         Scene *scene, ID *id_key,
499         struct bContext *C, const bool do_rotate, const bool do_translate)
500 {
501         if (autokeyframe_cfra_can_key(scene, id_key)) {
502                 const float cfra = (float)CFRA;
503                 ListBase dsources = {NULL, NULL};
504
505                 /* add data-source override for the camera object */
506                 ANIM_relative_keyingset_add_source(&dsources, id_key, NULL, NULL);
507
508                 /* insert keyframes
509                  * 1) on the first frame
510                  * 2) on each subsequent frame
511                  *    TODO: need to check in future that frame changed before doing this
512                  */
513                 if (do_rotate) {
514                         struct KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_ROTATION_ID);
515                         ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, cfra);
516                 }
517                 if (do_translate) {
518                         struct KeyingSet *ks = ANIM_get_keyingset_for_autokeying(scene, ANIM_KS_LOCATION_ID);
519                         ANIM_apply_keyingset(C, &dsources, NULL, ks, MODIFYKEY_MODE_INSERT, cfra);
520                 }
521
522                 /* free temp data */
523                 BLI_freelistN(&dsources);
524
525                 return true;
526         }
527         else {
528                 return false;
529         }
530 }
531
532 /**
533  * Call after modifying a locked view.
534  *
535  * \note Not every view edit currently auto-keys (numpad for eg),
536  * this is complicated because of smoothview.
537  */
538 bool ED_view3d_camera_lock_autokey(
539         View3D *v3d, RegionView3D *rv3d,
540         struct bContext *C, const bool do_rotate, const bool do_translate)
541 {
542         /* similar to ED_view3d_cameracontrol_update */
543         if (ED_view3d_camera_lock_check(v3d, rv3d)) {
544                 Scene *scene = CTX_data_scene(C);
545                 ID *id_key;
546                 Object *root_parent;
547                 if ((U.uiflag & USER_CAM_LOCK_NO_PARENT) == 0 && (root_parent = v3d->camera->parent)) {
548                         while (root_parent->parent) {
549                                 root_parent = root_parent->parent;
550                         }
551                         id_key = &root_parent->id;
552                 }
553                 else {
554                         id_key = &v3d->camera->id;
555                 }
556
557                 return ED_view3d_camera_autokey(scene, id_key, C, do_rotate, do_translate);
558         }
559         else {
560                 return false;
561         }
562 }
563
564 /** \} */
565
566
567
568 /* -------------------------------------------------------------------- */
569 /** \name Box View Support
570  *
571  * Use with quad-split so each view is clipped by the bounds of each view axis.
572  * \{ */
573
574 static void view3d_boxview_clip(ScrArea *sa)
575 {
576         ARegion *ar;
577         BoundBox *bb = MEM_callocN(sizeof(BoundBox), "clipbb");
578         float clip[6][4];
579         float x1 = 0.0f, y1 = 0.0f, z1 = 0.0f, ofs[3] = {0.0f, 0.0f, 0.0f};
580         int val;
581
582         /* create bounding box */
583         for (ar = sa->regionbase.first; ar; ar = ar->next) {
584                 if (ar->regiontype == RGN_TYPE_WINDOW) {
585                         RegionView3D *rv3d = ar->regiondata;
586
587                         if (rv3d->viewlock & RV3D_BOXCLIP) {
588                                 if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) {
589                                         if (ar->winx > ar->winy) x1 = rv3d->dist;
590                                         else x1 = ar->winx * rv3d->dist / ar->winy;
591
592                                         if (ar->winx > ar->winy) y1 = ar->winy * rv3d->dist / ar->winx;
593                                         else y1 = rv3d->dist;
594                                         copy_v2_v2(ofs, rv3d->ofs);
595                                 }
596                                 else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) {
597                                         ofs[2] = rv3d->ofs[2];
598
599                                         if (ar->winx > ar->winy) z1 = ar->winy * rv3d->dist / ar->winx;
600                                         else z1 = rv3d->dist;
601                                 }
602                         }
603                 }
604         }
605
606         for (val = 0; val < 8; val++) {
607                 if (ELEM(val, 0, 3, 4, 7))
608                         bb->vec[val][0] = -x1 - ofs[0];
609                 else
610                         bb->vec[val][0] =  x1 - ofs[0];
611
612                 if (ELEM(val, 0, 1, 4, 5))
613                         bb->vec[val][1] = -y1 - ofs[1];
614                 else
615                         bb->vec[val][1] =  y1 - ofs[1];
616
617                 if (val > 3)
618                         bb->vec[val][2] = -z1 - ofs[2];
619                 else
620                         bb->vec[val][2] =  z1 - ofs[2];
621         }
622
623         /* normals for plane equations */
624         normal_tri_v3(clip[0], bb->vec[0], bb->vec[1], bb->vec[4]);
625         normal_tri_v3(clip[1], bb->vec[1], bb->vec[2], bb->vec[5]);
626         normal_tri_v3(clip[2], bb->vec[2], bb->vec[3], bb->vec[6]);
627         normal_tri_v3(clip[3], bb->vec[3], bb->vec[0], bb->vec[7]);
628         normal_tri_v3(clip[4], bb->vec[4], bb->vec[5], bb->vec[6]);
629         normal_tri_v3(clip[5], bb->vec[0], bb->vec[2], bb->vec[1]);
630
631         /* then plane equations */
632         for (val = 0; val < 6; val++) {
633                 clip[val][3] = -dot_v3v3(clip[val], bb->vec[val % 5]);
634         }
635
636         /* create bounding box */
637         for (ar = sa->regionbase.first; ar; ar = ar->next) {
638                 if (ar->regiontype == RGN_TYPE_WINDOW) {
639                         RegionView3D *rv3d = ar->regiondata;
640
641                         if (rv3d->viewlock & RV3D_BOXCLIP) {
642                                 rv3d->rflag |= RV3D_CLIPPING;
643                                 memcpy(rv3d->clip, clip, sizeof(clip));
644                                 if (rv3d->clipbb) MEM_freeN(rv3d->clipbb);
645                                 rv3d->clipbb = MEM_dupallocN(bb);
646                         }
647                 }
648         }
649         MEM_freeN(bb);
650 }
651
652 /**
653  * Find which axis values are shared between both views and copy to \a rv3d_dst
654  * taking axis flipping into account.
655  */
656 static void view3d_boxview_sync_axis(RegionView3D *rv3d_dst, RegionView3D *rv3d_src)
657 {
658         /* absolute axis values above this are considered to be set (will be ~1.0f) */
659         const float axis_eps = 0.5f;
660         float viewinv[4];
661
662         /* use the view rotation to identify which axis to sync on */
663         float view_axis_all[4][3] = {
664             {1.0f, 0.0f, 0.0f},
665             {0.0f, 1.0f, 0.0f},
666             {1.0f, 0.0f, 0.0f},
667             {0.0f, 1.0f, 0.0f}};
668
669         float *view_src_x = &view_axis_all[0][0];
670         float *view_src_y = &view_axis_all[1][0];
671
672         float *view_dst_x = &view_axis_all[2][0];
673         float *view_dst_y = &view_axis_all[3][0];
674         int i;
675
676
677         /* we could use rv3d->viewinv, but better not depend on view matrix being updated */
678         if (UNLIKELY(ED_view3d_quat_from_axis_view(rv3d_src->view, viewinv) == false)) {
679                 return;
680         }
681         invert_qt_normalized(viewinv);
682         mul_qt_v3(viewinv, view_src_x);
683         mul_qt_v3(viewinv, view_src_y);
684
685         if (UNLIKELY(ED_view3d_quat_from_axis_view(rv3d_dst->view, viewinv) == false)) {
686                 return;
687         }
688         invert_qt_normalized(viewinv);
689         mul_qt_v3(viewinv, view_dst_x);
690         mul_qt_v3(viewinv, view_dst_y);
691
692         /* check source and dest have a matching axis */
693         for (i = 0; i < 3; i++) {
694                 if (((fabsf(view_src_x[i]) > axis_eps) || (fabsf(view_src_y[i]) > axis_eps)) &&
695                     ((fabsf(view_dst_x[i]) > axis_eps) || (fabsf(view_dst_y[i]) > axis_eps)))
696                 {
697                         rv3d_dst->ofs[i] = rv3d_src->ofs[i];
698                 }
699         }
700 }
701
702 /* sync center/zoom view of region to others, for view transforms */
703 void view3d_boxview_sync(ScrArea *sa, ARegion *ar)
704 {
705         ARegion *artest;
706         RegionView3D *rv3d = ar->regiondata;
707         short clip = 0;
708
709         for (artest = sa->regionbase.first; artest; artest = artest->next) {
710                 if (artest != ar && artest->regiontype == RGN_TYPE_WINDOW) {
711                         RegionView3D *rv3dtest = artest->regiondata;
712
713                         if (rv3dtest->viewlock & RV3D_LOCKED) {
714                                 rv3dtest->dist = rv3d->dist;
715                                 view3d_boxview_sync_axis(rv3dtest, rv3d);
716                                 clip |= rv3dtest->viewlock & RV3D_BOXCLIP;
717
718                                 ED_region_tag_redraw(artest);
719                         }
720                 }
721         }
722
723         if (clip) {
724                 view3d_boxview_clip(sa);
725         }
726 }
727
728 /* for home, center etc */
729 void view3d_boxview_copy(ScrArea *sa, ARegion *ar)
730 {
731         ARegion *artest;
732         RegionView3D *rv3d = ar->regiondata;
733         bool clip = false;
734
735         for (artest = sa->regionbase.first; artest; artest = artest->next) {
736                 if (artest != ar && artest->regiontype == RGN_TYPE_WINDOW) {
737                         RegionView3D *rv3dtest = artest->regiondata;
738
739                         if (rv3dtest->viewlock) {
740                                 rv3dtest->dist = rv3d->dist;
741                                 copy_v3_v3(rv3dtest->ofs, rv3d->ofs);
742                                 ED_region_tag_redraw(artest);
743
744                                 clip |= ((rv3dtest->viewlock & RV3D_BOXCLIP) != 0);
745                         }
746                 }
747         }
748
749         if (clip) {
750                 view3d_boxview_clip(sa);
751         }
752 }
753
754 /* 'clip' is used to know if our clip setting has changed */
755 void ED_view3d_quadview_update(ScrArea *sa, ARegion *ar, bool do_clip)
756 {
757         ARegion *ar_sync = NULL;
758         RegionView3D *rv3d = ar->regiondata;
759         short viewlock;
760         /* this function copies flags from the first of the 3 other quadview
761          * regions to the 2 other, so it assumes this is the region whose
762          * properties are always being edited, weak */
763         viewlock = rv3d->viewlock;
764
765         if ((viewlock & RV3D_LOCKED) == 0) {
766                 do_clip = (viewlock & RV3D_BOXCLIP) != 0;
767                 viewlock = 0;
768         }
769         else if ((viewlock & RV3D_BOXVIEW) == 0 && (viewlock & RV3D_BOXCLIP) != 0) {
770                 do_clip = true;
771                 viewlock &= ~RV3D_BOXCLIP;
772         }
773
774         for (; ar; ar = ar->prev) {
775                 if (ar->alignment == RGN_ALIGN_QSPLIT) {
776                         rv3d = ar->regiondata;
777                         rv3d->viewlock = viewlock;
778
779                         if (do_clip && (viewlock & RV3D_BOXCLIP) == 0) {
780                                 rv3d->rflag &= ~RV3D_BOXCLIP;
781                         }
782
783                         /* use ar_sync so we sync with one of the aligned views below
784                          * else the view jumps on changing view settings like 'clip'
785                          * since it copies from the perspective view */
786                         ar_sync = ar;
787                 }
788         }
789
790         if (rv3d->viewlock & RV3D_BOXVIEW) {
791                 view3d_boxview_sync(sa, ar_sync ? ar_sync : sa->regionbase.last);
792         }
793
794         /* ensure locked regions have an axis, locked user views don't make much sense */
795         if (viewlock & RV3D_LOCKED) {
796                 int index_qsplit = 0;
797                 for (ar = sa->regionbase.first; ar; ar = ar->next) {
798                         if (ar->alignment == RGN_ALIGN_QSPLIT) {
799                                 rv3d = ar->regiondata;
800                                 if (rv3d->viewlock) {
801                                         if (!RV3D_VIEW_IS_AXIS(rv3d->view)) {
802                                                 rv3d->view = ED_view3d_lock_view_from_index(index_qsplit);
803                                                 rv3d->persp = RV3D_ORTHO;
804                                                 ED_view3d_lock(rv3d);
805                                         }
806                                 }
807                                 index_qsplit++;
808                         }
809                 }
810         }
811
812         ED_area_tag_redraw(sa);
813 }
814
815 /** \} */
816
817 /* -------------------------------------------------------------------- */
818 /** \name View Auto-Depth Utilities
819  * \{ */
820
821 static float view_autodist_depth_margin(ARegion *ar, const int mval[2], int margin)
822 {
823         ViewDepths depth_temp = {0};
824         rcti rect;
825         float depth_close;
826
827         if (margin == 0) {
828                 /* Get Z Depths, needed for perspective, nice for ortho */
829                 rect.xmin = mval[0];
830                 rect.ymin = mval[1];
831                 rect.xmax = mval[0] + 1;
832                 rect.ymax = mval[1] + 1;
833         }
834         else {
835                 BLI_rcti_init_pt_radius(&rect, mval, margin);
836         }
837
838         view3d_update_depths_rect(ar, &depth_temp, &rect);
839         depth_close = view3d_depth_near(&depth_temp);
840         MEM_SAFE_FREE(depth_temp.depths);
841         return depth_close;
842 }
843
844 /**
845  * Get the world-space 3d location from a screen-space 2d point.
846  *
847  * \param mval: Input screen-space pixel location.
848  * \param mouse_worldloc: Output world-space location.
849  * \param fallback_depth_pt: Use this points depth when no depth can be found.
850  */
851 bool ED_view3d_autodist(
852         const EvaluationContext *eval_ctx, struct Depsgraph *graph, ARegion *ar, View3D *v3d,
853         const int mval[2], float mouse_worldloc[3],
854         const bool alphaoverride, const float fallback_depth_pt[3])
855 {
856         float depth_close;
857         int margin_arr[] = {0, 2, 4};
858         int i;
859         bool depth_ok = false;
860
861         /* Get Z Depths, needed for perspective, nice for ortho */
862         ED_view3d_draw_depth(eval_ctx, graph, ar, v3d, alphaoverride);
863
864         /* Attempt with low margin's first */
865         i = 0;
866         do {
867                 depth_close = view_autodist_depth_margin(ar, mval, margin_arr[i++] * U.pixelsize);
868                 depth_ok = (depth_close != FLT_MAX);
869         } while ((depth_ok == false) && (i < ARRAY_SIZE(margin_arr)));
870
871         if (depth_ok) {
872                 float centx = (float)mval[0] + 0.5f;
873                 float centy = (float)mval[1] + 0.5f;
874
875                 if (ED_view3d_unproject(ar, centx, centy, depth_close, mouse_worldloc)) {
876                         return true;
877                 }
878         }
879
880         if (fallback_depth_pt) {
881                 ED_view3d_win_to_3d_int(v3d, ar, fallback_depth_pt, mval, mouse_worldloc);
882                 return true;
883         }
884         else {
885                 return false;
886         }
887 }
888
889 void ED_view3d_autodist_init(
890         const EvaluationContext *eval_ctx, struct Depsgraph *graph,
891         ARegion *ar, View3D *v3d, int mode)
892 {
893         /* Get Z Depths, needed for perspective, nice for ortho */
894         switch (mode) {
895                 case 0:
896                         ED_view3d_draw_depth(eval_ctx, graph, ar, v3d, true);
897                         break;
898                 case 1:
899                 {
900                         Scene *scene = DEG_get_evaluated_scene(graph);
901                         ED_view3d_draw_depth_gpencil(eval_ctx, scene, ar, v3d);
902                         break;
903                 }
904         }
905 }
906
907 /* no 4x4 sampling, run #ED_view3d_autodist_init first */
908 bool ED_view3d_autodist_simple(ARegion *ar, const int mval[2], float mouse_worldloc[3],
909                                int margin, float *force_depth)
910 {
911         float depth;
912
913         /* Get Z Depths, needed for perspective, nice for ortho */
914         if (force_depth)
915                 depth = *force_depth;
916         else
917                 depth = view_autodist_depth_margin(ar, mval, margin);
918
919         if (depth == FLT_MAX)
920                 return false;
921
922         float centx = (float)mval[0] + 0.5f;
923         float centy = (float)mval[1] + 0.5f;
924         return ED_view3d_unproject(ar, centx, centy, depth, mouse_worldloc);
925 }
926
927 bool ED_view3d_autodist_depth(ARegion *ar, const int mval[2], int margin, float *depth)
928 {
929         *depth = view_autodist_depth_margin(ar, mval, margin);
930
931         return (*depth != FLT_MAX);
932 }
933
934 static bool depth_segment_cb(int x, int y, void *userData)
935 {
936         struct { ARegion *ar; int margin; float depth; } *data = userData;
937         int mval[2];
938         float depth;
939
940         mval[0] = x;
941         mval[1] = y;
942
943         depth = view_autodist_depth_margin(data->ar, mval, data->margin);
944
945         if (depth != FLT_MAX) {
946                 data->depth = depth;
947                 return 0;
948         }
949         else {
950                 return 1;
951         }
952 }
953
954 bool ED_view3d_autodist_depth_seg(
955         ARegion *ar, const int mval_sta[2], const int mval_end[2],
956         int margin, float *depth)
957 {
958         struct { ARegion *ar; int margin; float depth; } data = {NULL};
959         int p1[2];
960         int p2[2];
961
962         data.ar = ar;
963         data.margin = margin;
964         data.depth = FLT_MAX;
965
966         copy_v2_v2_int(p1, mval_sta);
967         copy_v2_v2_int(p2, mval_end);
968
969         BLI_bitmap_draw_2d_line_v2v2i(p1, p2, depth_segment_cb, &data);
970
971         *depth = data.depth;
972
973         return (*depth != FLT_MAX);
974 }
975
976 /** \} */
977
978 /* -------------------------------------------------------------------- */
979 /** \name View Radius/Distance Utilities
980  *
981  * Use to calculate a distance to a point based on it's radius.
982  * \{ */
983
984 float ED_view3d_radius_to_dist_persp(const float angle, const float radius)
985 {
986         return radius * (1.0f / tanf(angle / 2.0f));
987 }
988
989 float ED_view3d_radius_to_dist_ortho(const float lens, const float radius)
990 {
991         return radius / (DEFAULT_SENSOR_WIDTH / lens);
992 }
993
994 /**
995  * Return a new RegionView3D.dist value to fit the \a radius.
996  *
997  * \note Depth isn't taken into account, this will fit a flat plane exactly,
998  * but points towards the view (with a perspective projection),
999  * may be within the radius but outside the view. eg:
1000  *
1001  * <pre>
1002  *           +
1003  * pt --> + /^ radius
1004  *         / |
1005  *        /  |
1006  * view  +   +
1007  *        \  |
1008  *         \ |
1009  *          \|
1010  *           +
1011  * </pre>
1012  *
1013  * \param ar  Can be NULL if \a use_aspect is false.
1014  * \param persp  Allow the caller to tell what kind of perspective to use (ortho/view/camera)
1015  * \param use_aspect  Increase the distance to account for non 1:1 view aspect.
1016  * \param radius  The radius will be fitted exactly, typically pre-scaled by a margin (#VIEW3D_MARGIN).
1017  */
1018 float ED_view3d_radius_to_dist(
1019         const View3D *v3d, const ARegion *ar,
1020         const char persp, const bool use_aspect,
1021         const float radius)
1022 {
1023         float dist;
1024
1025         BLI_assert(ELEM(persp, RV3D_ORTHO, RV3D_PERSP, RV3D_CAMOB));
1026         BLI_assert((persp != RV3D_CAMOB) || v3d->camera);
1027
1028         if (persp == RV3D_ORTHO) {
1029                 dist = ED_view3d_radius_to_dist_ortho(v3d->lens, radius);
1030         }
1031         else {
1032                 float lens, sensor_size, zoom;
1033                 float angle;
1034
1035                 if (persp == RV3D_CAMOB) {
1036                         CameraParams params;
1037                         BKE_camera_params_init(&params);
1038                         params.clipsta = v3d->near;
1039                         params.clipend = v3d->far;
1040                         BKE_camera_params_from_object(&params, v3d->camera);
1041
1042                         lens = params.lens;
1043                         sensor_size = BKE_camera_sensor_size(params.sensor_fit, params.sensor_x, params.sensor_y);
1044
1045                         /* ignore 'rv3d->camzoom' because we want to fit to the cameras frame */
1046                         zoom = CAMERA_PARAM_ZOOM_INIT_CAMOB;
1047                 }
1048                 else {
1049                         lens = v3d->lens;
1050                         sensor_size = DEFAULT_SENSOR_WIDTH;
1051                         zoom = CAMERA_PARAM_ZOOM_INIT_PERSP;
1052                 }
1053
1054                 angle = focallength_to_fov(lens, sensor_size);
1055
1056                 /* zoom influences lens, correct this by scaling the angle as a distance (by the zoom-level) */
1057                 angle = atanf(tanf(angle / 2.0f) * zoom) * 2.0f;
1058
1059                 dist = ED_view3d_radius_to_dist_persp(angle, radius);
1060         }
1061
1062         if (use_aspect) {
1063                 const RegionView3D *rv3d = ar->regiondata;
1064
1065                 float winx, winy;
1066
1067                 if (persp == RV3D_CAMOB) {
1068                         /* camera frame x/y in pixels */
1069                         winx = ar->winx / rv3d->viewcamtexcofac[0];
1070                         winy = ar->winy / rv3d->viewcamtexcofac[1];
1071                 }
1072                 else {
1073                         winx = ar->winx;
1074                         winy = ar->winy;
1075                 }
1076
1077                 if (winx && winy) {
1078                         float aspect = winx / winy;
1079                         if (aspect < 1.0f) {
1080                                 aspect = 1.0f / aspect;
1081                         }
1082                         dist *= aspect;
1083                 }
1084         }
1085
1086         return dist;
1087 }
1088
1089 /** \} */
1090
1091 /* -------------------------------------------------------------------- */
1092 /** \name View Distance Utilities
1093  * \{ */
1094
1095 /* problem - ofs[3] can be on same location as camera itself.
1096  * Blender needs proper dist value for zoom.
1097  * use fallback_dist to override small values
1098  */
1099 float ED_view3d_offset_distance(float mat[4][4], const float ofs[3], const float fallback_dist)
1100 {
1101         float pos[4] = {0.0f, 0.0f, 0.0f, 1.0f};
1102         float dir[4] = {0.0f, 0.0f, 1.0f, 0.0f};
1103         float dist;
1104
1105         mul_m4_v4(mat, pos);
1106         add_v3_v3(pos, ofs);
1107         mul_m4_v4(mat, dir);
1108         normalize_v3(dir);
1109
1110         dist = dot_v3v3(pos, dir);
1111
1112         if ((dist < FLT_EPSILON) && (fallback_dist != 0.0f)) {
1113                 dist = fallback_dist;
1114         }
1115
1116         return dist;
1117 }
1118
1119 /**
1120  * Set the dist without moving the view (compensate with #RegionView3D.ofs)
1121  *
1122  * \note take care that viewinv is up to date, #ED_view3d_update_viewmat first.
1123  */
1124 void ED_view3d_distance_set(RegionView3D *rv3d, const float dist)
1125 {
1126         float viewinv[4];
1127         float tvec[3];
1128
1129         BLI_assert(dist >= 0.0f);
1130
1131         copy_v3_fl3(tvec, 0.0f, 0.0f, rv3d->dist - dist);
1132         /* rv3d->viewinv isn't always valid */
1133 #if 0
1134         mul_mat3_m4_v3(rv3d->viewinv, tvec);
1135 #else
1136         invert_qt_qt_normalized(viewinv, rv3d->viewquat);
1137         mul_qt_v3(viewinv, tvec);
1138 #endif
1139         sub_v3_v3(rv3d->ofs, tvec);
1140
1141         rv3d->dist = dist;
1142 }
1143
1144 /** \} */
1145
1146 /* -------------------------------------------------------------------- */
1147 /** \name View Axis Utilities
1148  * \{ */
1149 static float view3d_quat_axis[6][4] = {
1150         {M_SQRT1_2, -M_SQRT1_2, 0.0f, 0.0f},    /* RV3D_VIEW_FRONT */
1151         {0.0f, 0.0f, -M_SQRT1_2, -M_SQRT1_2},   /* RV3D_VIEW_BACK */
1152         {0.5f, -0.5f, 0.5f, 0.5f},              /* RV3D_VIEW_LEFT */
1153         {0.5f, -0.5f, -0.5f, -0.5f},            /* RV3D_VIEW_RIGHT */
1154         {1.0f, 0.0f, 0.0f, 0.0f},               /* RV3D_VIEW_TOP */
1155         {0.0f, -1.0f, 0.0f, 0.0f},              /* RV3D_VIEW_BOTTOM */
1156 };
1157
1158
1159 bool ED_view3d_quat_from_axis_view(const char view, float quat[4])
1160 {
1161         if (RV3D_VIEW_IS_AXIS(view)) {
1162                 copy_qt_qt(quat, view3d_quat_axis[view - RV3D_VIEW_FRONT]);
1163                 return true;
1164         }
1165         else {
1166                 return false;
1167         }
1168 }
1169
1170 char ED_view3d_quat_to_axis_view(const float quat[4], const float epsilon)
1171 {
1172         /* quat values are all unit length */
1173
1174         char view;
1175
1176         for (view = RV3D_VIEW_FRONT; view <= RV3D_VIEW_BOTTOM; view++) {
1177                 if (fabsf(angle_signed_qtqt(quat, view3d_quat_axis[view - RV3D_VIEW_FRONT])) < epsilon) {
1178                         return view;
1179                 }
1180         }
1181
1182         return RV3D_VIEW_USER;
1183 }
1184
1185 char ED_view3d_lock_view_from_index(int index)
1186 {
1187         switch (index) {
1188                 case 0:  return RV3D_VIEW_FRONT;
1189                 case 1:  return RV3D_VIEW_TOP;
1190                 case 2:  return RV3D_VIEW_RIGHT;
1191                 default: return RV3D_VIEW_USER;
1192         }
1193
1194 }
1195
1196 char ED_view3d_axis_view_opposite(char view)
1197 {
1198         switch (view) {
1199                 case RV3D_VIEW_FRONT:   return RV3D_VIEW_BACK;
1200                 case RV3D_VIEW_BACK:    return RV3D_VIEW_FRONT;
1201                 case RV3D_VIEW_LEFT:    return RV3D_VIEW_RIGHT;
1202                 case RV3D_VIEW_RIGHT:   return RV3D_VIEW_LEFT;
1203                 case RV3D_VIEW_TOP:     return RV3D_VIEW_BOTTOM;
1204                 case RV3D_VIEW_BOTTOM:  return RV3D_VIEW_TOP;
1205         }
1206
1207         return RV3D_VIEW_USER;
1208 }
1209
1210
1211 bool ED_view3d_lock(RegionView3D *rv3d)
1212 {
1213         return ED_view3d_quat_from_axis_view(rv3d->view, rv3d->viewquat);
1214 }
1215
1216 /** \} */
1217
1218 /* -------------------------------------------------------------------- */
1219 /** \name View Transform Utilities
1220  * \{ */
1221
1222 /**
1223  * Set the view transformation from a 4x4 matrix.
1224  *
1225  * \param mat The view 4x4 transformation matrix to assign.
1226  * \param ofs The view offset, normally from RegionView3D.ofs.
1227  * \param quat The view rotation, quaternion normally from RegionView3D.viewquat.
1228  * \param dist The view distance from ofs, normally from RegionView3D.dist.
1229  */
1230 void ED_view3d_from_m4(float mat[4][4], float ofs[3], float quat[4], float *dist)
1231 {
1232         float nmat[3][3];
1233
1234         /* dist depends on offset */
1235         BLI_assert(dist == NULL || ofs != NULL);
1236
1237         copy_m3_m4(nmat, mat);
1238         normalize_m3(nmat);
1239
1240         /* Offset */
1241         if (ofs)
1242                 negate_v3_v3(ofs, mat[3]);
1243
1244         /* Quat */
1245         if (quat) {
1246                 mat3_normalized_to_quat(quat, nmat);
1247                 invert_qt_normalized(quat);
1248         }
1249
1250         if (ofs && dist) {
1251                 madd_v3_v3fl(ofs, nmat[2], *dist);
1252         }
1253 }
1254
1255 /**
1256  * Calculate the view transformation matrix from RegionView3D input.
1257  * The resulting matrix is equivalent to RegionView3D.viewinv
1258  * \param mat The view 4x4 transformation matrix to calculate.
1259  * \param ofs The view offset, normally from RegionView3D.ofs.
1260  * \param quat The view rotation, quaternion normally from RegionView3D.viewquat.
1261  * \param dist The view distance from ofs, normally from RegionView3D.dist.
1262  */
1263 void ED_view3d_to_m4(float mat[4][4], const float ofs[3], const float quat[4], const float dist)
1264 {
1265         float iviewquat[4] = {-quat[0], quat[1], quat[2], quat[3]};
1266         float dvec[3] = {0.0f, 0.0f, dist};
1267
1268         quat_to_mat4(mat, iviewquat);
1269         mul_mat3_m4_v3(mat, dvec);
1270         sub_v3_v3v3(mat[3], dvec, ofs);
1271 }
1272
1273 /**
1274  * Set the RegionView3D members from an objects transformation and optionally lens.
1275  * \param ob The object to set the view to.
1276  * \param ofs The view offset to be set, normally from RegionView3D.ofs.
1277  * \param quat The view rotation to be set, quaternion normally from RegionView3D.viewquat.
1278  * \param dist The view distance from ofs to be set, normally from RegionView3D.dist.
1279  * \param lens The view lens angle set for cameras and lamps, normally from View3D.lens.
1280  */
1281 void ED_view3d_from_object(Object *ob, float ofs[3], float quat[4], float *dist, float *lens)
1282 {
1283         ED_view3d_from_m4(ob->obmat, ofs, quat, dist);
1284
1285         if (lens) {
1286                 CameraParams params;
1287
1288                 BKE_camera_params_init(&params);
1289                 BKE_camera_params_from_object(&params, ob);
1290                 *lens = params.lens;
1291         }
1292 }
1293
1294 /**
1295  * Set the object transformation from RegionView3D members.
1296  * \param ob The object which has the transformation assigned.
1297  * \param ofs The view offset, normally from RegionView3D.ofs.
1298  * \param quat The view rotation, quaternion normally from RegionView3D.viewquat.
1299  * \param dist The view distance from ofs, normally from RegionView3D.dist.
1300  */
1301 void ED_view3d_to_object(Object *ob, const float ofs[3], const float quat[4], const float dist)
1302 {
1303         float mat[4][4];
1304         ED_view3d_to_m4(mat, ofs, quat, dist);
1305         BKE_object_apply_mat4(ob, mat, true, true);
1306 }
1307
1308 /** \} */
1309
1310 /* -------------------------------------------------------------------- */
1311 /** \name Depth Buffer Utilities
1312  * \{ */
1313
1314 float ED_view3d_depth_read_cached(const ViewContext *vc, const int mval[2])
1315 {
1316         ViewDepths *vd = vc->rv3d->depths;
1317
1318         int x = mval[0];
1319         int y = mval[1];
1320
1321         if (vd && vd->depths && x > 0 && y > 0 && x < vd->w && y < vd->h) {
1322                 return vd->depths[y * vd->w + x];
1323         }
1324         else {
1325                 BLI_assert(1.0 <= vd->depth_range[1]);
1326                 return 1.0f;
1327         }
1328 }
1329
1330 bool ED_view3d_depth_read_cached_normal(
1331         const ViewContext *vc, const int mval[2],
1332         float r_normal[3])
1333 {
1334         /* Note: we could support passing in a radius.
1335          * For now just read 9 pixels. */
1336
1337         /* pixels surrounding */
1338         bool  depths_valid[9] = {false};
1339         float coords[9][3] = {{0}};
1340
1341         ARegion *ar = vc->ar;
1342         const ViewDepths *depths = vc->rv3d->depths;
1343
1344         for (int x = 0, i = 0; x < 2; x++) {
1345                 for (int y = 0; y < 2; y++) {
1346                         const int mval_ofs[2] = {mval[0] + (x - 1), mval[1] + (y - 1)};
1347
1348                         const double depth = (double)ED_view3d_depth_read_cached(vc, mval_ofs);
1349                         if ((depth > depths->depth_range[0]) && (depth < depths->depth_range[1])) {
1350                                 if (ED_view3d_depth_unproject(ar, mval_ofs, depth, coords[i])) {
1351                                         depths_valid[i] = true;
1352                                 }
1353                         }
1354                         i++;
1355                 }
1356         }
1357
1358         const int edges[2][6][2] = {
1359             /* x edges */
1360             {{0, 1}, {1, 2},
1361              {3, 4}, {4, 5},
1362              {6, 7}, {7, 8}},
1363             /* y edges */
1364             {{0, 3}, {3, 6},
1365              {1, 4}, {4, 7},
1366              {2, 5}, {5, 8}},
1367         };
1368
1369         float cross[2][3] = {{0.0f}};
1370
1371         for (int i = 0; i < 6; i++) {
1372                 for (int axis = 0; axis < 2; axis++) {
1373                         if (depths_valid[edges[axis][i][0]] && depths_valid[edges[axis][i][1]]) {
1374                                 float delta[3];
1375                                 sub_v3_v3v3(delta, coords[edges[axis][i][0]], coords[edges[axis][i][1]]);
1376                                 add_v3_v3(cross[axis], delta);
1377                         }
1378                 }
1379         }
1380
1381         cross_v3_v3v3(r_normal, cross[0], cross[1]);
1382
1383         if (normalize_v3(r_normal) != 0.0f) {
1384                 return true;
1385         }
1386         else {
1387                 return false;
1388         }
1389 }
1390
1391 bool ED_view3d_depth_unproject(
1392         const ARegion *ar,
1393         const int mval[2], const double depth,
1394         float r_location_world[3])
1395 {
1396         float centx = (float)mval[0] + 0.5f;
1397         float centy = (float)mval[1] + 0.5f;
1398         return ED_view3d_unproject(ar, centx, centy, depth, r_location_world);
1399 }
1400
1401 void ED_view3d_depth_tag_update(RegionView3D *rv3d)
1402 {
1403         if (rv3d->depths)
1404                 rv3d->depths->damaged = true;
1405 }
1406
1407 /** \} */