Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Fri, 28 Apr 2017 17:39:24 +0000 (03:39 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Fri, 28 Apr 2017 17:39:24 +0000 (03:39 +1000)
1  2 
source/blender/editors/space_view3d/view3d_edit.c

index 028d613ba8c0ebafc95459c71c5604584414dfc4,f712c7906636683126eacdc0fd17cfb403154f62..42e8759c6dcb386a65ff8ef7139e320a0c16d74a
@@@ -60,7 -60,9 +60,7 @@@
  #include "BKE_action.h"
  #include "BKE_depsgraph.h" /* for ED_view3d_camera_lock_sync */
  
 -
  #include "BIF_gl.h"
 -#include "BIF_glutil.h"
  
  #include "WM_api.h"
  #include "WM_types.h"
@@@ -83,6 -85,8 +83,8 @@@
  
  #include "view3d_intern.h"  /* own include */
  
+ static bool view3d_ensure_persp(struct View3D *v3d, ARegion *ar);
  bool ED_view3d_offset_lock_check(const  View3D *v3d, const  RegionView3D *rv3d)
  {
        return (rv3d->persp != RV3D_CAMOB) && (v3d->ob_centre_cursor || v3d->ob_centre);
@@@ -617,8 -621,7 +619,8 @@@ static bool view3d_orbit_calc_center(bC
        bool is_set = false;
  
        Scene *scene = CTX_data_scene(C);
 -      Object *ob_act = OBACT;
 +      SceneLayer *sl = CTX_data_scene_layer(C);
 +      Object *ob_act = OBACT_NEW;
  
        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_NEW; base; base = base->next) {
 +                      if (TESTBASE_NEW(base)) {
                                /* use the boundbox if we can */
                                Object *ob = base->object;
  
        return is_set;
  }
  
+ enum eViewOpsOrbit {
+       VIEWOPS_ORBIT_DEFAULT = 0,
+       VIEWOPS_ORBIT_SELECT = 1,
+       VIEWOPS_ORBIT_DEPTH = 2,
+ };
+ static enum eViewOpsOrbit viewops_orbit_mode_ex(bool use_select, bool use_depth)
+ {
+       if (use_select) {
+               return VIEWOPS_ORBIT_SELECT;
+       }
+       else if (use_depth) {
+               return VIEWOPS_ORBIT_DEPTH;
+       }
+       else {
+               return VIEWOPS_ORBIT_DEFAULT;
+       }
+ }
+ static enum eViewOpsOrbit viewops_orbit_mode(void)
+ {
+       return viewops_orbit_mode_ex(
+               (U.uiflag & USER_ORBIT_SELECTION) != 0,
+               (U.uiflag & USER_ZBUF_ORBIT) != 0);
+ }
  /**
   * Calculate the values for #ViewOpsData
   */
- static void viewops_data_create_ex(bContext *C, wmOperator *op, const wmEvent *event,
-                                    const bool use_orbit_select,
-                                    const bool use_orbit_zbuf)
+ static void viewops_data_create_ex(
+         bContext *C, wmOperator *op, const wmEvent *event,
+         bool switch_from_camera, enum eViewOpsOrbit orbit_mode)
  {
        ViewOpsData *vod = op->customdata;
        RegionView3D *rv3d = vod->rv3d;
  
 -                      vod->scene, vod->ar, vod->v3d,
+       /* we need the depth info before changing any viewport options */
+       if (orbit_mode == VIEWOPS_ORBIT_DEPTH) {
++              struct Depsgraph *graph = CTX_data_depsgraph(C);
+               float fallback_depth_pt[3];
+               view3d_operator_needs_opengl(C); /* needed for zbuf drawing */
+               negate_v3_v3(fallback_depth_pt, rv3d->ofs);
+               vod->use_dyn_ofs = ED_view3d_autodist(
++                      graph, vod->scene, vod->ar, vod->v3d,
+                       event->mval, vod->dyn_ofs, true, fallback_depth_pt);
+       }
+       else {
+               vod->use_dyn_ofs = false;
+       }
+       if (switch_from_camera) {
+               /* switch from camera view when: */
+               if (view3d_ensure_persp(vod->v3d, vod->ar)) {
+                       /* If we're switching from camera view to the perspective one,
+                        * need to tag viewport update, so camera vuew and borders
+                        * are properly updated.
+                        */
+                       ED_region_tag_redraw(vod->ar);
+               }
+       }
        /* set the view from the camera, if view locking is enabled.
         * we may want to make this optional but for now its needed always */
        ED_view3d_camera_lock_init(vod->v3d, vod->rv3d);
        vod->origx = vod->oldx = event->x;
        vod->origy = vod->oldy = event->y;
        vod->origkey = event->type; /* the key that triggered the operator.  */
-       vod->use_dyn_ofs = false;
        copy_v3_v3(vod->ofs, rv3d->ofs);
  
-       if (use_orbit_select) {
+       if (orbit_mode == VIEWOPS_ORBIT_SELECT) {
  
                vod->use_dyn_ofs = true;
  
  
                negate_v3(vod->dyn_ofs);
        }
-       else if (use_orbit_zbuf) {
-               Scene *scene = CTX_data_scene(C);
-               struct Depsgraph *graph = CTX_data_depsgraph(C);
-               float fallback_depth_pt[3];
-               view3d_operator_needs_opengl(C); /* needed for zbuf drawing */
-               negate_v3_v3(fallback_depth_pt, rv3d->ofs);
-               if ((vod->use_dyn_ofs = ED_view3d_autodist(graph, scene, vod->ar, vod->v3d,
-                                                          event->mval, vod->dyn_ofs, true, fallback_depth_pt)))
-               {
+       else if (orbit_mode == VIEWOPS_ORBIT_DEPTH) {
+               if (vod->use_dyn_ofs) {
                        if (rv3d->is_persp) {
                                float my_origin[3]; /* original G.vd->ofs */
                                float my_pivot[3]; /* view */
        rv3d->rflag |= RV3D_NAVIGATING;
  }
  
- static void viewops_data_create(bContext *C, wmOperator *op, const wmEvent *event)
+ static void viewops_data_create(bContext *C, wmOperator *op, const wmEvent *event, bool switch_from_camera)
  {
-       viewops_data_create_ex(
-               C, op, event,
-               (U.uiflag & USER_ORBIT_SELECTION) != 0,
-               (U.uiflag & USER_ZBUF_ORBIT) != 0);
+       enum eViewOpsOrbit orbit_mode = viewops_orbit_mode();
+       viewops_data_create_ex(C, op, event, switch_from_camera, orbit_mode);
  }
  
  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);
  }
  /** \} */
@@@ -1221,16 -1262,7 +1264,7 @@@ static int viewrotate_invoke(bContext *
  
        ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
  
-       /* switch from camera view when: */
-       if (view3d_ensure_persp(vod->v3d, vod->ar)) {
-               /* If we're switching from camera view to the perspective one,
-                * need to tag viewport update, so camera vuew and borders
-                * are properly updated.
-                */
-               ED_region_tag_redraw(vod->ar);
-       }
-       viewops_data_create(C, op, event);
+       viewops_data_create(C, op, event, true);
  
        if (ELEM(event->type, MOUSEPAN, MOUSEROTATE)) {
                /* Rotate direction we keep always same */
@@@ -1639,8 -1671,9 +1673,9 @@@ static int ndof_orbit_invoke(bContext *
                const wmNDOFMotionData *ndof = event->customdata;
  
                viewops_data_alloc(C, op);
-               viewops_data_create_ex(C, op, event,
-                                      (U.uiflag & USER_ORBIT_SELECTION) != 0, false);
+               viewops_data_create_ex(
+                       C, op, event,
+                       viewops_orbit_mode_ex((U.uiflag & USER_ORBIT_SELECTION) != 0, false), false);
                vod = op->customdata;
  
                ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
@@@ -1707,8 -1740,9 +1742,9 @@@ static int ndof_orbit_zoom_invoke(bCont
                const wmNDOFMotionData *ndof = event->customdata;
  
                viewops_data_alloc(C, op);
-               viewops_data_create_ex(C, op, event,
-                                      (U.uiflag & USER_ORBIT_SELECTION) != 0, false);
+               viewops_data_create_ex(
+                       C, op, event,
+                       viewops_orbit_mode_ex((U.uiflag & USER_ORBIT_SELECTION) != 0, false), false);
  
                vod = op->customdata;
  
@@@ -2022,7 -2056,7 +2058,7 @@@ static int viewmove_invoke(bContext *C
  
        /* makes op->customdata */
        viewops_data_alloc(C, op);
-       viewops_data_create(C, op, event);
+       viewops_data_create(C, op, event, false);
        vod = op->customdata;
  
        ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
@@@ -2503,7 -2537,7 +2539,7 @@@ static int viewzoom_invoke(bContext *C
  
        /* makes op->customdata */
        viewops_data_alloc(C, op);
-       viewops_data_create(C, op, event);
+       viewops_data_create(C, op, event, false);
        vod = op->customdata;
  
        ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
@@@ -2776,7 -2810,7 +2812,7 @@@ static int viewdolly_invoke(bContext *C
                ED_region_tag_redraw(vod->ar);
        }
  
-       viewops_data_create(C, op, event);
+       viewops_data_create(C, op, event, false);
  
  
        /* if one or the other zoom position aren't set, set from event */
@@@ -2942,7 -2976,6 +2978,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);
 +      SceneLayer *sl = CTX_data_scene_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 = sl->object_bases.first; base; base = base->next) {
 +              if (BASE_VISIBLE_NEW(base)) {
                        changed = true;
  
                        if (skip_camera && base->object == v3d->camera) {
@@@ -3027,10 -3060,9 +3063,10 @@@ static int viewselected_exec(bContext *
        ARegion *ar = CTX_wm_region(C);
        View3D *v3d = CTX_wm_view3d(C);
        Scene *scene = CTX_data_scene(C);
 +      SceneLayer *sl = CTX_data_scene_layer(C);
        bGPdata *gpd = CTX_data_gpencil_data(C);
        const bool is_gp_edit = ((gpd) && (gpd->flag & GP_DATA_STROKE_EDITMODE));
 -      Object *ob = OBACT;
 +      Object *ob = OBACT_NEW;
        Object *obedit = CTX_data_edit_object(C);
        float min[3], max[3];
        bool ok = false, ok_dist = true;
                /* 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 = sl->object_bases.first; base; base = base->next) {
 +                      if (TESTBASELIB_NEW(base)) {
                                if (base->object->type == OB_ARMATURE)
                                        if (base->object->mode & OB_MODE_POSE)
                                                break;
                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, sl, 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_NEW; base; base = base->next) {
 +                      if (TESTBASE_NEW(base)) {
  
                                if (skip_camera && base->object == v3d->camera) {
                                        continue;
@@@ -3278,7 -3310,6 +3314,7 @@@ static int viewcenter_pick_invoke(bCont
        ARegion *ar = CTX_wm_region(C);
  
        if (rv3d) {
 +              struct Depsgraph *graph = CTX_data_depsgraph(C);
                float new_ofs[3];
                const int smooth_viewtx = WM_operator_smooth_viewtx_get(op);
  
  
                view3d_operator_needs_opengl(C);
  
 -              if (ED_view3d_autodist(scene, ar, v3d, event->mval, new_ofs, false, NULL)) {
 +              if (ED_view3d_autodist(graph, scene, ar, v3d, event->mval, new_ofs, false, NULL)) {
                        /* pass */
                }
                else {
@@@ -3558,8 -3589,9 +3594,8 @@@ static int view3d_zoom_border_exec(bCon
        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);
        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(CTX_data_depsgraph(C), scene, 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]))
 +              if (depth_close != FLT_MAX && ED_view3d_unproject(ar, centx, centy, depth_close, p))
                {
 -                      new_ofs[0] = -p[0];
 -                      new_ofs[1] = -p[1];
 -                      new_ofs[2] = -p[2];
 +                      negate_v3_v3(new_ofs, p);
                }
                else {
                        float mval_f[2];
@@@ -3861,7 -3907,6 +3897,7 @@@ static int viewnumpad_exec(bContext *C
        ARegion *ar;
        RegionView3D *rv3d;
        Scene *scene = CTX_data_scene(C);
 +      SceneLayer *sl = CTX_data_scene_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_NEW;
  
                                if (!rv3d->smooth_timer) {
                                        /* store settings of current view before allowing overwriting with camera view
@@@ -4289,7 -4334,7 +4325,7 @@@ static int viewroll_invoke(bContext *C
        else {
                /* makes op->customdata */
                viewops_data_alloc(C, op);
-               viewops_data_create(C, op, event);
+               viewops_data_create(C, op, event, false);
                vod = op->customdata;
  
                ED_view3d_smooth_view_force_finish(C, vod->v3d, vod->ar);
@@@ -4366,7 -4411,7 +4402,7 @@@ static int viewpan_invoke(bContext *C, 
        else if (pandir == V3D_VIEW_PANDOWN)   { y =  25; }
  
        viewops_data_alloc(C, op);
-       viewops_data_create(C, op, event);
+       viewops_data_create(C, op, event, false);
        ViewOpsData *vod = op->customdata;
  
        viewmove_apply(vod, vod->oldx + x, vod->oldy + y);
@@@ -4590,8 -4635,9 +4626,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;
  }
@@@ -4674,9 -4724,8 +4710,9 @@@ void ED_view3d_cursor3d_position(bConte
        }
  
        if (U.uiflag & USER_ZBUF_CURSOR) {  /* maybe this should be accessed some other way */
 +              struct Depsgraph *graph = CTX_data_depsgraph(C);
                view3d_operator_needs_opengl(C);
 -              if (ED_view3d_autodist(scene, ar, v3d, mval, fp, true, NULL))
 +              if (ED_view3d_autodist(graph, scene, ar, v3d, mval, fp, true, NULL))
                        depth_used = true;
        }
  
@@@ -4749,6 -4798,45 +4785,6 @@@ void VIEW3D_OT_cursor3d(wmOperatorType 
  
  /* ***************** manipulator op ******************* */
  
 -
 -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);
 -}
 -
  static int enable_manipulator_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
  {
        View3D *v3d = CTX_wm_view3d(C);
@@@ -4852,17 -4940,22 +4888,17 @@@ static float view_autodist_depth_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,
 +        struct Depsgraph *graph, Scene *scene, 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(graph, scene, 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]))
 +              if (ED_view3d_unproject(ar, centx, centy, depth_close, mouse_worldloc))
                {
 -                      mouse_worldloc[0] = (float)p[0];
 -                      mouse_worldloc[1] = (float)p[1];
 -                      mouse_worldloc[2] = (float)p[2];
                        return true;
                }
        }
        }
  }
  
 -void ED_view3d_autodist_init(Scene *scene, ARegion *ar, View3D *v3d, int mode)
 +void ED_view3d_autodist_init(
 +        struct Depsgraph *graph,
 +        Scene *scene, 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(graph, scene, ar, v3d, true);
                        break;
                case 1:
                        ED_view3d_draw_depth_gpencil(scene, ar, v3d);
  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)