Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Tue, 23 Jan 2018 09:04:54 +0000 (20:04 +1100)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 23 Jan 2018 09:04:54 +0000 (20:04 +1100)
1  2 
build_files/cmake/macros.cmake
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_view.c

index 2e16b9238b349a98db88d46a4e10f8c389e944a3,f8350b9ab7f0159757ef76b5372db929bb538782..417c012b526dc38c1dab212115452a79ffa26d7f
@@@ -319,7 -319,7 +319,7 @@@ function(SETUP_LIBDIRS
                        link_directories(${JACK_LIBPATH})
                endif()
                if(WITH_CODEC_SNDFILE)
 -                      link_directories(${SNDFILE_LIBPATH})
 +                      link_directories(${LIBSNDFILE_LIBPATH})
                endif()
                if(WITH_FFTW3)
                        link_directories(${FFTW3_LIBPATH})
@@@ -400,7 -400,7 +400,7 @@@ function(setup_liblink
                target_link_libraries(${target} ${JACK_LIBRARIES})
        endif()
        if(WITH_CODEC_SNDFILE)
 -              target_link_libraries(${target} ${SNDFILE_LIBRARIES})
 +              target_link_libraries(${target} ${LIBSNDFILE_LIBRARIES})
        endif()
        if(WITH_SDL AND NOT WITH_SDL_DYNLOAD)
                target_link_libraries(${target} ${SDL_LIBRARY})
@@@ -548,12 -548,6 +548,12 @@@ function(SETUP_BLENDER_SORTED_LIBS
                endif()
        endif()
  
 +      if(WITH_AUDASPACE AND NOT WITH_SYSTEM_AUDASPACE)
 +              list(APPEND BLENDER_LINK_LIBS
 +                      audaspace
 +                      audaspace-py)
 +      endif()
 +
        # Sort libraries
        set(BLENDER_SORTED_LIBS
                bf_windowmanager
                bf_editor_curve
                bf_editor_gpencil
                bf_editor_interface
 +              bf_editor_manipulator_library
                bf_editor_mesh
                bf_editor_metaball
                bf_editor_object
                bf_editor_armature
                bf_editor_physics
                bf_editor_render
 +              bf_editor_scene
                bf_editor_screen
                bf_editor_sculpt_paint
                bf_editor_sound
                bf_python
                bf_python_ext
                bf_python_mathutils
 +              bf_python_gawain
                bf_python_bmesh
                bf_freestyle
                bf_ikplugin
                bf_alembic
                bf_bmesh
                bf_gpu
 +              bf_draw
                bf_blenloader
                bf_blenkernel
                bf_physics
                bf_nodes
                bf_rna
 +              bf_editor_manipulator_library  # rna -> manipulator bad-level calls
 +              bf_python
                bf_imbuf
                bf_blenlib
                bf_depsgraph
                bf_blenfont
                bf_blentranslation
                bf_intern_audaspace
 +              audaspace
 +              audaspace-py
                bf_intern_mikktspace
                bf_intern_dualcon
                bf_intern_cycles
                cycles_util
                cycles_subd
                bf_intern_opencolorio
 +              bf_intern_gawain
                bf_intern_eigen
                extern_rangetree
                extern_wcwidth
@@@ -1513,7 -1498,6 +1513,7 @@@ function(find_python_packag
                  NAMES
                    ${package}
                  HINTS
 +                  "${PYTHON_LIBPATH}/"
                    "${PYTHON_LIBPATH}/python${PYTHON_VERSION}/"
                    "${PYTHON_LIBPATH}/python${_PY_VER_MAJOR}/"
                  PATH_SUFFIXES
@@@ -1569,7 -1553,7 +1569,7 @@@ macro(openmp_delayloa
                endif()
  endmacro()
  
MACRO(WINDOWS_SIGN_TARGET target)
macro(WINDOWS_SIGN_TARGET target)
        if(WITH_WINDOWS_CODESIGN)
                if(!SIGNTOOL_EXE)
                        error("Codesigning is enabled, but signtool is not found")
                        )
                endif()
        endif()
ENDMACRO()
endmacro()
index d286e608de44d38ed847d123be72c6d811c3bf22,c401b6618f2b776fb2bbe35a7446f73fb5185ac0..1d97541e813043f59249d7b595fd1bfa10630c9e
@@@ -26,6 -26,8 +26,8 @@@
  
  /** \file blender/editors/space_view3d/view3d_edit.c
   *  \ingroup spview3d
+  *
+  * 3D view manipulation/operators.
   */
  
  #include <string.h>
@@@ -34,7 -36,6 +36,7 @@@
  #include <float.h>
  
  #include "DNA_armature_types.h"
 +#include "DNA_camera_types.h"
  #include "DNA_curve_types.h"
  #include "DNA_object_types.h"
  #include "DNA_scene_types.h"
@@@ -52,7 -53,6 +54,7 @@@
  #include "BKE_camera.h"
  #include "BKE_context.h"
  #include "BKE_font.h"
 +#include "BKE_layer.h"
  #include "BKE_library.h"
  #include "BKE_object.h"
  #include "BKE_paint.h"
  #include "BKE_scene.h"
  #include "BKE_screen.h"
  #include "BKE_action.h"
 -#include "BKE_depsgraph.h" /* for ED_view3d_camera_lock_sync */
  
 +#include "DEG_depsgraph.h"
  
  #include "BIF_gl.h"
 -#include "BIF_glutil.h"
  
  #include "WM_api.h"
  #include "WM_types.h"
@@@ -80,8 -81,6 +82,8 @@@
  #include "ED_gpencil.h"
  #include "ED_view3d.h"
  
 +#include "DEG_depsgraph_query.h"
 +
  #include "UI_resources.h"
  
  #include "PIL_time.h" /* smoothview */
  
  static bool view3d_ensure_persp(struct View3D *v3d, ARegion *ar);
  
+ /* -------------------------------------------------------------------- */
+ /** \name View Utilities
+  *
+  * Lock the camera to the view-port, allowing view manipulation to transform the camera.
+  * \{ */
+ /**
+  * Use to store the last view, before entering camera view.
+  */
+ void ED_view3d_lastview_store(RegionView3D *rv3d)
+ {
+       copy_qt_qt(rv3d->lviewquat, rv3d->viewquat);
+       rv3d->lview = rv3d->view;
+       if (rv3d->persp != RV3D_CAMOB) {
+               rv3d->lpersp = rv3d->persp;
+       }
+ }
+ void ED_view3D_lock_clear(View3D *v3d)
+ {
+       v3d->ob_centre = NULL;
+       v3d->ob_centre_bone[0] = '\0';
+       v3d->ob_centre_cursor = false;
+       v3d->flag2 &= ~V3D_LOCK_CAMERA;
+ }
  bool ED_view3d_offset_lock_check(const  View3D *v3d, const  RegionView3D *rv3d)
  {
        return (rv3d->persp != RV3D_CAMOB) && (v3d->ob_centre_cursor || v3d->ob_centre);
  }
  
- /* ********************** view3d_edit: view manipulations ********************* */
+ /**
+  * For viewport operators that exit camera persp.
+  *
+  * \note This differs from simply setting ``rv3d->persp = persp`` because it
+  * sets the ``ofs`` and ``dist`` values of the viewport so it matches the camera,
+  * otherwise switching out of camera view may jump to a different part of the scene.
+  */
+ static void view3d_persp_switch_from_camera(View3D *v3d, RegionView3D *rv3d, const char persp)
+ {
+       BLI_assert(rv3d->persp == RV3D_CAMOB);
+       BLI_assert(persp != RV3D_CAMOB);
+       if (v3d->camera) {
+               rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
+               ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
+       }
+       if (!ED_view3d_camera_lock_check(v3d, rv3d)) {
+               rv3d->persp = persp;
+       }
+ }
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Camera Lock API
+  *
+  * Lock the camera to the view-port, allowing view manipulation to transform the camera.
+  * \{ */
  
  /**
   * \return true when the view-port is locked to its camera.
@@@ -166,7 -219,7 +222,7 @@@ bool ED_view3d_camera_lock_sync(View3D 
  
                        ob_update = v3d->camera;
                        while (ob_update) {
 -                              DAG_id_tag_update(&ob_update->id, OB_RECALC_OB);
 +                              DEG_id_tag_update(&ob_update->id, OB_RECALC_OB);
                                WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, ob_update);
                                ob_update = ob_update->parent;
                        }
                        ED_view3d_to_object(v3d->camera, rv3d->ofs, rv3d->viewquat, rv3d->dist);
                        BKE_object_tfm_protected_restore(v3d->camera, &obtfm, v3d->camera->protectflag | protect_scale_all);
  
 -                      DAG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
 +                      DEG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
                        WM_main_add_notifier(NC_OBJECT | ND_TRANSFORM, v3d->camera);
                }
  
@@@ -256,29 -309,13 +312,13 @@@ bool ED_view3d_camera_lock_autokey
        }
  }
  
- /**
-  * For viewport operators that exit camera persp.
-  *
-  * \note This differs from simply setting ``rv3d->persp = persp`` because it
-  * sets the ``ofs`` and ``dist`` values of the viewport so it matches the camera,
-  * otherwise switching out of camera view may jump to a different part of the scene.
-  */
- static void view3d_persp_switch_from_camera(View3D *v3d, RegionView3D *rv3d, const char persp)
- {
-       BLI_assert(rv3d->persp == RV3D_CAMOB);
-       BLI_assert(persp != RV3D_CAMOB);
-       if (v3d->camera) {
-               rv3d->dist = ED_view3d_offset_distance(v3d->camera->obmat, rv3d->ofs, VIEW3D_DIST_FALLBACK);
-               ED_view3d_from_object(v3d->camera, rv3d->ofs, rv3d->viewquat, &rv3d->dist, NULL);
-       }
-       if (!ED_view3d_camera_lock_check(v3d, rv3d)) {
-               rv3d->persp = persp;
-       }
- }
+ /** \} */
  
- /* ********************* box view support ***************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Box View Support
+  *
+  * Use with quad-split so each view is clipped by the bounds of each view axis.
+  * \{ */
  
  static void view3d_boxview_clip(ScrArea *sa)
  {
@@@ -521,11 -558,14 +561,15 @@@ void ED_view3d_quadview_update(ScrArea 
        ED_area_tag_redraw(sa);
  }
  
- /* ************************** init for view ops **********************************/
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Generic View Operator Custom-Data
+  * \{ */
  
  typedef struct ViewOpsData {
        /* context pointers (assigned by viewops_data_alloc) */
 +      const Depsgraph *depsgraph;
        Scene *scene;
        ScrArea *sa;
        ARegion *ar;
@@@ -581,13 -621,6 +625,6 @@@ static void calctrackballvec(const rct
        vec[2] = -z;     /* yah yah! */
  }
  
- /* -------------------------------------------------------------------- */
- /* ViewOpsData */
- /** \name Generic View Operator Custom-Data.
-  * \{ */
  /**
   * Allocate and fill in context pointers for #ViewOpsData
   */
@@@ -597,7 -630,6 +634,7 @@@ static void viewops_data_alloc(bContex
  
        /* store data */
        op->customdata = vod;
 +      vod->depsgraph = CTX_data_depsgraph(C);
        vod->scene = CTX_data_scene(C);
        vod->sa = CTX_wm_area(C);
        vod->ar = CTX_wm_region(C);
@@@ -626,8 -658,7 +663,8 @@@ static bool view3d_orbit_calc_center(bC
        bool is_set = false;
  
        Scene *scene = CTX_data_scene(C);
 -      Object *ob_act = OBACT;
 +      ViewLayer *view_layer = CTX_data_view_layer(C);
 +      Object *ob_act = OBACT(view_layer);
  
        if (ob_act && (ob_act->mode & OB_MODE_ALL_PAINT) &&
            /* with weight-paint + pose-mode, fall through to using calculateTransformCenter */
        }
        else if (ob_act == NULL || ob_act->mode == OB_MODE_OBJECT) {
                /* object mode use boundbox centers */
 -              View3D *v3d = CTX_wm_view3d(C);
                Base *base;
                unsigned int tot = 0;
                float select_center[3];
  
                zero_v3(select_center);
 -              for (base = FIRSTBASE; base; base = base->next) {
 -                      if (TESTBASE(v3d, base)) {
 +              for (base = FIRSTBASE(view_layer); base; base = base->next) {
 +                      if (TESTBASE(base)) {
                                /* use the boundbox if we can */
                                Object *ob = base->object;
  
@@@ -746,18 -778,14 +783,18 @@@ static void viewops_data_create_ex
  
        /* we need the depth info before changing any viewport options */
        if (orbit_mode & VIEWOPS_ORBIT_DEPTH) {
 +              EvaluationContext eval_ctx;
 +              struct Depsgraph *graph = CTX_data_depsgraph(C);
                float fallback_depth_pt[3];
  
 +              CTX_data_eval_ctx(C, &eval_ctx);
 +
                view3d_operator_needs_opengl(C); /* needed for zbuf drawing */
  
                negate_v3_v3(fallback_depth_pt, rv3d->ofs);
  
                vod->use_dyn_ofs = ED_view3d_autodist(
 -                      vod->scene, vod->ar, vod->v3d,
 +                      &eval_ctx, graph, vod->ar, vod->v3d,
                        event->mval, vod->dyn_ofs, true, fallback_depth_pt);
        }
        else {
@@@ -875,9 -903,8 +912,9 @@@ static void viewops_data_create(bContex
  static void viewops_data_free(bContext *C, wmOperator *op)
  {
        ARegion *ar;
 +#if 0
        Paint *p = BKE_paint_get_active_from_context(C);
 -
 +#endif
        if (op->customdata) {
                ViewOpsData *vod = op->customdata;
                ar = vod->ar;
                ar = CTX_wm_region(C);
        }
  
 +#if 0
        if (p && (p->flags & PAINT_FAST_NAVIGATE))
 +#endif
                ED_region_tag_redraw(ar);
  }
- /** \} */
  
+ /** \} */
  
- /* ************************** viewrotate **********************************/
+ /* -------------------------------------------------------------------- */
+ /** \name View Rotate
+  * \{ */
  
  enum {
        VIEW_PASS = 0,
  };
  
  /* NOTE: these defines are saved in keymap files, do not change values but just add new ones */
- #define VIEW_MODAL_CONFIRM              1 /* used for all view operations */
- #define VIEWROT_MODAL_AXIS_SNAP_ENABLE  2
- #define VIEWROT_MODAL_AXIS_SNAP_DISABLE 3
- #define VIEWROT_MODAL_SWITCH_ZOOM       4
- #define VIEWROT_MODAL_SWITCH_MOVE       5
- #define VIEWROT_MODAL_SWITCH_ROTATE     6
+ enum {
+       VIEW_MODAL_CONFIRM              = 1, /* used for all view operations */
+       VIEWROT_MODAL_AXIS_SNAP_ENABLE  = 2,
+       VIEWROT_MODAL_AXIS_SNAP_DISABLE = 3,
+       VIEWROT_MODAL_SWITCH_ZOOM       = 4,
+       VIEWROT_MODAL_SWITCH_MOVE       = 5,
+       VIEWROT_MODAL_SWITCH_ROTATE     = 6,
+ };
  
  /* called in transform_ops.c, on each regeneration of keymaps  */
  void viewrotate_modal_keymap(wmKeyConfig *keyconf)
@@@ -1365,11 -1394,13 +1406,13 @@@ void VIEW3D_OT_rotate(wmOperatorType *o
        ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
  }
  
- #ifdef WITH_INPUT_NDOF
+ /** \} */
  
+ /* -------------------------------------------------------------------- */
  /** \name NDOF Utility Functions
   * \{ */
  
+ #ifdef WITH_INPUT_NDOF
  #define NDOF_HAS_TRANSLATE ((!ED_view3d_offset_lock_check(v3d, rv3d)) && !is_zero_v3(ndof->tvec))
  #define NDOF_HAS_ROTATE    (((rv3d->viewlock & RV3D_LOCKED) == 0) && !is_zero_v3(ndof->rvec))
  
@@@ -1419,8 -1450,9 +1462,9 @@@ static float view3d_ndof_pan_speed_calc
   *
   * \param has_zoom zoom, otherwise dolly, often `!rv3d->is_persp` since it doesnt make sense to dolly in ortho.
   */
- static void view3d_ndof_pan_zoom(const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
-                                  const bool has_translate, const bool has_zoom)
+ static void view3d_ndof_pan_zoom(
+         const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
+         const bool has_translate, const bool has_zoom)
  {
        RegionView3D *rv3d = ar->regiondata;
        float view_inv[4];
  }
  
  
- static void view3d_ndof_orbit(const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
-                               /* optional, can be NULL*/
-                               ViewOpsData *vod)
+ static void view3d_ndof_orbit(
+         const struct wmNDOFMotionData *ndof, ScrArea *sa, ARegion *ar,
+         /* optional, can be NULL*/
+         ViewOpsData *vod)
  {
        View3D *v3d = sa->spacedata.first;
        RegionView3D *rv3d = ar->regiondata;
@@@ -1668,11 -1701,14 +1713,14 @@@ void view3d_ndof_fly
  
  /** \} */
  
+ /* -------------------------------------------------------------------- */
+ /** \name NDOF Operators
+  *
+  * - "orbit" navigation (trackball/turntable)
+  * - zooming
+  * - panning in rotationally-locked views
+  * \{ */
  
- /* -- "orbit" navigation (trackball/turntable)
-  * -- zooming
-  * -- panning in rotationally-locked views
-  */
  static int ndof_orbit_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
        
@@@ -1936,8 -1972,11 +1984,11 @@@ void VIEW3D_OT_ndof_all(struct wmOperat
  
  #endif /* WITH_INPUT_NDOF */
  
- /* ************************ viewmove ******************************** */
+ /** \} */
  
+ /* -------------------------------------------------------------------- */
+ /** \name View Move (Pan) Operator
+  * \{ */
  
  /* NOTE: these defines are saved in keymap files, do not change values but just add new ones */
  
@@@ -2117,7 -2156,11 +2168,11 @@@ void VIEW3D_OT_move(wmOperatorType *ot
        ot->flag = OPTYPE_BLOCKING | OPTYPE_GRAB_CURSOR;
  }
  
- /* ************************ viewzoom ******************************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Zoom Operator
+  * \{ */
  
  /* viewdolly_modal_keymap has an exact copy of this, apply fixes to both */
  /* called in transform_ops.c, on each regeneration of keymaps  */
@@@ -2155,7 -2198,7 +2210,7 @@@ void viewzoom_modal_keymap(wmKeyConfig 
  }
  
  static void view_zoom_mouseloc_camera(
 -        Scene *scene, View3D *v3d,
 +        Scene *scene, const Depsgraph *depsgraph, View3D *v3d,
          ARegion *ar, float dfac, int mx, int my)
  {
        RegionView3D *rv3d = ar->regiondata;
                float pt_dst[2];
                float delta_px[2];
  
 -              ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &camera_frame_old, false);
 +              ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &camera_frame_old, false);
                BLI_rctf_translate(&camera_frame_old, ar->winrct.xmin, ar->winrct.ymin);
  
                rv3d->camzoom = camzoom_new;
                CLAMP(rv3d->camzoom, RV3D_CAMZOOM_MIN, RV3D_CAMZOOM_MAX);
  
 -              ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &camera_frame_new, false);
 +              ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &camera_frame_new, false);
                BLI_rctf_translate(&camera_frame_new, ar->winrct.xmin, ar->winrct.ymin);
  
                BLI_rctf_transform_pt_v(&camera_frame_new, &camera_frame_old, pt_dst, pt_src);
@@@ -2326,7 -2369,7 +2381,7 @@@ static void viewzoom_apply_camera
                /* calculate inverted, then invert again (needed because of camera zoom scaling) */
                zfac = 1.0f / zfac;
                view_zoom_mouseloc_camera(
 -                      vod->scene, vod->v3d,
 +                      vod->scene, vod->depsgraph, vod->v3d,
                        vod->ar, zfac, vod->oldx, vod->oldy);
        }
  
@@@ -2440,7 -2483,6 +2495,7 @@@ static int viewzoom_modal(bContext *C, 
  
  static int viewzoom_exec(bContext *C, wmOperator *op)
  {
 +      const Depsgraph *depsgraph = CTX_data_depsgraph(C);
        Scene *scene = CTX_data_scene(C);
        View3D *v3d;
        RegionView3D *rv3d;
                const float step = 1.2f;
                /* this min and max is also in viewmove() */
                if (use_cam_zoom) {
 -                      view_zoom_mouseloc_camera(scene, v3d, ar, step, mx, my);
 +                      view_zoom_mouseloc_camera(scene, depsgraph, v3d, ar, step, mx, my);
                }
                else {
                        if (rv3d->dist < dist_range[1]) {
        else {
                const float step = 1.0f / 1.2f;
                if (use_cam_zoom) {
 -                      view_zoom_mouseloc_camera(scene, v3d, ar, step, mx, my);
 +                      view_zoom_mouseloc_camera(scene, depsgraph, v3d, ar, step, mx, my);
                }
                else {
                        if (rv3d->dist > dist_range[0]) {
        return OPERATOR_FINISHED;
  }
  
- /* this is an exact copy of viewzoom_modal_keymap */
- /* called in transform_ops.c, on each regeneration of keymaps  */
- void viewdolly_modal_keymap(wmKeyConfig *keyconf)
- {
-       static const EnumPropertyItem modal_items[] = {
-               {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
-               {VIEWROT_MODAL_SWITCH_ROTATE, "SWITCH_TO_ROTATE", 0, "Switch to Rotate"},
-               {VIEWROT_MODAL_SWITCH_MOVE, "SWITCH_TO_MOVE", 0, "Switch to Move"},
-               {0, NULL, 0, NULL, NULL}
-       };
-       wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Dolly Modal");
-       /* this function is called for each spacetype, only needs to add map once */
-       if (keymap && keymap->modal_items) return;
-       keymap = WM_modalkeymap_add(keyconf, "View3D Dolly Modal", modal_items);
-       /* items for modal map */
-       WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
-       WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
-       /* disabled mode switching for now, can re-implement better, later on */
- #if 0
-       WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
-       WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
-       WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
- #endif
-       
-       /* assign map to operators */
-       WM_modalkeymap_assign(keymap, "VIEW3D_OT_dolly");
- }
  /* viewdolly_invoke() copied this function, changes here may apply there */
  static int viewzoom_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
@@@ -2634,8 -2641,50 +2654,50 @@@ void VIEW3D_OT_zoom(wmOperatorType *ot
        RNA_def_property_flag(prop, PROP_HIDDEN);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Dolly Operator
+  *
+  * Like zoom but translates the view offset along the view direction
+  * which avoids #RegionView3D.dist approaching zero.
+  * \{ */
+ /* this is an exact copy of viewzoom_modal_keymap */
+ /* called in transform_ops.c, on each regeneration of keymaps  */
+ void viewdolly_modal_keymap(wmKeyConfig *keyconf)
+ {
+       static const EnumPropertyItem modal_items[] = {
+               {VIEW_MODAL_CONFIRM,    "CONFIRM", 0, "Confirm", ""},
+               {VIEWROT_MODAL_SWITCH_ROTATE, "SWITCH_TO_ROTATE", 0, "Switch to Rotate"},
+               {VIEWROT_MODAL_SWITCH_MOVE, "SWITCH_TO_MOVE", 0, "Switch to Move"},
+               {0, NULL, 0, NULL, NULL}
+       };
+       wmKeyMap *keymap = WM_modalkeymap_get(keyconf, "View3D Dolly Modal");
+       /* this function is called for each spacetype, only needs to add map once */
+       if (keymap && keymap->modal_items) return;
+       keymap = WM_modalkeymap_add(keyconf, "View3D Dolly Modal", modal_items);
+       /* items for modal map */
+       WM_modalkeymap_add_item(keymap, MIDDLEMOUSE, KM_RELEASE, KM_ANY, 0, VIEW_MODAL_CONFIRM);
+       WM_modalkeymap_add_item(keymap, ESCKEY, KM_PRESS, KM_ANY, 0, VIEW_MODAL_CONFIRM);
+       /* disabled mode switching for now, can re-implement better, later on */
+ #if 0
+       WM_modalkeymap_add_item(keymap, LEFTMOUSE, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
+       WM_modalkeymap_add_item(keymap, LEFTCTRLKEY, KM_RELEASE, KM_ANY, 0, VIEWROT_MODAL_SWITCH_ROTATE);
+       WM_modalkeymap_add_item(keymap, LEFTSHIFTKEY, KM_PRESS, KM_ANY, 0, VIEWROT_MODAL_SWITCH_MOVE);
+ #endif
+       
+       /* assign map to operators */
+       WM_modalkeymap_assign(keymap, "VIEW3D_OT_dolly");
+ }
  
- /* ************************ viewdolly ******************************** */
  static bool viewdolly_offset_lock_check(bContext *C, wmOperator *op)
  {
        View3D *v3d = CTX_wm_view3d(C);
@@@ -2901,9 -2950,18 +2963,9 @@@ void VIEW3D_OT_dolly(wmOperatorType *ot
        RNA_def_int(ot->srna, "my", 0, 0, INT_MAX, "Zoom Position Y", "", 0, INT_MAX);
  }
  
 -/** \} */
 -
 -/* -------------------------------------------------------------------- */
 -/** \name View All Operator
 - *
 - * Move & Zoom the view to fit all of it's contents.
 - * \{ */
 -
 -static void view3d_from_minmax(
 -        bContext *C, View3D *v3d, ARegion *ar,
 -        const float min[3], const float max[3],
 -        bool ok_dist, const int smooth_viewtx)
 +static void view3d_from_minmax(bContext *C, View3D *v3d, ARegion *ar,
 +                               const float min[3], const float max[3],
 +                               bool ok_dist, const int smooth_viewtx)
  {
        RegionView3D *rv3d = ar->regiondata;
        float afm[3];
  }
  
  /* same as view3d_from_minmax but for all regions (except cameras) */
- static void view3d_from_minmax_multi(bContext *C, View3D *v3d,
-                                      const float min[3], const float max[3],
-                                      const bool ok_dist, const int smooth_viewtx)
+ static void view3d_from_minmax_multi(
+         bContext *C, View3D *v3d,
+         const float min[3], const float max[3],
+         const bool ok_dist, const int smooth_viewtx)
  {
        ScrArea *sa = CTX_wm_area(C);
        ARegion *ar;
@@@ -2993,7 -3052,6 +3056,7 @@@ static int view3d_all_exec(bContext *C
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        Scene *scene = CTX_data_scene(C);
 +      ViewLayer *view_layer = CTX_data_view_layer(C);
        Base *base;
        float *curs;
        const bool use_all_regions = RNA_boolean_get(op->ptr, "use_all_regions");
                INIT_MINMAX(min, max);
        }
  
 -      for (base = scene->base.first; base; base = base->next) {
 -              if (BASE_VISIBLE(v3d, base)) {
 +      for (base = view_layer->object_bases.first; base; base = base->next) {
 +              if (BASE_VISIBLE(base)) {
                        changed = true;
  
                        if (skip_camera && base->object == v3d->camera) {
@@@ -3072,18 -3130,23 +3135,26 @@@ void VIEW3D_OT_view_all(wmOperatorType 
        RNA_def_boolean(ot->srna, "center", 0, "Center", "");
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Selected Operator
+  *
+  * Move & Zoom the view to fit selected contents.
+  * \{ */
  /* like a localview without local!, was centerview() in 2.4x */
  static int viewselected_exec(bContext *C, wmOperator *op)
  {
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        Scene *scene = CTX_data_scene(C);
 +      ViewLayer *view_layer = CTX_data_view_layer(C);
        bGPdata *gpd = CTX_data_gpencil_data(C);
        const bool is_gp_edit = ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE));
 -      Object *ob = OBACT;
 +      const bool is_face_map = ((is_gp_edit == false) && ar->manipulator_map &&
 +                                WM_manipulatormap_is_any_selected(ar->manipulator_map));
 +      Object *ob = OBACT(view_layer);
        Object *obedit = CTX_data_edit_object(C);
        float min[3], max[3];
        bool ok = false, ok_dist = true;
        const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
  
        INIT_MINMAX(min, max);
 -
 -      if (is_gp_edit) {
 +      if (is_gp_edit || is_face_map) {
                ob = NULL;
        }
  
                /* hard-coded exception, we look for the one selected armature */
                /* this is weak code this way, we should make a generic active/selection callback interface once... */
                Base *base;
 -              for (base = scene->base.first; base; base = base->next) {
 -                      if (TESTBASELIB(v3d, base)) {
 +              for (base = view_layer->object_bases.first; base; base = base->next) {
 +                      if (TESTBASELIB(base)) {
                                if (base->object->type == OB_ARMATURE)
                                        if (base->object->mode & OB_MODE_POSE)
                                                break;
                }
                CTX_DATA_END;
        }
 +      else if (is_face_map) {
 +              ok = WM_manipulatormap_minmax(ar->manipulator_map, true, true, min, max);
 +      }
        else if (obedit) {
                ok = ED_view3d_minmax_verts(obedit, min, max);    /* only selected */
        }
                ok = paintface_minmax(ob, min, max);
        }
        else if (ob && (ob->mode & OB_MODE_PARTICLE_EDIT)) {
 -              ok = PE_minmax(scene, min, max);
 +              ok = PE_minmax(scene, view_layer, min, max);
        }
        else if (ob &&
                 (ob->mode & (OB_MODE_SCULPT | OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT | OB_MODE_TEXTURE_PAINT)))
        }
        else {
                Base *base;
 -              for (base = FIRSTBASE; base; base = base->next) {
 -                      if (TESTBASE(v3d, base)) {
 +              for (base = FIRSTBASE(view_layer); base; base = base->next) {
 +                      if (TESTBASE(base)) {
  
                                if (skip_camera && base->object == v3d->camera) {
                                        continue;
@@@ -3202,6 -3263,12 +3273,12 @@@ void VIEW3D_OT_view_selected(wmOperator
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Lock Clear Operator
+  * \{ */
  static int view_lock_clear_exec(bContext *C, wmOperator *UNUSED(op))
  {
        View3D *v3d = CTX_wm_view3d(C);
@@@ -3234,6 -3301,12 +3311,12 @@@ void VIEW3D_OT_view_lock_clear(wmOperat
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Lock to Active Operator
+  * \{ */
  static int view_lock_to_active_exec(bContext *C, wmOperator *UNUSED(op))
  {
        View3D *v3d = CTX_wm_view3d(C);
@@@ -3285,6 -3358,12 +3368,12 @@@ void VIEW3D_OT_view_lock_to_active(wmOp
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Center Cursor Operator
+  * \{ */
  static int viewcenter_cursor_exec(bContext *C, wmOperator *op)
  {
        View3D *v3d = CTX_wm_view3d(C);
@@@ -3325,25 -3404,28 +3414,31 @@@ void VIEW3D_OT_view_center_cursor(wmOpe
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Center Pick Operator
+  * \{ */
  static int viewcenter_pick_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
        View3D *v3d = CTX_wm_view3d(C);
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
 -      Scene *scene = CTX_data_scene(C);
        ARegion *ar = CTX_wm_region(C);
  
        if (rv3d) {
 +              EvaluationContext eval_ctx;
 +              struct Depsgraph *graph = CTX_data_depsgraph(C);
                float new_ofs[3];
                const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
  
 +              CTX_data_eval_ctx(C, &eval_ctx);
 +
                ED_view3d_smooth_view_force_finish(C, v3d, ar);
  
                view3d_operator_needs_opengl(C);
  
 -              if (ED_view3d_autodist(scene, ar, v3d, event->mval, new_ofs, false, NULL)) {
 +              if (ED_view3d_autodist(&eval_ctx, graph, ar, v3d, event->mval, new_ofs, false, NULL)) {
                        /* pass */
                }
                else {
@@@ -3375,9 -3457,14 +3470,15 @@@ void VIEW3D_OT_view_center_pick(wmOpera
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Camera Center Operator
+  * \{ */
  static int view3d_center_camera_exec(bContext *C, wmOperator *UNUSED(op)) /* was view3d_home() in 2.4x */
  {
 +      const Depsgraph *depsgraph = CTX_data_depsgraph(C);
        Scene *scene = CTX_data_scene(C);
        float xfac, yfac;
        float size[2];
  
        rv3d->camdx = rv3d->camdy = 0.0f;
  
 -      ED_view3d_calc_camera_border_size(scene, ar, v3d, rv3d, size);
 +      ED_view3d_calc_camera_border_size(scene, depsgraph, ar, v3d, rv3d, size);
  
        /* 4px is just a little room from the edge of the area */
        xfac = (float)ar->winx / (float)(size[0] + 4);
@@@ -3421,6 -3508,12 +3522,12 @@@ void VIEW3D_OT_view_center_camera(wmOpe
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Lock Center Operator
+  * \{ */
  static int view3d_center_lock_exec(bContext *C, wmOperator *UNUSED(op)) /* was view3d_home() in 2.4x */
  {
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
@@@ -3447,11 -3540,14 +3554,15 @@@ void VIEW3D_OT_view_center_lock(wmOpera
        ot->flag = 0;
  }
  
- /* ********************* Set render border operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Set Render Border Operator
+  * \{ */
  
  static int render_border_exec(bContext *C, wmOperator *op)
  {
 +      const Depsgraph *depsgraph = CTX_data_depsgraph(C);
        View3D *v3d = CTX_wm_view3d(C);
        ARegion *ar = CTX_wm_region(C);
        RegionView3D *rv3d = ED_view3d_context_rv3d(C);
        /* calculate range */
  
        if (rv3d->persp == RV3D_CAMOB) {
 -              ED_view3d_calc_camera_border(scene, ar, v3d, rv3d, &vb, false);
 +              ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &vb, false);
        }
        else {
                vb.xmin = 0;
@@@ -3549,7 -3645,11 +3660,11 @@@ void VIEW3D_OT_render_border(wmOperator
        RNA_def_property_flag(prop, PROP_HIDDEN);
  }
  
- /* ********************* Clear render border operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Clear Render Border Operator
+  * \{ */
  
  static int clear_render_border_exec(bContext *C, wmOperator *UNUSED(op))
  {
@@@ -3596,14 -3696,18 +3711,18 @@@ void VIEW3D_OT_clear_render_border(wmOp
        ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
  }
  
- /* ********************* Border Zoom operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Border Zoom Operator
+  * \{ */
  
  static int view3d_zoom_border_exec(bContext *C, wmOperator *op)
  {
 +      EvaluationContext eval_ctx;
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
 -      Scene *scene = CTX_data_scene(C);
        const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
  
        /* Zooms in on a border drawn by the user */
        float new_ofs[3];
  
        /* ZBuffer depth vars */
 -      bglMats mats;
        float depth_close = FLT_MAX;
 -      double cent[2],  p[3];
 +      float p[3];
  
        /* note; otherwise opengl won't work */
        view3d_operator_needs_opengl(C);
  
 +      CTX_data_eval_ctx(C, &eval_ctx);
 +
        /* get border select values using rna */
        WM_operator_properties_border_to_rcti(op, &rect);
  
        ED_view3d_dist_range_get(v3d, dist_range);
  
        /* Get Z Depths, needed for perspective, nice for ortho */
 -      bgl_get_mats(&mats);
 -      ED_view3d_draw_depth(scene, ar, v3d, true);
 +      ED_view3d_draw_depth(&eval_ctx, CTX_data_depsgraph(C), ar, v3d, true);
        
        {
                /* avoid allocating the whole depth buffer */
                MEM_SAFE_FREE(depth_temp.depths);
        }
  
 -      cent[0] = (((double)rect.xmin) + ((double)rect.xmax)) / 2;
 -      cent[1] = (((double)rect.ymin) + ((double)rect.ymax)) / 2;
 +      float centx = (((float)rect.xmin) + ((float)rect.xmax)) / 2;
 +      float centy = (((float)rect.ymin) + ((float)rect.ymax)) / 2;
  
        if (rv3d->is_persp) {
 -              double p_corner[3];
 +              float p_corner[3];
  
                /* no depths to use, we cant do anything! */
                if (depth_close == FLT_MAX) {
                        return OPERATOR_CANCELLED;
                }
                /* convert border to 3d coordinates */
 -              if ((!gluUnProject(cent[0], cent[1], depth_close,
 -                                 mats.modelview, mats.projection, (GLint *)mats.viewport,
 -                                 &p[0], &p[1], &p[2])) ||
 -                  (!gluUnProject((double)rect.xmin, (double)rect.ymin, depth_close,
 -                                 mats.modelview, mats.projection, (GLint *)mats.viewport,
 -                                 &p_corner[0], &p_corner[1], &p_corner[2])))
 +              if ((!ED_view3d_unproject(ar, centx, centy, depth_close, p)) ||
 +                  (!ED_view3d_unproject(ar, rect.xmin, rect.ymin, depth_close, p_corner)))
                {
                        return OPERATOR_CANCELLED;
                }
  
 -              dvec[0] = p[0] - p_corner[0];
 -              dvec[1] = p[1] - p_corner[1];
 -              dvec[2] = p[2] - p_corner[2];
 -
 -              new_ofs[0] = -p[0];
 -              new_ofs[1] = -p[1];
 -              new_ofs[2] = -p[2];
 +              sub_v3_v3v3(dvec, p, p_corner);
 +              negate_v3_v3(new_ofs, p);
  
                new_dist = len_v3(dvec);
  
                new_dist = rv3d->dist;
  
                /* convert the drawn rectangle into 3d space */
 -              if (depth_close != FLT_MAX && gluUnProject(cent[0], cent[1], depth_close,
 -                                                         mats.modelview, mats.projection, (GLint *)mats.viewport,
 -                                                         &p[0], &p[1], &p[2]))
 -              {
 -                      new_ofs[0] = -p[0];
 -                      new_ofs[1] = -p[1];
 -                      new_ofs[2] = -p[2];
 +              if (depth_close != FLT_MAX && ED_view3d_unproject(ar, centx, centy, depth_close, p)) {
 +                      negate_v3_v3(new_ofs, p);
                }
                else {
                        float mval_f[2];
@@@ -3764,14 -3882,21 +3883,21 @@@ void VIEW3D_OT_zoom_border(wmOperatorTy
        WM_operator_properties_gesture_border_zoom(ot);
  }
  
- /* sets the view to 1:1 camera/render-pixel */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Set Camera Zoom 1:1 Operator
+  *
+  * Sets the view to 1:1 camera/render-pixel.
+  * \{ */
 -static void view3d_set_1_to_1_viewborder(Scene *scene, ARegion *ar, View3D *v3d)
 +static void view3d_set_1_to_1_viewborder(Scene *scene, const Depsgraph *depsgraph, ARegion *ar, View3D *v3d)
  {
        RegionView3D *rv3d = ar->regiondata;
        float size[2];
        int im_width = (scene->r.size * scene->r.xsch) / 100;
        
 -      ED_view3d_calc_camera_border_size(scene, ar, v3d, rv3d, size);
 +      ED_view3d_calc_camera_border_size(scene, depsgraph, ar, v3d, rv3d, size);
  
        rv3d->camzoom = BKE_screen_view3d_zoom_from_fac((float)im_width / size[0]);
        CLAMP(rv3d->camzoom, RV3D_CAMZOOM_MIN, RV3D_CAMZOOM_MAX);
  
  static int view3d_zoom_1_to_1_camera_exec(bContext *C, wmOperator *UNUSED(op))
  {
 +      const Depsgraph *depsgraph = CTX_data_depsgraph(C);
        Scene *scene = CTX_data_scene(C);
  
        View3D *v3d;
        /* no NULL check is needed, poll checks */
        ED_view3d_context_user_region(C, &v3d, &ar);
  
 -      view3d_set_1_to_1_viewborder(scene, ar, v3d);
 +      view3d_set_1_to_1_viewborder(scene, depsgraph, ar, v3d);
  
        WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
  
@@@ -3810,7 -3934,11 +3936,11 @@@ void VIEW3D_OT_zoom_camera_1_to_1(wmOpe
        ot->flag = 0;
  }
  
- /* ********************* Changing view operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Axis/Type Operator
+  * \{ */
  
  static const EnumPropertyItem prop_view_items[] = {
        {RV3D_VIEW_LEFT, "LEFT", ICON_TRIA_LEFT, "Left", "View From the Left"},
  
  /* would like to make this a generic function - outside of transform */
  
- static void axis_set_view(bContext *C, View3D *v3d, ARegion *ar,
-                           const float quat_[4],
-                           short view, int perspo, bool align_active,
-                           const int smooth_viewtx)
+ static void axis_set_view(
+         bContext *C, View3D *v3d, ARegion *ar,
+         const float quat_[4],
+         short view, int perspo, bool align_active,
+         const int smooth_viewtx)
  {
        RegionView3D *rv3d = ar->regiondata; /* no NULL check is needed, poll checks */
        float quat[4];
@@@ -3921,7 -4050,6 +4052,7 @@@ static int viewnumpad_exec(bContext *C
        ARegion *ar;
        RegionView3D *rv3d;
        Scene *scene = CTX_data_scene(C);
 +      ViewLayer *view_layer = CTX_data_view_layer(C);
        static int perspo = RV3D_PERSP;
        int viewnum, nextperspo;
        bool align_active;
                        /* lastview -  */
  
                        if (rv3d->persp != RV3D_CAMOB) {
 -                              Object *ob = OBACT;
 +                              Object *ob = OBACT(view_layer);
  
                                if (!rv3d->smooth_timer) {
                                        /* store settings of current view before allowing overwriting with camera view
                                        v3d->camera = ob;
  
                                if (v3d->camera == NULL)
 -                                      v3d->camera = BKE_scene_camera_find(scene);
 +                                      v3d->camera = BKE_view_layer_camera_find(view_layer);
  
                                /* couldnt find any useful camera, bail out */
                                if (v3d->camera == NULL)
@@@ -4049,6 -4177,12 +4180,12 @@@ void VIEW3D_OT_viewnumpad(wmOperatorTyp
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Orbit Operator
+  * \{ */
  static const EnumPropertyItem prop_view_orbit_items[] = {
        {V3D_VIEW_STEPLEFT, "ORBITLEFT", 0, "Orbit Left", "Orbit the view around to the Left"},
        {V3D_VIEW_STEPRIGHT, "ORBITRIGHT", 0, "Orbit Right", "Orbit the view around to the Right"},
@@@ -4169,11 -4303,13 +4306,13 @@@ void VIEW3D_OT_view_orbit(wmOperatorTyp
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  
        ot->prop = RNA_def_enum(ot->srna, "type", prop_view_orbit_items, 0, "Orbit", "Direction of View Orbit");
  }
  
+ /** \} */
  
- /* ************************ viewroll ******************************** */
+ /* -------------------------------------------------------------------- */
+ /** \name View Roll Operator
+  * \{ */
  
  static void view_roll_angle(ARegion *ar, float quat[4], const float orig_quat[4], const float dvec[3], float angle)
  {
@@@ -4415,6 -4551,14 +4554,14 @@@ static const EnumPropertyItem prop_view
        {0, NULL, 0, NULL, NULL}
  };
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Pan Operator
+  *
+  * Move (pan) in incremental steps.
+  * \{ */
  static int viewpan_invoke(bContext *C, wmOperator *op, const wmEvent *event)
  {
        int x = 0, y = 0;
@@@ -4455,6 -4599,12 +4602,12 @@@ void VIEW3D_OT_view_pan(wmOperatorType 
        ot->prop = RNA_def_enum(ot->srna, "type", prop_view_pan_items, 0, "Pan", "Direction of View Pan");
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Toggle Perspective/Orthographic Operator
+  * \{ */
  static int viewpersportho_exec(bContext *C, wmOperator *UNUSED(op))
  {
        View3D *v3d_dummy;
@@@ -4491,6 -4641,14 +4644,14 @@@ void VIEW3D_OT_view_persportho(wmOperat
        ot->flag = 0;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Navigate Operator
+  *
+  * Wraps walk/fly modes.
+  * \{ */
  static int view3d_navigate_invoke(bContext *C, wmOperator *UNUSED(op), const wmEvent *UNUSED(event))
  {
        eViewNavigation_Method mode = U.navigation_mode;
@@@ -4520,14 -4678,17 +4681,17 @@@ void VIEW3D_OT_navigate(wmOperatorType 
        ot->poll = ED_operator_view3d_active;
  }
  
+ /** \} */
  
- /* ******************** add background image operator **************** */
+ /* -------------------------------------------------------------------- */
+ /** \name Background Image Add Operator
+  * \{ */
  
 -static BGpic *background_image_add(bContext *C)
 +static CameraBGImage *background_image_add(bContext *C)
  {
 -      View3D *v3d = CTX_wm_view3d(C);
 +      Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
  
 -      return ED_view3D_background_image_new(v3d);
 +      return BKE_camera_background_image_new(cam);
  }
  
  static int background_image_add_exec(bContext *C, wmOperator *UNUSED(op))
  
  static int background_image_add_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
  {
 -      View3D *v3d = CTX_wm_view3d(C);
 +      Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
        Image *ima;
 -      BGpic *bgpic;
 +      CameraBGImage *bgpic;
        
        ima = (Image *)WM_operator_drop_load_path(C, op, ID_IM);
        /* may be NULL, continue anyway */
        bgpic = background_image_add(C);
        bgpic->ima = ima;
  
 -      v3d->flag |= V3D_DISPBGPICS;
 -      
 -      WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
 -      
 +      cam->flag |= CAM_SHOW_BG_IMAGE;
 +
 +      WM_event_add_notifier(C, NC_CAMERA | ND_DRAW_RENDER_VIEWPORT, cam);
 +
        return OPERATOR_FINISHED;
  }
  
@@@ -4568,7 -4729,7 +4732,7 @@@ void VIEW3D_OT_background_image_add(wmO
        /* api callbacks */
        ot->invoke = background_image_add_invoke;
        ot->exec   = background_image_add_exec;
 -      ot->poll   = ED_operator_view3d_active;
 +      ot->poll   = ED_operator_camera;
  
        /* flags */
        ot->flag   = OPTYPE_UNDO;
                WM_FILESEL_FILEPATH | WM_FILESEL_RELPATH, FILE_DEFAULTDISPLAY, FILE_SORT_ALPHA);
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Background Image Remove Operator
+  * \{ */
  
- /* ***** remove image operator ******* */
  static int background_image_remove_exec(bContext *C, wmOperator *op)
  {
 -      View3D *v3d = CTX_wm_view3d(C);
 +      Camera *cam = CTX_data_pointer_get_type(C, "camera", &RNA_Camera).data;
        const int index = RNA_int_get(op->ptr, "index");
 -      BGpic *bgpic_rem = BLI_findlink(&v3d->bgpicbase, index);
 +      CameraBGImage *bgpic_rem = BLI_findlink(&cam->bg_images, index);
  
        if (bgpic_rem) {
 -              if (bgpic_rem->source == V3D_BGPIC_IMAGE) {
 +              if (bgpic_rem->source == CAM_BGIMG_SOURCE_IMAGE) {
                        id_us_min((ID *)bgpic_rem->ima);
                }
 -              else if (bgpic_rem->source == V3D_BGPIC_MOVIE) {
 +              else if (bgpic_rem->source == CAM_BGIMG_SOURCE_MOVIE) {
                        id_us_min((ID *)bgpic_rem->clip);
                }
  
 -              ED_view3D_background_image_remove(v3d, bgpic_rem);
 +              BKE_camera_background_image_remove(cam, bgpic_rem);
 +
 +              WM_event_add_notifier(C, NC_CAMERA | ND_DRAW_RENDER_VIEWPORT, cam);
  
 -              WM_event_add_notifier(C, NC_SPACE | ND_SPACE_VIEW3D, v3d);
                return OPERATOR_FINISHED;
        }
        else {
@@@ -4617,7 -4781,7 +4785,7 @@@ void VIEW3D_OT_background_image_remove(
  
        /* api callbacks */
        ot->exec   = background_image_remove_exec;
 -      ot->poll   = ED_operator_view3d_active;
 +      ot->poll   = ED_operator_camera;
  
        /* flags */
        ot->flag   = 0;
        RNA_def_int(ot->srna, "index", 0, 0, INT_MAX, "Index", "Background image index to remove", 0, INT_MAX);
  }
  
- /* ********************* set clipping operator ****************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Clipping Planes Operator
+  *
+  * Draw border or toggle off.
+  * \{ */
  
  static void calc_local_clipping(float clip_local[6][4], BoundBox *clipbb, float mat[4][4])
  {
@@@ -4651,8 -4821,9 +4825,8 @@@ void ED_view3d_clipping_local(RegionVie
  
  static int view3d_clipping_exec(bContext *C, wmOperator *op)
  {
 +      ARegion *ar = CTX_wm_region(C);
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
 -      ViewContext vc;
 -      bglMats mats;
        rcti rect;
  
        WM_operator_properties_border_to_rcti(op, &rect);
        rv3d->rflag |= RV3D_CLIPPING;
        rv3d->clipbb = MEM_callocN(sizeof(BoundBox), "clipbb");
  
 -      /* note; otherwise opengl won't work */
 -      view3d_operator_needs_opengl(C);
 -
 -      view3d_set_viewcontext(C, &vc);
 -      view3d_get_transformation(vc.ar, vc.rv3d, NULL, &mats); /* NULL because we don't want it in object space */
 -      ED_view3d_clipping_calc(rv3d->clipbb, rv3d->clip, &mats, &rect);
 +      /* NULL object because we don't want it in object space */
 +      ED_view3d_clipping_calc(rv3d->clipbb, rv3d->clip, ar, NULL, &rect);
  
        return OPERATOR_FINISHED;
  }
@@@ -4683,7 -4858,6 +4857,7 @@@ static int view3d_clipping_invoke(bCont
        }
  }
  
 +/* toggles */
  void VIEW3D_OT_clip_border(wmOperatorType *ot)
  {
  
        WM_operator_properties_border(ot);
  }
  
- /* ***************** 3d cursor cursor op ******************* */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Set Cursor Operator
+  * \{ */
  
  /* cursor position in vec, result in vec, mval in region coords */
  /* note: cannot use event->mval here (called by object_add() */
  void ED_view3d_cursor3d_position(bContext *C, float fp[3], const int mval[2])
  {
 -      Scene *scene = CTX_data_scene(C);
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        RegionView3D *rv3d = ar->regiondata;
        }
  
        if (U.uiflag & USER_ZBUF_CURSOR) {  /* maybe this should be accessed some other way */
 +              EvaluationContext eval_ctx;
 +              struct Depsgraph *graph = CTX_data_depsgraph(C);
 +
 +              CTX_data_eval_ctx(C, &eval_ctx);
 +
                view3d_operator_needs_opengl(C);
 -              if (ED_view3d_autodist(scene, ar, v3d, mval, fp, true, NULL))
 +              if (ED_view3d_autodist(&eval_ctx, graph, ar, v3d, mval, fp, true, NULL)) {
                        depth_used = true;
 +              }
        }
  
        if (depth_used == false) {
@@@ -4819,7 -4992,55 +4997,11 @@@ void VIEW3D_OT_cursor3d(wmOperatorType 
  
  }
  
- /* ***************** manipulator op ******************* */
+ /** \} */
 -/* -------------------------------------------------------------------- */
 -/** \name Transform Manipulator Operator
 - * \{ */
 -
 -static int manipulator_invoke(bContext *C, wmOperator *op, const wmEvent *event)
 -{
 -      View3D *v3d = CTX_wm_view3d(C);
 -
 -      if (!(v3d->twflag & V3D_USE_MANIPULATOR)) return OPERATOR_PASS_THROUGH;
 -      if (!(v3d->twflag & V3D_DRAW_MANIPULATOR)) return OPERATOR_PASS_THROUGH;
 -
 -      /* note; otherwise opengl won't work */
 -      view3d_operator_needs_opengl(C);
 -
 -      if (BIF_do_manipulator(C, event, op) == 0)
 -              return OPERATOR_PASS_THROUGH;
 -
 -      return OPERATOR_FINISHED;
 -}
 -
 -void VIEW3D_OT_manipulator(wmOperatorType *ot)
 -{
 -      PropertyRNA *prop;
 -
 -      /* identifiers */
 -      ot->name = "3D Manipulator";
 -      ot->description = "Manipulate selected item by axis";
 -      ot->idname = "VIEW3D_OT_manipulator";
 -
 -      /* api callbacks */
 -      ot->invoke = manipulator_invoke;
 -
 -      ot->poll = ED_operator_view3d_active;
 -
 -      /* properties to pass to transform */
 -      Transform_Properties(ot, P_CONSTRAINT);
 -
 -      prop = RNA_def_boolean(ot->srna, "use_planar_constraint", false, "Planar Constraint", "Limit the transformation to the "
 -                             "two axes that have not been clicked (translate/scale only)");
 -      RNA_def_property_flag(prop, PROP_SKIP_SAVE | PROP_HIDDEN);
 -}
 -
 -/** \} */
 -
+ /* -------------------------------------------------------------------- */
+ /** \name Enable Transform Manipulator Operator
+  * \{ */
  
  static int enable_manipulator_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
  {
@@@ -4861,7 -5082,11 +5043,11 @@@ void VIEW3D_OT_enable_manipulator(wmOpe
        RNA_def_property_flag(prop, PROP_SKIP_SAVE);
  }
  
- /* ************************* Toggle rendered shading *********************** */
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name Toggle Render Shading Operator
+  * \{ */
  
  static int toggle_render_exec(bContext *C, wmOperator *UNUSED(op))
  {
@@@ -4890,8 -5115,11 +5076,11 @@@ void VIEW3D_OT_toggle_render(wmOperator
        ot->poll = ED_operator_view3d_active;
  }
  
- /* ************************* below the line! *********************** */
+ /** \} */
  
+ /* -------------------------------------------------------------------- */
+ /** \name View Distance Utilities
+  * \{ */
  
  static float view_autodist_depth_margin(ARegion *ar, const int mval[2], int margin)
  {
   * \param fallback_depth_pt: Use this points depth when no depth can be found.
   */
  bool ED_view3d_autodist(
 -        Scene *scene, ARegion *ar, View3D *v3d,
 +        const EvaluationContext *eval_ctx, struct Depsgraph *graph, ARegion *ar, View3D *v3d,
          const int mval[2], float mouse_worldloc[3],
          const bool alphaoverride, const float fallback_depth_pt[3])
  {
 -      bglMats mats; /* ZBuffer depth vars */
        float depth_close;
 -      double cent[2],  p[3];
        int margin_arr[] = {0, 2, 4};
        int i;
        bool depth_ok = false;
  
        /* Get Z Depths, needed for perspective, nice for ortho */
 -      ED_view3d_draw_depth(scene, ar, v3d, alphaoverride);
 -
 -      /* call after in case settings have been modified since last drawing, see: T47089 */
 -      bgl_get_mats(&mats);
 +      ED_view3d_draw_depth(eval_ctx, graph, ar, v3d, alphaoverride);
  
        /* Attempt with low margin's first */
        i = 0;
        } while ((depth_ok == false) && (i < ARRAY_SIZE(margin_arr)));
  
        if (depth_ok) {
 -              cent[0] = (double)mval[0] + 0.5;
 -              cent[1] = (double)mval[1] + 0.5;
 +              float centx = (float)mval[0] + 0.5f;
 +              float centy = (float)mval[1] + 0.5f;
  
 -              if (gluUnProject(cent[0], cent[1], depth_close,
 -                               mats.modelview, mats.projection, (GLint *)mats.viewport, &p[0], &p[1], &p[2]))
 -              {
 -                      mouse_worldloc[0] = (float)p[0];
 -                      mouse_worldloc[1] = (float)p[1];
 -                      mouse_worldloc[2] = (float)p[2];
 +              if (ED_view3d_unproject(ar, centx, centy, depth_close, mouse_worldloc)) {
                        return true;
                }
        }
        }
  }
  
 -void ED_view3d_autodist_init(Scene *scene, ARegion *ar, View3D *v3d, int mode)
 +void ED_view3d_autodist_init(
 +        const EvaluationContext *eval_ctx, struct Depsgraph *graph,
 +        ARegion *ar, View3D *v3d, int mode)
  {
        /* Get Z Depths, needed for perspective, nice for ortho */
        switch (mode) {
                case 0:
 -                      ED_view3d_draw_depth(scene, ar, v3d, true);
 +                      ED_view3d_draw_depth(eval_ctx, graph, ar, v3d, true);
                        break;
                case 1:
 -                      ED_view3d_draw_depth_gpencil(scene, ar, v3d);
 +              {
 +                      Scene *scene = DEG_get_evaluated_scene(graph);
 +                      ED_view3d_draw_depth_gpencil(eval_ctx, scene, ar, v3d);
                        break;
 +              }
        }
  }
  
  /* no 4x4 sampling, run #ED_view3d_autodist_init first */
 -bool ED_view3d_autodist_simple(
 -        ARegion *ar, const int mval[2], float mouse_worldloc[3],
 -        int margin, float *force_depth)
 +bool ED_view3d_autodist_simple(ARegion *ar, const int mval[2], float mouse_worldloc[3],
 +                               int margin, float *force_depth)
  {
 -      bglMats mats; /* ZBuffer depth vars, could cache? */
        float depth;
 -      double cent[2],  p[3];
  
        /* Get Z Depths, needed for perspective, nice for ortho */
        if (force_depth)
        if (depth == FLT_MAX)
                return false;
  
 -      cent[0] = (double)mval[0] + 0.5;
 -      cent[1] = (double)mval[1] + 0.5;
 -
 -      bgl_get_mats(&mats);
 -
 -      if (!gluUnProject(cent[0], cent[1], depth,
 -                        mats.modelview, mats.projection, (GLint *)mats.viewport, &p[0], &p[1], &p[2]))
 -      {
 -              return false;
 -      }
 -
 -      mouse_worldloc[0] = (float)p[0];
 -      mouse_worldloc[1] = (float)p[1];
 -      mouse_worldloc[2] = (float)p[2];
 -      return true;
 +      float centx = (float)mval[0] + 0.5f;
 +      float centy = (float)mval[1] + 0.5f;
 +      return ED_view3d_unproject(ar, centx, centy, depth, mouse_worldloc);
  }
  
  bool ED_view3d_autodist_depth(ARegion *ar, const int mval[2], int margin, float *depth)
@@@ -5026,8 -5274,9 +5215,9 @@@ static bool depth_segment_cb(int x, in
        }
  }
  
- bool ED_view3d_autodist_depth_seg(ARegion *ar, const int mval_sta[2], const int mval_end[2],
-                                   int margin, float *depth)
+ bool ED_view3d_autodist_depth_seg(
+         ARegion *ar, const int mval_sta[2], const int mval_end[2],
+         int margin, float *depth)
  {
        struct { ARegion *ar; int margin; float depth; } data = {NULL};
        int p1[2];
@@@ -5096,6 -5345,12 +5286,12 @@@ void ED_view3d_distance_set(RegionView3
        rv3d->dist = dist;
  }
  
+ /** \} */
+ /* -------------------------------------------------------------------- */
+ /** \name View Transform Utilities
+  * \{ */
  /**
   * Set the view transformation from a 4x4 matrix.
   *
@@@ -5178,27 -5433,51 +5374,10 @@@ void ED_view3d_from_object(Object *ob, 
  void ED_view3d_to_object(Object *ob, const float ofs[3], const float quat[4], const float dist)
  {
        float mat[4][4];
        ED_view3d_to_m4(mat, ofs, quat, dist);
        BKE_object_apply_mat4(ob, mat, true, true);
  }
  
- /**
-  * Use to store the last view, before entering camera view.
-  */
- void ED_view3d_lastview_store(RegionView3D *rv3d)
- {
-       copy_qt_qt(rv3d->lviewquat, rv3d->viewquat);
-       rv3d->lview = rv3d->view;
-       if (rv3d->persp != RV3D_CAMOB) {
-               rv3d->lpersp = rv3d->persp;
-       }
- }
+ /** \} */
 -/* -------------------------------------------------------------------- */
 -/** \name Background Image Utilities
 - * \{ */
 -
 -BGpic *ED_view3D_background_image_new(View3D *v3d)
 -{
 -      BGpic *bgpic = MEM_callocN(sizeof(BGpic), "Background Image");
 -
 -      bgpic->rotation = 0.0f;
 -      bgpic->size = 5.0f;
 -      bgpic->blend = 0.5f;
 -      bgpic->iuser.fie_ima = 2;
 -      bgpic->iuser.ok = 1;
 -      bgpic->view = 0; /* 0 for all */
 -      bgpic->flag |= V3D_BGPIC_EXPANDED;
 -
 -      BLI_addtail(&v3d->bgpicbase, bgpic);
 -
 -      return bgpic;
 -}
  
- void ED_view3D_lock_clear(View3D *v3d)
 -void ED_view3D_background_image_remove(View3D *v3d, BGpic *bgpic)
--{
-       v3d->ob_centre = NULL;
-       v3d->ob_centre_bone[0] = '\0';
-       v3d->ob_centre_cursor = false;
-       v3d->flag2 &= ~V3D_LOCK_CAMERA;
 -      BLI_remlink(&v3d->bgpicbase, bgpic);
 -
 -      MEM_freeN(bgpic);
 -}
 -
 -void ED_view3D_background_image_clear(View3D *v3d)
 -{
 -      BGpic *bgpic = v3d->bgpicbase.first;
 -
 -      while (bgpic) {
 -              BGpic *next_bgpic = bgpic->next;
 -
 -              ED_view3D_background_image_remove(v3d, bgpic);
 -
 -              bgpic = next_bgpic;
 -      }
--}
 -
 -/** \} */
index c555358f4c30e0441e796a804f33fbe42f89ebc7,bb8279b9877d69fc1e8b155d42bd205e4a3b8d2a..3af7f5c8ae8b2723ef15c74abc4a2e8a1d645258
@@@ -43,6 -43,7 +43,6 @@@
  #include "BKE_action.h"
  #include "BKE_camera.h"
  #include "BKE_context.h"
 -#include "BKE_depsgraph.h"
  #include "BKE_object.h"
  #include "BKE_global.h"
  #include "BKE_main.h"
  #include "BKE_scene.h"
  #include "BKE_screen.h"
  
 -#include "BIF_gl.h"
 +#include "DEG_depsgraph.h"
 +
  #include "BIF_glutil.h"
  
  #include "UI_resources.h"
  
 +#include "GPU_glew.h"
  #include "GPU_select.h"
 +#include "GPU_matrix.h"
  
  #include "WM_api.h"
  #include "WM_types.h"
@@@ -66,9 -64,6 +66,9 @@@
  #include "ED_screen.h"
  #include "ED_armature.h"
  
 +#include "DRW_engine.h"
 +
 +#include "DEG_depsgraph_query.h"
  
  #ifdef WITH_GAMEENGINE
  #  include "BLI_listbase.h"
@@@ -103,8 -98,10 +103,8 @@@ void view3d_region_operator_needs_openg
                RegionView3D *rv3d = ar->regiondata;
                
                wmSubWindowSet(win, ar->swinid);
 -              glMatrixMode(GL_PROJECTION);
 -              glLoadMatrixf(rv3d->winmat);
 -              glMatrixMode(GL_MODELVIEW);
 -              glLoadMatrixf(rv3d->viewmat);
 +              gpuLoadProjectionMatrix(rv3d->winmat);
 +              gpuLoadMatrix(rv3d->viewmat);
        }
  }
  
@@@ -448,9 -445,6 +448,9 @@@ void ED_view3d_smooth_view_force_finish
          View3D *v3d, ARegion *ar)
  {
        RegionView3D *rv3d = ar->regiondata;
 +      EvaluationContext eval_ctx;
 +
 +      CTX_data_eval_ctx(C, &eval_ctx);
  
        if (rv3d && rv3d->sms) {
                rv3d->sms->time_allowed = 0.0;  /* force finishing */
                /* force update of view matrix so tools that run immediately after
                 * can use them without redrawing first */
                Scene *scene = CTX_data_scene(C);
 -              ED_view3d_update_viewmat(scene, v3d, ar, NULL, NULL, NULL);
 +              ED_view3d_update_viewmat(&eval_ctx, scene, v3d, ar, NULL, NULL, NULL);
        }
  }
  
@@@ -501,7 -495,7 +501,7 @@@ static int view3d_camera_to_view_exec(b
  
        BKE_object_tfm_protected_restore(v3d->camera, &obtfm, v3d->camera->protectflag);
  
 -      DAG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
 +      DEG_id_tag_update(&v3d->camera->id, OB_RECALC_OB);
        rv3d->persp = RV3D_CAMOB;
        
        WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, v3d->camera);
@@@ -549,7 -543,6 +549,7 @@@ void VIEW3D_OT_camera_to_view(wmOperato
  static int view3d_camera_to_view_selected_exec(bContext *C, wmOperator *op)
  {
        Scene *scene = CTX_data_scene(C);
 +      ViewLayer *view_layer = CTX_data_view_layer(C);
        View3D *v3d = CTX_wm_view3d(C);  /* can be NULL */
        Object *camera_ob = v3d ? v3d->camera : scene->camera;
  
        }
  
        /* this function does all the important stuff */
 -      if (BKE_camera_view_frame_fit_to_scene(scene, v3d, camera_ob, r_co, &r_scale)) {
 +      if (BKE_camera_view_frame_fit_to_scene(scene, view_layer, camera_ob, r_co, &r_scale)) {
                ObjectTfmProtectedChannels obtfm;
                float obmat_new[4][4];
  
                BKE_object_tfm_protected_restore(camera_ob, &obtfm, OB_LOCK_SCALE | OB_LOCK_ROT4D);
  
                /* notifiers */
 -              DAG_id_tag_update(&camera_ob->id, OB_RECALC_OB);
 +              DEG_id_tag_update(&camera_ob->id, OB_RECALC_OB);
                WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, camera_ob);
                return OPERATOR_FINISHED;
        }
@@@ -736,35 -729,40 +736,35 @@@ void ED_view3d_clipping_calc_from_bound
        }
  }
  
 -void ED_view3d_clipping_calc(BoundBox *bb, float planes[4][4], bglMats *mats, const rcti *rect)
 +void ED_view3d_clipping_calc(BoundBox *bb, float planes[4][4], const ARegion *ar, const Object *ob, const rcti *rect)
  {
 -      float modelview[4][4];
 -      double xs, ys, p[3];
 -      int val, flip_sign, a;
 -
 -      /* near zero floating point values can give issues with gluUnProject
 -       * in side view on some implementations */
 -      if (fabs(mats->modelview[0]) < 1e-6) mats->modelview[0] = 0.0;
 -      if (fabs(mats->modelview[5]) < 1e-6) mats->modelview[5] = 0.0;
 -
 -      /* Set up viewport so that gluUnProject will give correct values */
 -      mats->viewport[0] = 0;
 -      mats->viewport[1] = 0;
 +      /* init in case unproject fails */
 +      memset(bb->vec, 0, sizeof(bb->vec));
  
        /* four clipping planes and bounding volume */
        /* first do the bounding volume */
 -      for (val = 0; val < 4; val++) {
 -              xs = (val == 0 || val == 3) ? rect->xmin : rect->xmax;
 -              ys = (val == 0 || val == 1) ? rect->ymin : rect->ymax;
 +      for (int val = 0; val < 4; val++) {
 +              float xs = (val == 0 || val == 3) ? rect->xmin : rect->xmax;
 +              float ys = (val == 0 || val == 1) ? rect->ymin : rect->ymax;
  
 -              gluUnProject(xs, ys, 0.0, mats->modelview, mats->projection, mats->viewport, &p[0], &p[1], &p[2]);
 -              copy_v3fl_v3db(bb->vec[val], p);
 +              ED_view3d_unproject(ar, xs, ys, 0.0, bb->vec[val]);
 +              ED_view3d_unproject(ar, xs, ys, 1.0, bb->vec[4 + val]);
 +      }
  
 -              gluUnProject(xs, ys, 1.0, mats->modelview, mats->projection, mats->viewport, &p[0], &p[1], &p[2]);
 -              copy_v3fl_v3db(bb->vec[4 + val], p);
 +      /* optionally transform to object space */
 +      if (ob) {
 +              float imat[4][4];
 +              invert_m4_m4(imat, ob->obmat);
 +
 +              for (int val = 0; val < 8; val++) {
 +                      mul_m4_v3(imat, bb->vec[val]);
 +              }
        }
  
        /* verify if we have negative scale. doing the transform before cross
         * product flips the sign of the vector compared to doing cross product
         * before transform then, so we correct for that. */
 -      for (a = 0; a < 16; a++)
 -              ((float *)modelview)[a] = mats->modelview[a];
 -      flip_sign = is_negative_m4(modelview);
 +      int flip_sign = (ob) ? is_negative_m4(ob->obmat) : false;
  
        ED_view3d_clipping_calc_from_boundbox(planes, bb, flip_sign);
  }
@@@ -840,7 -838,7 +840,7 @@@ float ED_view3d_depth_read_cached(cons
  }
  
  bool ED_view3d_depth_read_cached_normal(
 -        const ViewContext *vc, const bglMats *mats, const int mval[2],
 +        const ViewContext *vc, const int mval[2],
          float r_normal[3])
  {
        /* Note: we could support passing in a radius.
  
                        const double depth = (double)ED_view3d_depth_read_cached(vc, mval_ofs);
                        if ((depth > depths->depth_range[0]) && (depth < depths->depth_range[1])) {
 -                              if (ED_view3d_depth_unproject(ar, mats, mval_ofs, depth, coords[i])) {
 +                              if (ED_view3d_depth_unproject(ar, mval_ofs, depth, coords[i])) {
                                        depths_valid[i] = true;
                                }
                        }
  }
  
  bool ED_view3d_depth_unproject(
 -        const ARegion *ar, const bglMats *mats,
 +        const ARegion *ar,
          const int mval[2], const double depth,
          float r_location_world[3])
  {
 -      double p[3];
 -      if (gluUnProject(
 -              (double)ar->winrct.xmin + mval[0] + 0.5,
 -              (double)ar->winrct.ymin + mval[1] + 0.5,
 -              depth, mats->modelview, mats->projection, (const GLint *)mats->viewport,
 -              &p[0], &p[1], &p[2]))
 -      {
 -              copy_v3fl_v3db(r_location_world, p);
 -              return true;
 -      }
 -      return false;
 +      float centx = (float)mval[0] + 0.5f;
 +      float centy = (float)mval[1] + 0.5f;
 +      return ED_view3d_unproject(ar, centx, centy, depth, r_location_world);
  }
  
  /** \} */
@@@ -928,7 -934,6 +928,7 @@@ void ED_view3d_dist_range_get
  
  /* copies logic of get_view3d_viewplane(), keep in sync */
  bool ED_view3d_clip_range_get(
 +        const Depsgraph *depsgraph,
          const View3D *v3d, const RegionView3D *rv3d,
          float *r_clipsta, float *r_clipend,
          const bool use_ortho_factor)
        CameraParams params;
  
        BKE_camera_params_init(&params);
 -      BKE_camera_params_from_view3d(&params, v3d, rv3d);
 +      BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
  
        if (use_ortho_factor && params.is_ortho) {
                const float fac = 2.0f / (params.clipend - params.clipsta);
  }
  
  bool ED_view3d_viewplane_get(
 +        const Depsgraph *depsgraph,
          const View3D *v3d, const RegionView3D *rv3d, int winx, int winy,
          rctf *r_viewplane, float *r_clipsta, float *r_clipend, float *r_pixsize)
  {
        CameraParams params;
  
        BKE_camera_params_init(&params);
 -      BKE_camera_params_from_view3d(&params, v3d, rv3d);
 +      BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
        BKE_camera_params_compute_viewplane(&params, winx, winy, 1.0f, 1.0f);
  
        if (r_viewplane) *r_viewplane = params.viewplane;
@@@ -997,14 -1001,14 +997,14 @@@ void ED_view3d_polygon_offset(const Reg
  /**
   * \param rect optional for picking (can be NULL).
   */
 -void view3d_winmatrix_set(ARegion *ar, const View3D *v3d, const rcti *rect)
 +void view3d_winmatrix_set(const Depsgraph *depsgraph, ARegion *ar, const View3D *v3d, const rcti *rect)
  {
        RegionView3D *rv3d = ar->regiondata;
        rctf viewplane;
        float clipsta, clipend;
        bool is_ortho;
        
 -      is_ortho = ED_view3d_viewplane_get(v3d, rv3d, ar->winx, ar->winy, &viewplane, &clipsta, &clipend, NULL);
 +      is_ortho = ED_view3d_viewplane_get(depsgraph, v3d, rv3d, ar->winx, ar->winy, &viewplane, &clipsta, &clipend, NULL);
        rv3d->is_persp = !is_ortho;
  
  #if 0
        }
  
        if (is_ortho) {
 -              wmOrtho(viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, clipsta, clipend);
 +              gpuOrtho(viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, clipsta, clipend);
        }
        else {
 -              wmFrustum(viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, clipsta, clipend);
 +              gpuFrustum(viewplane.xmin, viewplane.xmax, viewplane.ymin, viewplane.ymax, clipsta, clipend);
        }
  
        /* update matrix in 3d view region */
 -      glGetFloatv(GL_PROJECTION_MATRIX, (float *)rv3d->winmat);
 +      gpuGetProjectionMatrix(rv3d->winmat);
  }
  
  static void obmat_to_viewmat(RegionView3D *rv3d, Object *ob)
@@@ -1116,7 -1120,6 +1116,7 @@@ bool ED_view3d_lock(RegionView3D *rv3d
  /**
   * Sets #RegionView3D.viewmat
   *
 + * \param eval_ctx: Context.
   * \param scene: Scene for camera and cursor location.
   * \param v3d: View 3D space data.
   * \param rv3d: 3D region which stores the final matrices.
   * \note don't set windows active in here, is used by renderwin too.
   */
  void view3d_viewmatrix_set(
 -        Scene *scene,
 +        const EvaluationContext *eval_ctx, Scene *scene,
          const View3D *v3d, RegionView3D *rv3d, const float rect_scale[2])
  {
        if (rv3d->persp == RV3D_CAMOB) {      /* obs/camera */
                if (v3d->camera) {
 -                      BKE_object_where_is_calc(scene, v3d->camera);
 -                      obmat_to_viewmat(rv3d, v3d->camera);
 +                      const Depsgraph *depsgraph = eval_ctx->depsgraph;
 +                      Object *camera_object = DEG_get_evaluated_object(depsgraph, v3d->camera);
 +                      BKE_object_where_is_calc(eval_ctx, scene, camera_object);
 +                      obmat_to_viewmat(rv3d, camera_object);
                }
                else {
                        quat_to_mat4(rv3d->viewmat, rv3d->viewquat);
                        vec[2] = 0.0f;
  
                        if (rect_scale) {
+                               /* Since 'RegionView3D.winmat' has been calculated and this function doesn't take the 'ARegion'
+                                * we don't know about the region size.
+                                * Use 'rect_scale' when drawing a sub-region to apply 2D offset,
+                                * scaled by the difference between the sub-region and the region size.
+                                */
                                vec[0] /= rect_scale[0];
                                vec[1] /= rect_scale[1];
                        }
@@@ -1224,11 -1230,10 +1229,11 @@@ void view3d_opengl_select_cache_end(voi
   * \note (vc->obedit == NULL) can be set to explicitly skip edit-object selection.
   */
  int view3d_opengl_select(
 -        ViewContext *vc, unsigned int *buffer, unsigned int bufsize, const rcti *input,
 +        const EvaluationContext *eval_ctx, ViewContext *vc, unsigned int *buffer, unsigned int bufsize, const rcti *input,
          eV3DSelectMode select_mode)
  {
        struct bThemeState theme_state;
 +      Depsgraph *graph = vc->depsgraph;
        Scene *scene = vc->scene;
        View3D *v3d = vc->v3d;
        ARegion *ar = vc->ar;
  
        /* Important we use the 'viewmat' and don't re-calculate since
         * the object & bone view locking takes 'rect' into account, see: T51629. */
 -      ED_view3d_draw_setup_view(vc->win, scene, ar, v3d, vc->rv3d->viewmat, NULL, &rect);
 +      ED_view3d_draw_setup_view(vc->win, eval_ctx, scene, ar, v3d, vc->rv3d->viewmat, NULL, &rect);
  
        if (v3d->drawtype > OB_WIRE) {
                v3d->zbuf = true;
        
        GPU_select_begin(buffer, bufsize, &rect, gpu_select_mode, 0);
  
 -      ED_view3d_draw_select_loop(vc, scene, v3d, ar, use_obedit_skip, use_nearest);
 +#ifdef WITH_OPENGL_LEGACY
 +      if (IS_VIEWPORT_LEGACY(vc->v3d)) {
 +              ED_view3d_draw_select_loop(vc, scene, sl, v3d, ar, use_obedit_skip, use_nearest);
 +      }
 +      else
 +#else
 +      {
 +              DRW_draw_select_loop(graph, ar, v3d, use_obedit_skip, use_nearest, &rect);
 +      }
 +#endif /* WITH_OPENGL_LEGACY */
  
        hits = GPU_select_end();
        
        if (do_passes && (hits > 0)) {
                GPU_select_begin(buffer, bufsize, &rect, GPU_SELECT_NEAREST_SECOND_PASS, hits);
  
 -              ED_view3d_draw_select_loop(vc, scene, v3d, ar, use_obedit_skip, use_nearest);
 +#ifdef WITH_OPENGL_LEGACY
 +              if (IS_VIEWPORT_LEGACY(vc->v3d)) {
 +                      ED_view3d_draw_select_loop(vc, scene, sl, v3d, ar, use_obedit_skip, use_nearest);
 +              }
 +              else
 +#else
 +              {
 +                      DRW_draw_select_loop(graph, ar, v3d, use_obedit_skip, use_nearest, &rect);
 +              }
 +#endif /* WITH_OPENGL_LEGACY */
  
                GPU_select_end();
        }
  
        G.f &= ~G_PICKSEL;
 -      ED_view3d_draw_setup_view(vc->win, scene, ar, v3d, vc->rv3d->viewmat, NULL, NULL);
 +      ED_view3d_draw_setup_view(vc->win, eval_ctx, scene, ar, v3d, vc->rv3d->viewmat, NULL, NULL);
        
        if (v3d->drawtype > OB_WIRE) {
                v3d->zbuf = 0;
@@@ -1352,7 -1339,43 +1357,7 @@@ finally
        return hits;
  }
  
 -/* ********************** local view operator ******************** */
 -
 -static unsigned int free_localbit(Main *bmain)
 -{
 -      unsigned int lay;
 -      ScrArea *sa;
 -      bScreen *sc;
 -      
 -      lay = 0;
 -      
 -      /* sometimes we loose a localview: when an area is closed */
 -      /* check all areas: which localviews are in use? */
 -      for (sc = bmain->screen.first; sc; sc = sc->id.next) {
 -              for (sa = sc->areabase.first; sa; sa = sa->next) {
 -                      SpaceLink *sl = sa->spacedata.first;
 -                      for (; sl; sl = sl->next) {
 -                              if (sl->spacetype == SPACE_VIEW3D) {
 -                                      View3D *v3d = (View3D *) sl;
 -                                      lay |= v3d->lay;
 -                              }
 -                      }
 -              }
 -      }
 -      
 -      if ((lay & 0x01000000) == 0) return 0x01000000;
 -      if ((lay & 0x02000000) == 0) return 0x02000000;
 -      if ((lay & 0x04000000) == 0) return 0x04000000;
 -      if ((lay & 0x08000000) == 0) return 0x08000000;
 -      if ((lay & 0x10000000) == 0) return 0x10000000;
 -      if ((lay & 0x20000000) == 0) return 0x20000000;
 -      if ((lay & 0x40000000) == 0) return 0x40000000;
 -      if ((lay & 0x80000000) == 0) return 0x80000000;
 -      
 -      return 0;
 -}
 -
 -int ED_view3d_scene_layer_set(int lay, const int *values, int *active)
 +int ED_view3d_view_layer_set(int lay, const int *values, int *active)
  {
        int i, tot = 0;
        
        return lay;
  }
  
 -static bool view3d_localview_init(
 -        wmWindowManager *wm, wmWindow *win,
 -        Main *bmain, Scene *scene, ScrArea *sa, const int smooth_viewtx,
 -        ReportList *reports)
 -{
 -      View3D *v3d = sa->spacedata.first;
 -      Base *base;
 -      float min[3], max[3], box[3], mid[3];
 -      float size = 0.0f;
 -      unsigned int locallay;
 -      bool ok = false;
 -
 -      if (v3d->localvd) {
 -              return ok;
 -      }
 -
 -      INIT_MINMAX(min, max);
 -
 -      locallay = free_localbit(bmain);
 -
 -      if (locallay == 0) {
 -              BKE_report(reports, RPT_ERROR, "No more than 8 local views");
 -              ok = false;
 -      }
 -      else {
 -              if (scene->obedit) {
 -                      BKE_object_minmax(scene->obedit, min, max, false);
 -                      
 -                      ok = true;
 -              
 -                      BASACT->lay |= locallay;
 -                      scene->obedit->lay = BASACT->lay;
 -              }
 -              else {
 -                      for (base = FIRSTBASE; base; base = base->next) {
 -                              if (TESTBASE(v3d, base)) {
 -                                      BKE_object_minmax(base->object, min, max, false);
 -                                      base->lay |= locallay;
 -                                      base->object->lay = base->lay;
 -                                      ok = true;
 -                              }
 -                      }
 -              }
 -
 -              sub_v3_v3v3(box, max, min);
 -              size = max_fff(box[0], box[1], box[2]);
 -      }
 -      
 -      if (ok == true) {
 -              ARegion *ar;
 -              
 -              v3d->localvd = MEM_mallocN(sizeof(View3D), "localview");
 -              
 -              memcpy(v3d->localvd, v3d, sizeof(View3D));
 -
 -              mid_v3_v3v3(mid, min, max);
 -
 -              copy_v3_v3(v3d->cursor, mid);
 -
 -              for (ar = sa->regionbase.first; ar; ar = ar->next) {
 -                      if (ar->regiontype == RGN_TYPE_WINDOW) {
 -                              RegionView3D *rv3d = ar->regiondata;
 -                              bool ok_dist = true;
 -
 -                              /* new view values */
 -                              Object *camera_old = NULL;
 -                              float dist_new, ofs_new[3];
 -
 -                              rv3d->localvd = MEM_mallocN(sizeof(RegionView3D), "localview region");
 -                              memcpy(rv3d->localvd, rv3d, sizeof(RegionView3D));
 -
 -                              negate_v3_v3(ofs_new, mid);
 -
 -                              if (rv3d->persp == RV3D_CAMOB) {
 -                                      rv3d->persp = RV3D_PERSP;
 -                                      camera_old = v3d->camera;
 -                              }
 -
 -                              if (rv3d->persp == RV3D_ORTHO) {
 -                                      if (size < 0.0001f) {
 -                                              ok_dist = false;
 -                                      }
 -                              }
 -
 -                              if (ok_dist) {
 -                                      dist_new = ED_view3d_radius_to_dist(v3d, ar, rv3d->persp, true, (size / 2) * VIEW3D_MARGIN);
 -                                      if (rv3d->persp == RV3D_PERSP) {
 -                                              /* don't zoom closer than the near clipping plane */
 -                                              dist_new = max_ff(dist_new, v3d->near * 1.5f);
 -                                      }
 -                              }
 -
 -                              ED_view3d_smooth_view_ex(
 -                                      wm, win, sa, v3d, ar, smooth_viewtx,
 -                                          &(const V3D_SmoothParams) {
 -                                              .camera_old = camera_old,
 -                                              .ofs = ofs_new, .quat = rv3d->viewquat,
 -                                              .dist = ok_dist ? &dist_new : NULL, .lens = &v3d->lens});
 -                      }
 -              }
 -              
 -              v3d->lay = locallay;
 -      }
 -      else {
 -              /* clear flags */ 
 -              for (base = FIRSTBASE; base; base = base->next) {
 -                      if (base->lay & locallay) {
 -                              base->lay -= locallay;
 -                              if (base->lay == 0) base->lay = v3d->layact;
 -                              if (base->object != scene->obedit) base->flag |= SELECT;
 -                              base->object->lay = base->lay;
 -                      }
 -              }
 -      }
 -
 -      DAG_on_visible_update(bmain, false);
 -
 -      return ok;
 -}
 -
 -static void restore_localviewdata(wmWindowManager *wm, wmWindow *win, Main *bmain, Scene *scene, ScrArea *sa, const int smooth_viewtx)
 -{
 -      const bool free = true;
 -      ARegion *ar;
 -      View3D *v3d = sa->spacedata.first;
 -      Object *camera_old, *camera_new;
 -      
 -      if (v3d->localvd == NULL) return;
 -      
 -      camera_old = v3d->camera;
 -      camera_new = v3d->localvd->camera;
 -
 -      v3d->lay = v3d->localvd->lay;
 -      v3d->layact = v3d->localvd->layact;
 -      v3d->drawtype = v3d->localvd->drawtype;
 -      v3d->camera = v3d->localvd->camera;
 -      
 -      if (free) {
 -              MEM_freeN(v3d->localvd);
 -              v3d->localvd = NULL;
 -      }
 -      
 -      for (ar = sa->regionbase.first; ar; ar = ar->next) {
 -              if (ar->regiontype == RGN_TYPE_WINDOW) {
 -                      RegionView3D *rv3d = ar->regiondata;
 -                      
 -                      if (rv3d->localvd) {
 -                              Object *camera_old_rv3d, *camera_new_rv3d;
 -
 -                              camera_old_rv3d = (rv3d->persp          == RV3D_CAMOB) ? camera_old : NULL;
 -                              camera_new_rv3d = (rv3d->localvd->persp == RV3D_CAMOB) ? camera_new : NULL;
 -
 -                              rv3d->view = rv3d->localvd->view;
 -                              rv3d->persp = rv3d->localvd->persp;
 -                              rv3d->camzoom = rv3d->localvd->camzoom;
 -
 -                              ED_view3d_smooth_view_ex(
 -                                      wm, win, sa,
 -                                      v3d, ar, smooth_viewtx,
 -                                      &(const V3D_SmoothParams) {
 -                                          .camera_old = camera_old_rv3d, .camera = camera_new_rv3d,
 -                                          .ofs = rv3d->localvd->ofs, .quat = rv3d->localvd->viewquat,
 -                                          .dist = &rv3d->localvd->dist});
 -
 -                              if (free) {
 -                                      MEM_freeN(rv3d->localvd);
 -                                      rv3d->localvd = NULL;
 -                              }
 -                      }
 -
 -                      ED_view3d_shade_update(bmain, scene, v3d, sa);
 -              }
 -      }
 -}
 -
 -static bool view3d_localview_exit(
 -        wmWindowManager *wm, wmWindow *win,
 -        Main *bmain, Scene *scene, ScrArea *sa, const int smooth_viewtx)
 -{
 -      View3D *v3d = sa->spacedata.first;
 -      struct Base *base;
 -      unsigned int locallay;
 -      
 -      if (v3d->localvd) {
 -              
 -              locallay = v3d->lay & 0xFF000000;
 -
 -              restore_localviewdata(wm, win, bmain, scene, sa, smooth_viewtx);
 -
 -              /* for when in other window the layers have changed */
 -              if (v3d->scenelock) v3d->lay = scene->lay;
 -              
 -              for (base = FIRSTBASE; base; base = base->next) {
 -                      if (base->lay & locallay) {
 -                              base->lay -= locallay;
 -                              if (base->lay == 0) base->lay = v3d->layact;
 -                              if (base->object != scene->obedit) {
 -                                      base->flag |= SELECT;
 -                                      base->object->flag |= SELECT;
 -                              }
 -                              base->object->lay = base->lay;
 -                      }
 -              }
 -              
 -              DAG_on_visible_update(bmain, false);
 -
 -              return true;
 -      }
 -      else {
 -              return false;
 -      }
 -}
 -
 -static int localview_exec(bContext *C, wmOperator *op)
 -{
 -      const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
 -      wmWindowManager *wm = CTX_wm_manager(C);
 -      wmWindow *win = CTX_wm_window(C);
 -      Main *bmain = CTX_data_main(C);
 -      Scene *scene = CTX_data_scene(C);
 -      ScrArea *sa = CTX_wm_area(C);
 -      View3D *v3d = CTX_wm_view3d(C);
 -      bool changed;
 -      
 -      if (v3d->localvd) {
 -              changed = view3d_localview_exit(wm, win, bmain, scene, sa, smooth_viewtx);
 -      }
 -      else {
 -              changed = view3d_localview_init(wm, win, bmain, scene, sa, smooth_viewtx, op->reports);
 -      }
 -
 -      if (changed) {
 -              DAG_id_type_tag(bmain, ID_OB);
 -              ED_area_tag_redraw(sa);
 -
 -              /* unselected objects become selected when exiting */
 -              if (v3d->localvd == NULL) {
 -                      WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
 -              }
 -
 -              return OPERATOR_FINISHED;
 -      }
 -      else {
 -              return OPERATOR_CANCELLED;
 -      }
 -}
 -
 -void VIEW3D_OT_localview(wmOperatorType *ot)
 -{
 -      /* identifiers */
 -      ot->name = "Local View";
 -      ot->description = "Toggle display of selected object(s) separately and centered in view";
 -      ot->idname = "VIEW3D_OT_localview";
 -      
 -      /* api callbacks */
 -      ot->exec = localview_exec;
 -      ot->flag = OPTYPE_UNDO; /* localview changes object layer bitflags */
 -      
 -      ot->poll = ED_operator_view3d_active;
 -}
 -
  #ifdef WITH_GAMEENGINE
  
  static ListBase queue_back;
@@@ -1428,6 -1712,7 +1433,6 @@@ static void RestoreState(bContext *C, w
                win->queue = queue_back;
        
        GPU_state_init();
 -      GPU_set_tpage(NULL, 0, 0);
  
        glPopAttrib();
  }
@@@ -1470,6 -1755,10 +1475,6 @@@ static void game_set_commmandline_optio
                SYS_WriteCommandLineInt(syshandle, "blender_material", test);
                test = (gm->matmode == GAME_MAT_GLSL);
                SYS_WriteCommandLineInt(syshandle, "blender_glsl_material", test);
 -              test = (gm->flag & GAME_DISPLAY_LISTS);
 -              SYS_WriteCommandLineInt(syshandle, "displaylists", test);
 -
 -
        }
  }
  
  
  static int game_engine_poll(bContext *C)
  {
 -      bScreen *screen;
 +      const wmWindow *win = CTX_wm_window(C);
 +      const Scene *scene = WM_window_get_active_scene(win);
 +
        /* we need a context and area to launch BGE
         * it's a temporary solution to avoid crash at load time
         * if we try to auto run the BGE. Ideally we want the
         * context to be set as soon as we load the file. */
  
 -      if (CTX_wm_window(C) == NULL) return 0;
 -      if ((screen = CTX_wm_screen(C)) == NULL) return 0;
 +      if (win == NULL) return 0;
 +      if (CTX_wm_screen(C) == NULL) return 0;
  
        if (CTX_data_mode_enum(C) != CTX_MODE_OBJECT)
                return 0;
  
 -      if (!BKE_scene_uses_blender_game(screen->scene))
 +      if (!BKE_scene_uses_blender_game(scene))
                return 0;
  
        return 1;
@@@ -1559,10 -1846,9 +1564,10 @@@ static int game_engine_exec(bContext *C
            (startscene->gm.framing.type == SCE_GAMEFRAMING_BARS) &&
            (startscene->gm.stereoflag != STEREO_DOME))
        {
 +              const Depsgraph *depsgraph = CTX_data_depsgraph(C);
                /* Letterbox */
                rctf cam_framef;
 -              ED_view3d_calc_camera_border(startscene, ar, CTX_wm_view3d(C), rv3d, &cam_framef, false);
 +              ED_view3d_calc_camera_border(startscene, depsgraph, ar, CTX_wm_view3d(C), rv3d, &cam_framef, false);
                cam_frame.xmin = cam_framef.xmin + ar->winrct.xmin;
                cam_frame.xmax = cam_framef.xmax + ar->winrct.xmin;
                cam_frame.ymin = cam_framef.ymin + ar->winrct.ymin;
  
        //XXX restore_all_scene_cfra(scene_cfra_store);
        BKE_scene_set_background(CTX_data_main(C), startscene);
 -      //XXX BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, scene->lay);
 +      //XXX BKE_scene_graph_update_for_newframe(bmain->eval_ctx, bmain, scene, depsgraph);
  
        BLI_callback_exec(bmain, &startscene->id, BLI_CB_EVT_GAME_POST);