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