code cleanup: move runtime var zfac out of RegionView3D. rename initgrabz() -> ED_vie...
authorCampbell Barton <ideasman42@gmail.com>
Sat, 9 Mar 2013 11:40:42 +0000 (11:40 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sat, 9 Mar 2013 11:40:42 +0000 (11:40 +0000)
16 files changed:
source/blender/blenlib/intern/math_matrix.c
source/blender/editors/armature/editarmature_sketch.c
source/blender/editors/gpencil/gpencil_paint.c
source/blender/editors/include/ED_view3d.h
source/blender/editors/physics/particle_edit.c
source/blender/editors/sculpt_paint/paint_utils.c
source/blender/editors/sculpt_paint/sculpt.c
source/blender/editors/space_view3d/view3d_draw.c
source/blender/editors/space_view3d/view3d_edit.c
source/blender/editors/space_view3d/view3d_project.c
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_constraints.c
source/blender/editors/transform/transform_generics.c
source/blender/makesdna/DNA_view3d_types.h

index 9d9e3e6..e8d0a43 100644 (file)
@@ -367,7 +367,9 @@ void mul_mat3_m4_v3(float mat[4][4], float vec[3])
 
 void mul_project_m4_v3(float mat[4][4], float vec[3])
 {
-       const float w = vec[0] * mat[0][3] + vec[1] * mat[1][3] + vec[2] * mat[2][3] + mat[3][3];
+       const float w = (mat[0][3] * vec[0]) +
+                       (mat[1][3] * vec[1]) +
+                       (mat[2][3] * vec[2]) + mat[3][3];
        mul_m4_v3(mat, vec);
 
        vec[0] /= w;
index 334d9f6..cd20b7f 100644 (file)
@@ -922,17 +922,18 @@ static void sk_projectDrawPoint(bContext *C, float vec[3], SK_Stroke *stk, SK_Dr
        float fp[3] = {0, 0, 0};
        float dvec[3];
        float mval_f[2];
+       float zfac;
 
        if (last != NULL) {
                copy_v3_v3(fp, last->p);
        }
 
-       initgrabz(ar->regiondata, fp[0], fp[1], fp[2]);
+       zfac = ED_view3d_calc_zfac(ar->regiondata, fp, NULL);
 
        /* method taken from editview.c - mouse_cursor() */
        if (ED_view3d_project_short_global(ar, fp, cval, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
                VECSUB2D(mval_f, cval, dd->mval);
-               ED_view3d_win_to_delta(ar, mval_f, dvec);
+               ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
                sub_v3_v3v3(vec, fp, dvec);
        }
        else {
index 4681545..3d8ab17 100644 (file)
@@ -277,6 +277,7 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3]
                        int mval_prj[2];
                        float rvec[3], dvec[3];
                        float mval_f[2];
+                       float zfac;
                        
                        /* Current method just converts each point in screen-coordinates to
                         * 3D-coordinates using the 3D-cursor as reference. In general, this
@@ -288,12 +289,13 @@ static void gp_stroke_convertcoords(tGPsdata *p, const int mval[2], float out[3]
                         */
                        
                        gp_get_3d_reference(p, rvec);
+                       zfac = ED_view3d_calc_zfac(p->ar->regiondata, rvec, NULL);
                        
                        /* method taken from editview.c - mouse_cursor() */
                        /* TODO, use ED_view3d_project_float_global */
                        if (ED_view3d_project_int_global(p->ar, rvec, mval_prj, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
                                VECSUB2D(mval_f, mval_prj, mval);
-                               ED_view3d_win_to_delta(p->ar, mval_f, dvec);
+                               ED_view3d_win_to_delta(p->ar, mval_f, dvec, zfac);
                                sub_v3_v3v3(out, rvec, dvec);
                        }
                        else {
@@ -1237,13 +1239,6 @@ static void gp_paint_initstroke(tGPsdata *p, short paintmode)
                switch (p->sa->spacetype) {
                        case SPACE_VIEW3D:
                        {
-                               RegionView3D *rv3d = p->ar->regiondata;
-                               float rvec[3];
-                               
-                               /* get reference point for 3d space placement */
-                               gp_get_3d_reference(p, rvec);
-                               initgrabz(rv3d, rvec[0], rvec[1], rvec[2]);
-                               
                                p->gpd->sbuffer_sflag |= GP_STROKE_3DSPACE;
                        }
                        break;
index ad2a8f7..8861c7d 100644 (file)
@@ -197,11 +197,11 @@ eV3DProjStatus ED_view3d_project_float_ex(struct ARegion *ar, float perspmat[4][
 eV3DProjStatus ED_view3d_project_float_global(struct ARegion *ar, const float co[3], float r_co[2], const eV3DProjTest flag);
 eV3DProjStatus ED_view3d_project_float_object(struct ARegion *ar, const float co[3], float r_co[2], const eV3DProjTest flag);
 
-int initgrabz(struct RegionView3D *rv3d, float x, float y, float z);
+float ED_view3d_calc_zfac(struct RegionView3D *rv3d, const float co[3], bool *r_flip);
 void ED_view3d_win_to_ray(struct ARegion *ar, struct View3D *v3d, const float mval[2], float ray_start[3], float ray_normal[3]);
 void ED_view3d_global_to_vector(struct RegionView3D *rv3d, const float coord[3], float vec[3]);
 void ED_view3d_win_to_3d(struct ARegion *ar, const float depth_pt[3], const float mval[2], float out[3]);
-void ED_view3d_win_to_delta(struct ARegion *ar, const float mval[2], float out[3]);
+void ED_view3d_win_to_delta(struct ARegion *ar, const float mval[2], float out[3], const float zfac);
 void ED_view3d_win_to_vector(struct ARegion *ar, const float mval[2], float out[3]);
 void ED_view3d_win_to_segment(struct ARegion *ar, struct View3D *v3d, const float mval[2], float ray_start[3], float ray_end[3]);
 int  ED_view3d_win_to_segment_clip(struct ARegion *ar, struct View3D *v3d, const float mval[2], float ray_start[3], float ray_end[3]);
index 31079de..111f3a0 100644 (file)
@@ -3476,6 +3476,7 @@ typedef struct BrushEdit {
 
        int first;
        int lastmouse[2];
+       float zfac;
 
        /* optional cached view settings to avoid setting on every mousemove */
        PEData data;
@@ -3498,7 +3499,6 @@ static int brush_edit_init(bContext *C, wmOperator *op)
        INIT_MINMAX(min, max);
        PE_minmax(scene, min, max);
        mid_v3_v3v3(min, min, max);
-       initgrabz(ar->regiondata, min[0], min[1], min[2]);
 
        bedit= MEM_callocN(sizeof(BrushEdit), "BrushEdit");
        bedit->first= 1;
@@ -3508,6 +3508,8 @@ static int brush_edit_init(bContext *C, wmOperator *op)
        bedit->ob= ob;
        bedit->edit= edit;
 
+       bedit->zfac = ED_view3d_calc_zfac(ar->regiondata, min, NULL);
+
        /* cache view depths and settings for re-use */
        PE_set_view3d_data(C, &bedit->data);
 
@@ -3587,7 +3589,7 @@ static void brush_edit_apply(bContext *C, wmOperator *op, PointerRNA *itemptr)
 
                                        invert_m4_m4(ob->imat, ob->obmat);
 
-                                       ED_view3d_win_to_delta(ar, mval_f, vec);
+                                       ED_view3d_win_to_delta(ar, mval_f, vec, bedit->zfac);
                                        data.dvec= vec;
 
                                        foreach_mouse_hit_key(&data, brush_comb, selected);
index dc3f310..6fb2361 100644 (file)
@@ -160,12 +160,12 @@ float paint_calc_object_space_radius(ViewContext *vc, const float center[3],
        Object *ob = vc->obact;
        float delta[3], scale, loc[3];
        const float mval_f[2] = {pixel_radius, 0.0f};
+       float zfac;
 
        mul_v3_m4v3(loc, ob->obmat, center);
 
-       initgrabz(vc->rv3d, loc[0], loc[1], loc[2]);
-
-       ED_view3d_win_to_delta(vc->ar, mval_f, delta);
+       zfac = ED_view3d_calc_zfac(vc->rv3d, loc, NULL);
+       ED_view3d_win_to_delta(vc->ar, mval_f, delta, zfac);
 
        scale = fabsf(mat4_to_scale(ob->obmat));
        scale = (scale == 0.0f) ? 1.0f : scale;
index ea5b012..ad82801 100644 (file)
@@ -1235,11 +1235,12 @@ static void calc_local_y(ViewContext *vc, const float center[3], float y[3])
 {
        Object *ob = vc->obact;
        float loc[3], mval_f[2] = {0.0f, 1.0f};
+       float zfac;
 
        mul_v3_m4v3(loc, ob->imat, center);
-       initgrabz(vc->rv3d, loc[0], loc[1], loc[2]);
+       zfac = ED_view3d_calc_zfac(vc->rv3d, loc, NULL);
 
-       ED_view3d_win_to_delta(vc->ar, mval_f, y);
+       ED_view3d_win_to_delta(vc->ar, mval_f, y, zfac);
        normalize_v3(y);
 
        add_v3_v3(y, ob->loc);
@@ -3850,8 +3851,6 @@ static void sculpt_update_brush_delta(UnifiedPaintSettings *ups, Object *ob, Bru
 
                /* compute 3d coordinate at same z from original location + mouse */
                mul_v3_m4v3(loc, ob->obmat, cache->orig_grab_location);
-               initgrabz(cache->vc->rv3d, loc[0], loc[1], loc[2]);
-
                ED_view3d_win_to_3d(cache->vc->ar, loc, mouse, grab_location);
 
                /* compute delta to move verts by */
index 1df2504..d77dafa 100644 (file)
@@ -1705,10 +1705,12 @@ static void view3d_draw_bgpic(Scene *scene, ARegion *ar, View3D *v3d,
                                float tvec[3];
                                float sco[2];
                                const float mval_f[2] = {1.0f, 0.0f};
+                               const float co_zero[3] = {0};
+                               float zfac;
 
                                /* calc window coord */
-                               initgrabz(rv3d, 0.0, 0.0, 0.0);
-                               ED_view3d_win_to_delta(ar, mval_f, tvec);
+                               zfac = ED_view3d_calc_zfac(rv3d, co_zero, NULL);
+                               ED_view3d_win_to_delta(ar, mval_f, tvec, zfac);
                                fac = max_ff(fabsf(tvec[0]), max_ff(fabsf(tvec[1]), fabsf(tvec[2]))); /* largest abs axis */
                                fac = 1.0f / fac;
 
index 5f54f0d..1cb9ce7 100644 (file)
@@ -368,6 +368,7 @@ typedef struct ViewOpsData {
        float reverse, dist0, camzoom0;
        float grid, far;
        short axis_snap; /* view rotate only */
+       float zfac;
 
        /* use for orbit selection and auto-dist */
        float ofs[3], dyn_ofs[3];
@@ -504,7 +505,11 @@ static void viewops_data_create(bContext *C, wmOperator *op, wmEvent *event)
 
        calctrackballvec(&vod->ar->winrct, event->x, event->y, vod->trackvec);
 
-       initgrabz(rv3d, -rv3d->ofs[0], -rv3d->ofs[1], -rv3d->ofs[2]);
+       {
+               float tvec[3];
+               negate_v3_v3(tvec, rv3d->ofs);
+               vod->zfac = ED_view3d_calc_zfac(rv3d, tvec, NULL);
+       }
 
        vod->reverse = 1.0f;
        if (rv3d->persmat[2][1] < 0.0f)
@@ -1508,7 +1513,7 @@ static void viewmove_apply(ViewOpsData *vod, int x, int y)
 
                mval_f[0] = x - vod->oldx;
                mval_f[1] = y - vod->oldy;
-               ED_view3d_win_to_delta(vod->ar, mval_f, dvec);
+               ED_view3d_win_to_delta(vod->ar, mval_f, dvec, vod->zfac);
 
                add_v3_v3(vod->rv3d->ofs, dvec);
 
@@ -1665,15 +1670,16 @@ static void view_zoom_mouseloc(ARegion *ar, float dfac, int mx, int my)
                float tpos[3];
                float mval_f[2];
                float new_dist;
+               float zfac;
 
                negate_v3_v3(tpos, rv3d->ofs);
 
-               /* Project cursor position into 3D space */
-               initgrabz(rv3d, tpos[0], tpos[1], tpos[2]);
-
                mval_f[0] = (float)(((mx - ar->winrct.xmin) * 2) - ar->winx) / 2.0f;
                mval_f[1] = (float)(((my - ar->winrct.ymin) * 2) - ar->winy) / 2.0f;
-               ED_view3d_win_to_delta(ar, mval_f, dvec);
+
+               /* Project cursor position into 3D space */
+               zfac = ED_view3d_calc_zfac(rv3d, tpos, NULL);
+               ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
 
                /* Calculate view target position for dolly */
                add_v3_v3v3(tvec, tpos, dvec);
@@ -2957,14 +2963,20 @@ static int view3d_zoom_border_exec(bContext *C, wmOperator *op)
                }
                else {
                        float mval_f[2];
+                       float zfac;
+
                        /* We cant use the depth, fallback to the old way that dosnt set the center depth */
                        copy_v3_v3(new_ofs, rv3d->ofs);
 
-                       initgrabz(rv3d, -new_ofs[0], -new_ofs[1], -new_ofs[2]);
+                       {
+                               float tvec[3];
+                               negate_v3_v3(tvec, new_ofs);
+                               zfac = ED_view3d_calc_zfac(rv3d, tvec, NULL);
+                       }
 
                        mval_f[0] = (rect.xmin + rect.xmax - vb[0]) / 2.0f;
                        mval_f[1] = (rect.ymin + rect.ymax - vb[1]) / 2.0f;
-                       ED_view3d_win_to_delta(ar, mval_f, dvec);
+                       ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
                        /* center the view to the center of the rectangle */
                        sub_v3_v3(new_ofs, dvec);
                }
@@ -3415,16 +3427,19 @@ static int viewpan_exec(bContext *C, wmOperator *op)
        ARegion *ar = CTX_wm_region(C);
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
        float vec[3];
+       const float co_zero[3] = {0.0f};
        float mval_f[2] = {0.0f, 0.0f};
+       float zfac;
        int pandir;
 
        pandir = RNA_enum_get(op->ptr, "type");
 
-       initgrabz(rv3d, 0.0, 0.0, 0.0);
-       if      (pandir == V3D_VIEW_PANRIGHT)  { mval_f[0] = -32.0f; ED_view3d_win_to_delta(ar, mval_f, vec); }
-       else if (pandir == V3D_VIEW_PANLEFT)   { mval_f[0] =  32.0f; ED_view3d_win_to_delta(ar, mval_f, vec); }
-       else if (pandir == V3D_VIEW_PANUP)     { mval_f[1] = -25.0f; ED_view3d_win_to_delta(ar, mval_f, vec); }
-       else if (pandir == V3D_VIEW_PANDOWN)   { mval_f[1] =  25.0f; ED_view3d_win_to_delta(ar, mval_f, vec); }
+       zfac = ED_view3d_calc_zfac(rv3d, co_zero, NULL);
+       if      (pandir == V3D_VIEW_PANRIGHT)  { mval_f[0] = -32.0f; }
+       else if (pandir == V3D_VIEW_PANLEFT)   { mval_f[0] =  32.0f; }
+       else if (pandir == V3D_VIEW_PANUP)     { mval_f[1] = -25.0f; }
+       else if (pandir == V3D_VIEW_PANDOWN)   { mval_f[1] =  25.0f; }
+       ED_view3d_win_to_delta(ar, mval_f, vec, zfac);
        add_v3_v3(rv3d->ofs, vec);
 
        if (rv3d->viewlock & RV3D_BOXVIEW)
@@ -3713,15 +3728,16 @@ void ED_view3d_cursor3d_position(bContext *C, float fp[3], const int mval[2])
        View3D *v3d = CTX_wm_view3d(C);
        RegionView3D *rv3d = CTX_wm_region_view3d(C);
        float mval_fl[2];
-       int flip;
+       float zfac;
+       bool flip;
        
-       flip = initgrabz(rv3d, fp[0], fp[1], fp[2]);
+       zfac = ED_view3d_calc_zfac(rv3d, fp, &flip);
        
        /* reset the depth based on the view offset (we _know_ the offset is infront of us) */
        if (flip) {
                negate_v3_v3(fp, rv3d->ofs);
                /* re initialize, no need to check flip again */
-               /* flip = */ initgrabz(rv3d, fp[0], fp[1], fp[2]);
+               zfac = ED_view3d_calc_zfac(rv3d, fp, NULL /* &flip */ );
        }
 
        if (ED_view3d_project_float_global(ar, fp, mval_fl, V3D_PROJ_TEST_NOP) == V3D_PROJ_RET_OK) {
@@ -3736,17 +3752,17 @@ void ED_view3d_cursor3d_position(bContext *C, float fp[3], const int mval[2])
                if (depth_used == FALSE) {
                        float dvec[3];
                        VECSUB2D(mval_fl, mval_fl, mval);
-                       ED_view3d_win_to_delta(ar, mval_fl, dvec);
+                       ED_view3d_win_to_delta(ar, mval_fl, dvec, zfac);
                        sub_v3_v3(fp, dvec);
                }
        }
        else {
-               const float dx = ((float)(mval[0] - (ar->winx / 2))) * rv3d->zfac / (ar->winx / 2);
-               const float dy = ((float)(mval[1] - (ar->winy / 2))) * rv3d->zfac / (ar->winy / 2);
+               const float dx = ((float)(mval[0] - (ar->winx / 2))) * zfac / (ar->winx / 2);
+               const float dy = ((float)(mval[1] - (ar->winy / 2))) * zfac / (ar->winy / 2);
                const float fz = (rv3d->persmat[0][3] * fp[0] +
                                  rv3d->persmat[1][3] * fp[1] +
                                  rv3d->persmat[2][3] * fp[2] +
-                                 rv3d->persmat[3][3]) / rv3d->zfac;
+                                 rv3d->persmat[3][3]) / zfac;
 
                fp[0] = (rv3d->persinv[0][0] * dx + rv3d->persinv[1][0] * dy + rv3d->persinv[2][0] * fz) - rv3d->ofs[0];
                fp[1] = (rv3d->persinv[0][1] * dx + rv3d->persinv[1][1] * dy + rv3d->persinv[2][1] * fz) - rv3d->ofs[1];
index bc1656f..27d0010 100644 (file)
@@ -271,28 +271,32 @@ eV3DProjStatus ED_view3d_project_float_object(ARegion *ar, const float co[3], fl
 /* More Generic Window/Ray/Vector projection functions
  * *************************************************** */
 
-/* odd function, need to document better */
-int initgrabz(RegionView3D *rv3d, float x, float y, float z)
+/**
+ * Caculate a depth value from \a co, use with #ED_view3d_win_to_delta
+ */
+float ED_view3d_calc_zfac(RegionView3D *rv3d, const float co[3], bool *r_flip)
 {
-       int flip = FALSE;
-       if (rv3d == NULL) return flip;
-       rv3d->zfac = rv3d->persmat[0][3] * x + rv3d->persmat[1][3] * y + rv3d->persmat[2][3] * z + rv3d->persmat[3][3];
-       if (rv3d->zfac < 0.0f)
-               flip = TRUE;
+       float zfac = (rv3d->persmat[0][3] * co[0]) +
+                    (rv3d->persmat[1][3] * co[1]) +
+                    (rv3d->persmat[2][3] * co[2]) + rv3d->persmat[3][3];
+
+       if (r_flip) {
+               *r_flip = (zfac < 0.0f);
+       }
+
        /* if x,y,z is exactly the viewport offset, zfac is 0 and we don't want that
-        * (accounting for near zero values)
-        */
-       if (rv3d->zfac < 1.e-6f && rv3d->zfac > -1.e-6f) rv3d->zfac = 1.0f;
+        * (accounting for near zero values) */
+       if (zfac < 1.e-6f && zfac > -1.e-6f) {
+               zfac = 1.0f;
+       }
 
        /* Negative zfac means x, y, z was behind the camera (in perspective).
-        * This gives flipped directions, so revert back to ok default case.
-        */
-       /* NOTE: I've changed this to flip zfac to be positive again for now so that GPencil draws ok
-        * Aligorith, 2009Aug31 */
-       //if (rv3d->zfac < 0.0f) rv3d->zfac = 1.0f;
-       if (rv3d->zfac < 0.0f) rv3d->zfac = -rv3d->zfac;
-
-       return flip;
+        * This gives flipped directions, so revert back to ok default case. */
+       if (zfac < 0.0f) {
+               zfac = -zfac;
+       }
+
+       return zfac;
 }
 
 /**
@@ -384,19 +388,19 @@ void ED_view3d_win_to_3d(ARegion *ar, const float depth_pt[3], const float mval[
 
 /**
  * Calculate a 3d difference vector from 2d window offset.
- * note that initgrabz() must be called first to determine
+ * note that ED_view3d_calc_zfac() must be called first to determine
  * the depth used to calculate the delta.
  * \param ar The region (used for the window width and height).
  * \param mval The area relative 2d difference (such as event->mval[0] - other_x).
  * \param out The resulting world-space delta.
  */
-void ED_view3d_win_to_delta(ARegion *ar, const float mval[2], float out[3])
+void ED_view3d_win_to_delta(ARegion *ar, const float mval[2], float out[3], const float zfac)
 {
        RegionView3D *rv3d = ar->regiondata;
        float dx, dy;
        
-       dx = 2.0f * mval[0] * rv3d->zfac / ar->winx;
-       dy = 2.0f * mval[1] * rv3d->zfac / ar->winy;
+       dx = 2.0f * mval[0] * zfac / ar->winx;
+       dy = 2.0f * mval[1] * zfac / ar->winy;
        
        out[0] = (rv3d->persinv[0][0] * dx + rv3d->persinv[1][0] * dy);
        out[1] = (rv3d->persinv[0][1] * dx + rv3d->persinv[1][1] * dy);
@@ -408,7 +412,7 @@ void ED_view3d_win_to_delta(ARegion *ar, const float mval[2], float out[3])
  * This direction vector starts and the view in the direction of the 2d window coordinates.
  * In orthographic view all window coordinates yield the same vector.
  *
- * \note doesn't rely on initgrabz
+ * \note doesn't rely on ED_view3d_calc_zfac
  * for perspective view, get the vector direction to
  * the mouse cursor as a normalized vector.
  *
index 065354a..01f3271 100644 (file)
@@ -120,12 +120,11 @@ bool view3d_get_view_aligned_coordinate(ARegion *ar, float fp[3], const int mval
 
        ret = ED_view3d_project_int_global(ar, fp, mval_cpy, V3D_PROJ_TEST_NOP);
 
-       initgrabz(rv3d, fp[0], fp[1], fp[2]);
-
        if (ret == V3D_PROJ_RET_OK) {
                const float mval_f[2] = {(float)(mval_cpy[0] - mval[0]),
                                         (float)(mval_cpy[1] - mval[1])};
-               ED_view3d_win_to_delta(ar, mval_f, dvec);
+               const float zfac = ED_view3d_calc_zfac(rv3d, fp, NULL);
+               ED_view3d_win_to_delta(ar, mval_f, dvec, zfac);
                sub_v3_v3(fp, dvec);
 
                return TRUE;
index 4aa5439..924bd74 100644 (file)
@@ -183,7 +183,7 @@ void convertViewVec(TransInfo *t, float r_vec[3], int dx, int dy)
 {
        if ((t->spacetype == SPACE_VIEW3D) && (t->ar->regiontype == RGN_TYPE_WINDOW)) {
                const float mval_f[2] = {(float)dx, (float)dy};
-               ED_view3d_win_to_delta(t->ar, mval_f, r_vec);
+               ED_view3d_win_to_delta(t->ar, mval_f, r_vec, t->zfac);
        }
        else if (t->spacetype == SPACE_IMAGE) {
                float aspx, aspy;
index dbf56f6..f8c2498 100644 (file)
@@ -354,6 +354,7 @@ typedef struct TransInfo {
        struct wmTimer *animtimer;
        struct wmKeyMap *keymap;  /* so we can do lookups for header text */
        int         mval[2];        /* current mouse position               */
+       float       zfac;           /* use for 3d view */
        struct Object   *obedit;
        void            *draw_handle_apply;
        void            *draw_handle_view;
index 256ae90..35287c1 100644 (file)
@@ -890,9 +890,11 @@ static void setNearestAxis3d(TransInfo *t)
         * and to overflow the short integers.
         * The formula used is a bit stupid, just a simplification of the subtraction
         * of two 2D points 30 pixels apart (that's the last factor in the formula) after
-        * projecting them with window_to_3d_delta and then get the length of that vector.
+        * projecting them with ED_view3d_win_to_delta and then get the length of that vector.
         */
-       zfac = t->persmat[0][3] * t->center[0] + t->persmat[1][3] * t->center[1] + t->persmat[2][3] * t->center[2] + t->persmat[3][3];
+       zfac = (t->persmat[0][3] * t->center[0]) +
+              (t->persmat[1][3] * t->center[1]) +
+              (t->persmat[2][3] * t->center[2]) + t->persmat[3][3];
        zfac = len_v3(t->persinv[0]) * 2.0f / t->ar->winx * zfac * 30.0f;
 
        for (i = 0; i < 3; i++) {
index c2a331f..ca49147 100644 (file)
@@ -1669,7 +1669,7 @@ void calculateCenter(TransInfo *t)
                                
                                projectIntView(t, axis, t->center2d);
                                
-                               /* rotate only needs correct 2d center, grab needs initgrabz() value */
+                               /* rotate only needs correct 2d center, grab needs ED_view3d_calc_zfac() value */
                                if (t->mode == TFM_TRANSLATION) {
                                        copy_v3_v3(t->center, axis);
                                        copy_v3_v3(t->con.center, t->center);
@@ -1679,18 +1679,16 @@ void calculateCenter(TransInfo *t)
        }
        
        if (t->spacetype == SPACE_VIEW3D) {
-               /* initgrabz() defines a factor for perspective depth correction, used in window_to_3d_delta() */
+               /* ED_view3d_calc_zfac() defines a factor for perspective depth correction, used in ED_view3d_win_to_delta() */
+               float vec[3];
                if (t->flag & (T_EDIT | T_POSE)) {
                        Object *ob = t->obedit ? t->obedit : t->poseobj;
-                       float vec[3];
-                       
-                       copy_v3_v3(vec, t->center);
-                       mul_m4_v3(ob->obmat, vec);
-                       initgrabz(t->ar->regiondata, vec[0], vec[1], vec[2]);
+                       mul_v3_m4v3(vec, ob->obmat, t->center);
                }
                else {
-                       initgrabz(t->ar->regiondata, t->center[0], t->center[1], t->center[2]);
+                       copy_v3_v3(vec, t->center);
                }
+               t->zfac = ED_view3d_calc_zfac(t->ar->regiondata, vec, NULL);
        }
 }
 
index d9d6db5..5397b06 100644 (file)
@@ -118,7 +118,6 @@ typedef struct RegionView3D {
 
        float viewquat[4];                      /* view rotation, must be kept normalized */
        float dist;                                     /* distance from 'ofs' along -viewinv[2] vector, where result is negative as is 'ofs' */
-       float zfac;                                     /* initgrabz() result */
        float camdx, camdy;                     /* camera view offsets, 1.0 = viewplane moves entire width/height */
        float pixsize;                          /* runtime only */
        float ofs[3];                           /* view center & orbit pivot, negative of worldspace location,
@@ -129,10 +128,11 @@ typedef struct RegionView3D {
        char persp;
        char view;
        char viewlock;
+       char pad[4];
 
        short twdrawflag;
        short rflag;
-       
+
 
        /* last view (use when switching out of camera view) */
        float lviewquat[4];