[#19930] Nurb CV select is failing because of view clipping
[blender.git] / source / blender / editors / space_view3d / view3d_view.c
index b108d38a3f92e27935449c3690ac2074385cee91..82b5730daa28191566a17021d8d74c4ae70ec728 100644 (file)
@@ -45,7 +45,7 @@
 
 #include "MEM_guardedalloc.h"
 
-#include "BLI_arithb.h"
+#include "BLI_math.h"
 #include "BLI_blenlib.h"
 #include "BLI_editVert.h"
 #include "BLI_rand.h"
@@ -161,26 +161,26 @@ static void view_settings_from_ob(Object *ob, float *ofs, float *quat, float *di
        /* Offset */
        if (ofs) {
                VECCOPY(ofs, ob->obmat[3]);
-               VecMulf(ofs, -1.0f); /*flip the vector*/
+               mul_v3_fl(ofs, -1.0f); /*flip the vector*/
        }
        
        /* Quat */
        if (quat) {
-               Mat4CpyMat4(bmat, ob->obmat);
-               Mat4Ortho(bmat);
-               Mat4Invert(imat, bmat);
-               Mat3CpyMat4(tmat, imat);
-               Mat3ToQuat(tmat, quat);
+               copy_m4_m4(bmat, ob->obmat);
+               normalize_m4(bmat);
+               invert_m4_m4(imat, bmat);
+               copy_m3_m4(tmat, imat);
+               mat3_to_quat( quat,tmat);
        }
        
        if (dist) {
                float vec[3];
-               Mat3CpyMat4(tmat, ob->obmat);
+               copy_m3_m4(tmat, ob->obmat);
                
                vec[0]= vec[1] = 0.0;
                vec[2]= -(*dist);
-               Mat3MulVecfl(tmat, vec);
-               VecSubf(ofs, ofs, vec);
+               mul_m3_v3(tmat, vec);
+               sub_v3_v3v3(ofs, ofs, vec);
        }
        
        /* Lens */
@@ -263,10 +263,10 @@ void smooth_view(bContext *C, Object *oldcamera, Object *camera, float *ofs, flo
                                
                                VECCOPY(vec1, sms.new_quat);
                                VECCOPY(vec2, sms.orig_quat);
-                               Normalize(vec1);
-                               Normalize(vec2);
+                               normalize_v3(vec1);
+                               normalize_v3(vec2);
                                /* scale the time allowed by the rotation */
-                               sms.time_allowed *= NormalizedVecAngle2(vec1, vec2)/(M_PI/2); 
+                               sms.time_allowed *= angle_normalized_v3v3(vec1, vec2)/(M_PI/2); 
                        }
                        
                        /* original values */
@@ -285,7 +285,7 @@ void smooth_view(bContext *C, Object *oldcamera, Object *camera, float *ofs, flo
                        rv3d->view= 0;
                        
                        /* ensure it shows correct */
-                       if(sms.to_camera) rv3d->persp= V3D_PERSP;
+                       if(sms.to_camera) rv3d->persp= RV3D_PERSP;
                        
                        /* keep track of running timer! */
                        if(rv3d->sms==NULL)
@@ -329,7 +329,7 @@ static int view3d_smoothview_invoke(bContext *C, wmOperator *op, wmEvent *event)
                
                /* if we went to camera, store the original */
                if(sms->to_camera) {
-                       rv3d->persp= V3D_CAMOB;
+                       rv3d->persp= RV3D_CAMOB;
                        VECCOPY(rv3d->ofs, sms->orig_ofs);
                        QUATCOPY(rv3d->viewquat, sms->orig_quat);
                        rv3d->dist = sms->orig_dist;
@@ -361,7 +361,7 @@ static int view3d_smoothview_invoke(bContext *C, wmOperator *op, wmEvent *event)
                for (i=0; i<3; i++)
                        rv3d->ofs[i] = sms->new_ofs[i]*step + sms->orig_ofs[i]*step_inv;
 
-               QuatInterpol(rv3d->viewquat, sms->orig_quat, sms->new_quat, step);
+               interp_qt_qtqt(rv3d->viewquat, sms->orig_quat, sms->new_quat, step);
                
                rv3d->dist = sms->new_dist*step + sms->orig_dist*step_inv;
                v3d->lens = sms->new_lens*step + sms->orig_lens*step_inv;
@@ -395,10 +395,10 @@ static void setcameratoview3d(View3D *v3d, RegionView3D *rv3d, Object *ob)
        dvec[2]= rv3d->dist*rv3d->viewinv[2][2];
        
        VECCOPY(ob->loc, dvec);
-       VecSubf(ob->loc, ob->loc, rv3d->ofs);
+       sub_v3_v3v3(ob->loc, ob->loc, rv3d->ofs);
        rv3d->viewquat[0]= -rv3d->viewquat[0];
 
-       QuatToEul(rv3d->viewquat, ob->rot);
+       quat_to_eul( ob->rot,rv3d->viewquat);
        rv3d->viewquat[0]= -rv3d->viewquat[0];
        
        ob->recalc= OB_RECALC_OB;
@@ -411,7 +411,7 @@ static int view3d_setcameratoview_exec(bContext *C, wmOperator *op)
        RegionView3D *rv3d= CTX_wm_region_view3d(C);
 
        setcameratoview3d(v3d, rv3d, v3d->camera);
-       rv3d->persp = V3D_CAMOB;
+       rv3d->persp = RV3D_CAMOB;
        
        WM_event_add_notifier(C, NC_OBJECT|ND_TRANSFORM, CTX_data_scene(C));
        
@@ -452,7 +452,7 @@ static int view3d_setobjectascamera_exec(bContext *C, wmOperator *op)
        Scene *scene= CTX_data_scene(C);
        
        if(BASACT) {
-               rv3d->persp= V3D_CAMOB;
+               rv3d->persp= RV3D_CAMOB;
                v3d->camera= OBACT;
                if(v3d->scenelock)
                        scene->camera= OBACT;
@@ -487,18 +487,18 @@ void viewline(ARegion *ar, View3D *v3d, float mval[2], float ray_start[3], float
        RegionView3D *rv3d= ar->regiondata;
        float vec[4];
        
-       if(rv3d->persp != V3D_ORTHO){
+       if(rv3d->persp != RV3D_ORTHO){
                vec[0]= 2.0f * mval[0] / ar->winx - 1;
                vec[1]= 2.0f * mval[1] / ar->winy - 1;
                vec[2]= -1.0f;
                vec[3]= 1.0f;
                
-               Mat4MulVec4fl(rv3d->persinv, vec);
-               VecMulf(vec, 1.0f / vec[3]);
+               mul_m4_v4(rv3d->persinv, vec);
+               mul_v3_fl(vec, 1.0f / vec[3]);
                
                VECCOPY(ray_start, rv3d->viewinv[3]);
                VECSUB(vec, vec, ray_start);
-               Normalize(vec);
+               normalize_v3(vec);
                
                VECADDFAC(ray_start, rv3d->viewinv[3], vec, v3d->near);
                VECADDFAC(ray_end, rv3d->viewinv[3], vec, v3d->far);
@@ -509,7 +509,7 @@ void viewline(ARegion *ar, View3D *v3d, float mval[2], float ray_start[3], float
                vec[2] = 0.0f;
                vec[3] = 1.0f;
                
-               Mat4MulVec4fl(rv3d->persinv, vec);
+               mul_m4_v4(rv3d->persinv, vec);
                
                VECADDFAC(ray_start, vec, rv3d->viewinv[2],  1000.0f);
                VECADDFAC(ray_end, vec, rv3d->viewinv[2], -1000.0f);
@@ -522,8 +522,8 @@ void viewray(ARegion *ar, View3D *v3d, float mval[2], float ray_start[3], float
        float ray_end[3];
        
        viewline(ar, v3d, mval, ray_start, ray_end);
-       VecSubf(ray_normal, ray_end, ray_start);
-       Normalize(ray_normal);
+       sub_v3_v3v3(ray_normal, ray_end, ray_start);
+       normalize_v3(ray_normal);
 }
 
 
@@ -601,8 +601,8 @@ void view3d_get_object_project_mat(RegionView3D *rv3d, Object *ob, float pmat[4]
 {
        float vmat[4][4];
        
-       Mat4MulMat4(vmat, ob->obmat, rv3d->viewmat);
-       Mat4MulMat4(pmat, vmat, rv3d->winmat);
+       mul_m4_m4m4(vmat, ob->obmat, rv3d->viewmat);
+       mul_m4_m4m4(pmat, vmat, rv3d->winmat);
 }
 
 /* Uses window coordinates (x,y) and depth component z to find a point in
@@ -627,7 +627,7 @@ void view3d_project_float(ARegion *ar, float *vec, float *adr, float mat[4][4])
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(mat, vec4);
+       mul_m4_v4(mat, vec4);
        
        if( vec4[3]>FLT_EPSILON ) {
                adr[0] = (float)(ar->winx/2.0f)+(ar->winx/2.0f)*vec4[0]/vec4[3];        
@@ -648,12 +648,12 @@ int boundbox_clip(RegionView3D *rv3d, float obmat[][4], BoundBox *bb)
        if(bb==NULL) return 1;
        if(bb->flag & OB_BB_DISABLED) return 1;
        
-       Mat4MulMat4(mat, obmat, rv3d->persmat);
+       mul_m4_m4m4(mat, obmat, rv3d->persmat);
        
        for(a=0; a<8; a++) {
                VECCOPY(vec, bb->vec[a]);
                vec[3]= 1.0;
-               Mat4MulVec4fl(mat, vec);
+               mul_m4_v4(mat, vec);
                max= vec[3];
                min= -vec[3];
                
@@ -680,13 +680,13 @@ void project_short(ARegion *ar, float *vec, short *adr)   /* clips */
        adr[0]= IS_CLIPPED;
        
        if(rv3d->rflag & RV3D_CLIPPING) {
-               if(view3d_test_clipping(rv3d, vec))
+               if(view3d_test_clipping(rv3d, vec, 0))
                        return;
        }
        
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( vec4[3]>BL_NEAR_CLIP ) {    /* 0.001 is the NEAR clipping cutoff for picking */
                fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]);
@@ -712,7 +712,7 @@ void project_int(ARegion *ar, float *vec, int *adr)
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( vec4[3]>BL_NEAR_CLIP ) {    /* 0.001 is the NEAR clipping cutoff for picking */
                fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]);
@@ -736,7 +736,7 @@ void project_int_noclip(ARegion *ar, float *vec, int *adr)
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( fabs(vec4[3]) > BL_NEAR_CLIP ) {
                fx = (ar->winx/2)*(1 + vec4[0]/vec4[3]);
@@ -761,7 +761,7 @@ void project_short_noclip(ARegion *ar, float *vec, short *adr)
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( vec4[3]>BL_NEAR_CLIP ) {    /* 0.001 is the NEAR clipping cutoff for picking */
                fx= (ar->winx/2)*(1 + vec4[0]/vec4[3]);
@@ -787,7 +787,7 @@ void project_float(ARegion *ar, float *vec, float *adr)
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( vec4[3]>BL_NEAR_CLIP ) {
                adr[0] = (float)(ar->winx/2.0)+(ar->winx/2.0)*vec4[0]/vec4[3];  
@@ -803,7 +803,7 @@ void project_float_noclip(ARegion *ar, float *vec, float *adr)
        VECCOPY(vec4, vec);
        vec4[3]= 1.0;
        
-       Mat4MulVec4fl(rv3d->persmat, vec4);
+       mul_m4_v4(rv3d->persmat, vec4);
        
        if( fabs(vec4[3]) > BL_NEAR_CLIP ) {
                adr[0] = (float)(ar->winx/2.0)+(ar->winx/2.0)*vec4[0]/vec4[3];  
@@ -820,7 +820,7 @@ int get_view3d_ortho(View3D *v3d, RegionView3D *rv3d)
 {
   Camera *cam;
   
-  if(rv3d->persp==V3D_CAMOB) {
+  if(rv3d->persp==RV3D_CAMOB) {
       if(v3d->camera && v3d->camera->type==OB_CAMERA) {
           cam= v3d->camera->data;
 
@@ -833,7 +833,7 @@ int get_view3d_ortho(View3D *v3d, RegionView3D *rv3d)
           return 0;
   }
   
-  if(rv3d->persp==V3D_ORTHO)
+  if(rv3d->persp==RV3D_ORTHO)
       return 1;
 
   return 0;
@@ -852,7 +852,7 @@ int get_view3d_viewplane(View3D *v3d, RegionView3D *rv3d, int winxi, int winyi,
        *clipsta= v3d->near;
        *clipend= v3d->far;
        
-       if(rv3d->persp==V3D_CAMOB) {
+       if(rv3d->persp==RV3D_CAMOB) {
                if(v3d->camera) {
                        if(v3d->camera->type==OB_LAMP ) {
                                Lamp *la;
@@ -875,7 +875,7 @@ int get_view3d_viewplane(View3D *v3d, RegionView3D *rv3d, int winxi, int winyi,
                }
        }
        
-       if(rv3d->persp==V3D_ORTHO) {
+       if(rv3d->persp==RV3D_ORTHO) {
                if(winx>winy) x1= -rv3d->dist;
                else x1= -winx*rv3d->dist/winy;
                x2= -x1;
@@ -890,7 +890,7 @@ int get_view3d_viewplane(View3D *v3d, RegionView3D *rv3d, int winxi, int winyi,
        }
        else {
                /* fac for zoom, also used for camdx */
-               if(rv3d->persp==V3D_CAMOB) {
+               if(rv3d->persp==RV3D_CAMOB) {
                        fac= (1.41421+( (float)rv3d->camzoom )/50.0);
                        fac*= fac;
                }
@@ -1001,15 +1001,15 @@ static void obmat_to_viewmat(View3D *v3d, RegionView3D *rv3d, Object *ob, short
        
        rv3d->view= 0; /* dont show the grid */
        
-       Mat4CpyMat4(bmat, ob->obmat);
-       Mat4Ortho(bmat);
-       Mat4Invert(rv3d->viewmat, bmat);
+       copy_m4_m4(bmat, ob->obmat);
+       normalize_m4(bmat);
+       invert_m4_m4(rv3d->viewmat, bmat);
        
        /* view quat calculation, needed for add object */
-       Mat3CpyMat4(tmat, rv3d->viewmat);
+       copy_m3_m4(tmat, rv3d->viewmat);
        if (smooth) {
                float new_quat[4];
-               if (rv3d->persp==V3D_CAMOB && v3d->camera) {
+               if (rv3d->persp==RV3D_CAMOB && v3d->camera) {
                        /* were from a camera view */
                        
                        float orig_ofs[3];
@@ -1018,22 +1018,22 @@ static void obmat_to_viewmat(View3D *v3d, RegionView3D *rv3d, Object *ob, short
                        VECCOPY(orig_ofs, rv3d->ofs);
                        
                        /* Switch from camera view */
-                       Mat3ToQuat(tmat, new_quat);
+                       mat3_to_quat( new_quat,tmat);
                        
-                       rv3d->persp=V3D_PERSP;
+                       rv3d->persp=RV3D_PERSP;
                        rv3d->dist= 0.0;
                        
                        view_settings_from_ob(v3d->camera, rv3d->ofs, NULL, NULL, &v3d->lens);
                        smooth_view(NULL, NULL, NULL, orig_ofs, new_quat, &orig_dist, &orig_lens); // XXX
                        
-                       rv3d->persp=V3D_CAMOB; /* just to be polite, not needed */
+                       rv3d->persp=RV3D_CAMOB; /* just to be polite, not needed */
                        
                } else {
-                       Mat3ToQuat(tmat, new_quat);
+                       mat3_to_quat( new_quat,tmat);
                        smooth_view(NULL, NULL, NULL, NULL, new_quat, NULL, NULL); // XXX
                }
        } else {
-               Mat3ToQuat(tmat, rv3d->viewquat);
+               mat3_to_quat( rv3d->viewquat,tmat);
        }
 }
 
@@ -1042,27 +1042,27 @@ static void obmat_to_viewmat(View3D *v3d, RegionView3D *rv3d, Object *ob, short
 static void view3d_viewlock(RegionView3D *rv3d)
 {
        switch(rv3d->view) {
-       case V3D_VIEW_BOTTOM :
+       case RV3D_VIEW_BOTTOM :
                QUATSET(rv3d->viewquat,0.0, -1.0, 0.0, 0.0);
                break;
                
-       case V3D_VIEW_BACK:
+       case RV3D_VIEW_BACK:
                QUATSET(rv3d->viewquat,0.0, 0.0, (float)-cos(M_PI/4.0), (float)-cos(M_PI/4.0));
                break;
                
-       case V3D_VIEW_LEFT:
+       case RV3D_VIEW_LEFT:
                QUATSET(rv3d->viewquat,0.5, -0.5, 0.5, 0.5);
                break;
                
-       case V3D_VIEW_TOP:
+       case RV3D_VIEW_TOP:
                QUATSET(rv3d->viewquat,1.0, 0.0, 0.0, 0.0);
                break;
                
-       case V3D_VIEW_FRONT:
+       case RV3D_VIEW_FRONT:
                QUATSET(rv3d->viewquat,(float)cos(M_PI/4.0), (float)-sin(M_PI/4.0), 0.0, 0.0);
                break;
                
-       case V3D_VIEW_RIGHT:
+       case RV3D_VIEW_RIGHT:
                QUATSET(rv3d->viewquat, 0.5, -0.5, -0.5, -0.5);
                break;
        }
@@ -1071,13 +1071,13 @@ static void view3d_viewlock(RegionView3D *rv3d)
 /* dont set windows active in in here, is used by renderwin too */
 void setviewmatrixview3d(Scene *scene, View3D *v3d, RegionView3D *rv3d)
 {
-       if(rv3d->persp==V3D_CAMOB) {        /* obs/camera */
+       if(rv3d->persp==RV3D_CAMOB) {       /* obs/camera */
                if(v3d->camera) {
                        where_is_object(scene, v3d->camera);    
                        obmat_to_viewmat(v3d, rv3d, v3d->camera, 0);
                }
                else {
-                       QuatToMat4(rv3d->viewquat, rv3d->viewmat);
+                       quat_to_mat4( rv3d->viewmat,rv3d->viewquat);
                        rv3d->viewmat[3][2]-= rv3d->dist;
                }
        }
@@ -1086,8 +1086,8 @@ void setviewmatrixview3d(Scene *scene, View3D *v3d, RegionView3D *rv3d)
                if(rv3d->viewlock)
                        view3d_viewlock(rv3d);
                
-               QuatToMat4(rv3d->viewquat, rv3d->viewmat);
-               if(rv3d->persp==V3D_PERSP) rv3d->viewmat[3][2]-= rv3d->dist;
+               quat_to_mat4( rv3d->viewmat,rv3d->viewquat);
+               if(rv3d->persp==RV3D_PERSP) rv3d->viewmat[3][2]-= rv3d->dist;
                if(v3d->ob_centre) {
                        Object *ob= v3d->ob_centre;
                        float vec[3];
@@ -1097,12 +1097,12 @@ void setviewmatrixview3d(Scene *scene, View3D *v3d, RegionView3D *rv3d)
                                bPoseChannel *pchan= get_pose_channel(ob->pose, v3d->ob_centre_bone);
                                if(pchan) {
                                        VECCOPY(vec, pchan->pose_mat[3]);
-                                       Mat4MulVecfl(ob->obmat, vec);
+                                       mul_m4_v3(ob->obmat, vec);
                                }
                        }
-                       i_translate(-vec[0], -vec[1], -vec[2], rv3d->viewmat);
+                       translate_m4( rv3d->viewmat,-vec[0], -vec[1], -vec[2]);
                }
-               else i_translate(rv3d->ofs[0], rv3d->ofs[1], rv3d->ofs[2], rv3d->viewmat);
+               else translate_m4( rv3d->viewmat,rv3d->ofs[0], rv3d->ofs[1], rv3d->ofs[2]);
        }
 }
 
@@ -1136,7 +1136,7 @@ short view3d_opengl_select(ViewContext *vc, unsigned int *buffer, unsigned int b
        }
        
        setwinmatrixview3d(ar, v3d, &rect);
-       Mat4MulMat4(vc->rv3d->persmat, vc->rv3d->viewmat, vc->rv3d->winmat);
+       mul_m4_m4m4(vc->rv3d->persmat, vc->rv3d->viewmat, vc->rv3d->winmat);
        
        if(v3d->drawtype > OB_WIRE) {
                v3d->zbuf= TRUE;
@@ -1186,11 +1186,11 @@ short view3d_opengl_select(ViewContext *vc, unsigned int *buffer, unsigned int b
                                                
                                                for(dob= lb->first; dob; dob= dob->next) {
                                                        tbase.object= dob->ob;
-                                                       Mat4CpyMat4(dob->ob->obmat, dob->mat);
+                                                       copy_m4_m4(dob->ob->obmat, dob->mat);
                                                        
                                                        draw_object(scene, ar, v3d, &tbase, DRAW_PICKING|DRAW_CONSTCOLOR);
                                                        
-                                                       Mat4CpyMat4(dob->ob->obmat, dob->omat);
+                                                       copy_m4_m4(dob->ob->obmat, dob->omat);
                                                }
                                                free_object_duplilist(lb);
                                        }
@@ -1206,7 +1206,7 @@ short view3d_opengl_select(ViewContext *vc, unsigned int *buffer, unsigned int b
        
        G.f &= ~G_PICKSEL;
        setwinmatrixview3d(ar, v3d, NULL);
-       Mat4MulMat4(vc->rv3d->persmat, vc->rv3d->viewmat, vc->rv3d->winmat);
+       mul_m4_m4m4(vc->rv3d->persmat, vc->rv3d->viewmat, vc->rv3d->winmat);
        
        if(v3d->drawtype > OB_WIRE) {
                v3d->zbuf= 0;
@@ -1324,7 +1324,7 @@ static void initlocalview(Scene *scene, ScrArea *sa)
 
                                rv3d->dist= size;
                                /* perspective should be a bit farther away to look nice */
-                               if(rv3d->persp==V3D_ORTHO)
+                               if(rv3d->persp==RV3D_ORTHO)
                                        rv3d->dist*= 0.7;
 
                                // correction for window aspect ratio
@@ -1334,7 +1334,7 @@ static void initlocalview(Scene *scene, ScrArea *sa)
                                        rv3d->dist*= asp;
                                }
                                
-                               if (rv3d->persp==V3D_CAMOB) rv3d->persp= V3D_PERSP;
+                               if (rv3d->persp==RV3D_CAMOB) rv3d->persp= RV3D_PERSP;
                                
                                v3d->cursor[0]= -rv3d->ofs[0];
                                v3d->cursor[1]= -rv3d->ofs[1];
@@ -1447,7 +1447,7 @@ void VIEW3D_OT_localview(wmOperatorType *ot)
        
        /* identifiers */
        ot->name= "Local View";
-       ot->description= "Toggle display of selected object(s) seperately and centered in view.";
+       ot->description= "Toggle display of selected object(s) separately and centered in view.";
        ot->idname= "VIEW3D_OT_localview";
        
        /* api callbacks */
@@ -1559,41 +1559,58 @@ int game_engine_poll(bContext *C)
        return CTX_data_mode_enum(C)==CTX_MODE_OBJECT ? 1:0;
 }
 
-static int game_engine_exec(bContext *C, wmOperator *unused)
+int ED_view3d_context_activate(bContext *C)
 {
-#if GAMEBLENDER == 1
-       Scene *startscene = CTX_data_scene(C);
        bScreen *sc= CTX_wm_screen(C);
-       ScrArea *sa, *prevsa= CTX_wm_area(C);
-       ARegion *ar, *prevar= CTX_wm_region(C);
-       rcti cam_frame;
+       ScrArea *sa= CTX_wm_area(C);
+       ARegion *ar;
+       RegionView3D *rv3d;
 
-       sa= prevsa;
-       if(sa->spacetype != SPACE_VIEW3D) {
+       if(sa->spacetype != SPACE_VIEW3D)
                for(sa=sc->areabase.first; sa; sa= sa->next)
                        if(sa->spacetype==SPACE_VIEW3D)
                                break;
-       }
 
        if(!sa)
-               return OPERATOR_CANCELLED;
+               return 0;
        
        for(ar=sa->regionbase.first; ar; ar=ar->next)
                if(ar->regiontype == RGN_TYPE_WINDOW)
                        break;
        
        if(!ar)
-               return OPERATOR_CANCELLED;
+               return 0;
        
        // bad context switch ..
        CTX_wm_area_set(C, sa);
        CTX_wm_region_set(C, ar);
+       rv3d= ar->regiondata;
+
+       return 1;
+}
+
+static int game_engine_exec(bContext *C, wmOperator *unused)
+{
+#if GAMEBLENDER == 1
+       Scene *startscene = CTX_data_scene(C);
+       ScrArea *sa, *prevsa= CTX_wm_area(C);
+       ARegion *ar, *prevar= CTX_wm_region(C);
+       RegionView3D *rv3d;
+       rcti cam_frame;
+
+       // bad context switch ..
+       if(!ED_view3d_context_activate(C))
+               return OPERATOR_CANCELLED;
+       
+       rv3d= CTX_wm_region_view3d(C);
+       sa= CTX_wm_area(C);
+       ar= CTX_wm_region(C);
 
        view3d_operator_needs_opengl(C);
        
        game_set_commmandline_options(&startscene->gm);
 
-       if(startscene->gm.framing.type == SCE_GAMEFRAMING_BARS) { /* Letterbox */
+       if(rv3d->persp==RV3D_CAMOB && startscene->gm.framing.type == SCE_GAMEFRAMING_BARS && startscene->gm.stereoflag != STEREO_DOME) { /* Letterbox */
                rctf cam_framef;
                calc_viewborder(startscene, ar, CTX_wm_view3d(C), &cam_framef);
                cam_frame.xmin = cam_framef.xmin + ar->winrct.xmin;
@@ -1788,7 +1805,7 @@ int initFlyInfo (bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event)
        fly->ar = CTX_wm_region(C);
        fly->scene= CTX_data_scene(C);
 
-       if(fly->rv3d->persp==V3D_CAMOB && fly->v3d->camera->id.lib) {
+       if(fly->rv3d->persp==RV3D_CAMOB && fly->v3d->camera->id.lib) {
                BKE_report(op->reports, RPT_ERROR, "Cannot fly a camera from an external library");
                return FALSE;
        }
@@ -1798,7 +1815,7 @@ int initFlyInfo (bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event)
                return FALSE;
        }
 
-       if(fly->rv3d->persp==V3D_CAMOB && fly->v3d->camera->constraints.first) {
+       if(fly->rv3d->persp==RV3D_CAMOB && fly->v3d->camera->constraints.first) {
                BKE_report(op->reports, RPT_ERROR, "Cannot fly an object with constraints");
                return FALSE;
        }
@@ -1834,22 +1851,22 @@ int initFlyInfo (bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event)
 
        /* detect weather to start with Z locking */
        upvec[0]=1.0f; upvec[1]=0.0f; upvec[2]=0.0f;
-       Mat3CpyMat4(mat, fly->rv3d->viewinv);
-       Mat3MulVecfl(mat, upvec);
+       copy_m3_m4(mat, fly->rv3d->viewinv);
+       mul_m3_v3(mat, upvec);
        if (fabs(upvec[2]) < 0.1)
                fly->zlock = 1;
        upvec[0]=0; upvec[1]=0; upvec[2]=0;
 
        fly->persp_backup= fly->rv3d->persp;
        fly->dist_backup= fly->rv3d->dist;
-       if (fly->rv3d->persp==V3D_CAMOB) {
+       if (fly->rv3d->persp==RV3D_CAMOB) {
                /* store the origoinal camera loc and rot */
                VECCOPY(fly->ofs_backup, fly->v3d->camera->loc);
                VECCOPY(fly->rot_backup, fly->v3d->camera->rot);
 
                where_is_object(fly->scene, fly->v3d->camera);
                VECCOPY(fly->rv3d->ofs, fly->v3d->camera->obmat[3]);
-               VecMulf(fly->rv3d->ofs, -1.0f); /*flip the vector*/
+               mul_v3_fl(fly->rv3d->ofs, -1.0f); /*flip the vector*/
 
                fly->rv3d->dist=0.0;
                fly->rv3d->viewbut=0;
@@ -1860,15 +1877,15 @@ int initFlyInfo (bContext *C, FlyInfo *fly, wmOperator *op, wmEvent *event)
 
        } else {
                /* perspective or ortho */
-               if (fly->rv3d->persp==V3D_ORTHO)
-                       fly->rv3d->persp= V3D_PERSP; /*if ortho projection, make perspective */
+               if (fly->rv3d->persp==RV3D_ORTHO)
+                       fly->rv3d->persp= RV3D_PERSP; /*if ortho projection, make perspective */
                QUATCOPY(fly->rot_backup, fly->rv3d->viewquat);
                VECCOPY(fly->ofs_backup, fly->rv3d->ofs);
                fly->rv3d->dist= 0.0;
 
                upvec[2]= fly->dist_backup; /*x and y are 0*/
-               Mat3MulVecfl(mat, upvec);
-               VecSubf(fly->rv3d->ofs, fly->rv3d->ofs, upvec);
+               mul_m3_v3(mat, upvec);
+               sub_v3_v3v3(fly->rv3d->ofs, fly->rv3d->ofs, upvec);
                /*Done with correcting for the dist*/
        }
 
@@ -1891,7 +1908,7 @@ static int flyEnd(bContext *C, FlyInfo *fly)
 
        if (fly->state == FLY_CANCEL) {
        /* Revert to original view? */
-               if (fly->persp_backup==V3D_CAMOB) { /* a camera view */
+               if (fly->persp_backup==RV3D_CAMOB) { /* a camera view */
                        rv3d->viewbut=1;
                        VECCOPY(v3d->camera->loc, fly->ofs_backup);
                        VECCOPY(v3d->camera->rot, fly->rot_backup);
@@ -1903,10 +1920,10 @@ static int flyEnd(bContext *C, FlyInfo *fly)
                        rv3d->persp= fly->persp_backup;
                }
        }
-       else if (fly->persp_backup==V3D_CAMOB) {        /* camera */
+       else if (fly->persp_backup==RV3D_CAMOB) {       /* camera */
                float mat3[3][3];
-               Mat3CpyMat4(mat3, v3d->camera->obmat);
-               Mat3ToCompatibleEul(mat3, v3d->camera->rot, fly->rot_backup);
+               copy_m3_m4(mat3, v3d->camera->obmat);
+               mat3_to_compatible_eul( v3d->camera->rot, fly->rot_backup,mat3);
 
                DAG_id_flush_update(&v3d->camera->id, OB_RECALC_OB);
 #if 0 //XXX2.5
@@ -1924,9 +1941,9 @@ static int flyEnd(bContext *C, FlyInfo *fly)
                float mat[3][3];
                upvec[0]= upvec[1]= 0;
                upvec[2]= fly->dist_backup; /*x and y are 0*/
-               Mat3CpyMat4(mat, rv3d->viewinv);
-               Mat3MulVecfl(mat, upvec);
-               VecAddf(rv3d->ofs, rv3d->ofs, upvec);
+               copy_m3_m4(mat, rv3d->viewinv);
+               mul_m3_v3(mat, upvec);
+               add_v3_v3v3(rv3d->ofs, rv3d->ofs, upvec);
                /*Done with correcting for the dist */
        }
 
@@ -2159,7 +2176,7 @@ int flyApply(FlyInfo *fly)
                        if (fly->use_precision)
                                fly->speed= fly->speed * (1.0f-time_redraw_clamped);
 
-                       Mat3CpyMat4(mat, rv3d->viewinv);
+                       copy_m3_m4(mat, rv3d->viewinv);
 
                        if (fly->pan_view==TRUE) {
                                /* pan only */
@@ -2172,8 +2189,8 @@ int flyApply(FlyInfo *fly)
                                        dvec_tmp[1] *= 0.1;
                                }
 
-                               Mat3MulVecfl(mat, dvec_tmp);
-                               VecMulf(dvec_tmp, time_redraw*200.0 * fly->grid);
+                               mul_m3_v3(mat, dvec_tmp);
+                               mul_v3_fl(dvec_tmp, time_redraw*200.0 * fly->grid);
 
                        } else {
                                float roll; /* similar to the angle between the camera's up and the Z-up, but its very rough so just roll*/
@@ -2183,9 +2200,9 @@ int flyApply(FlyInfo *fly)
                                        upvec[0]=1;
                                        upvec[1]=0;
                                        upvec[2]=0;
-                                       Mat3MulVecfl(mat, upvec);
-                                       VecRotToQuat( upvec, (float)moffset[1]*-time_redraw*20, tmp_quat); /* Rotate about the relative up vec */
-                                       QuatMul(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+                                       mul_m3_v3(mat, upvec);
+                                       axis_angle_to_quat( tmp_quat, upvec, (float)moffset[1]*-time_redraw*20); /* Rotate about the relative up vec */
+                                       mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                        if (fly->xlock) fly->xlock = 2; /*check for rotation*/
                                        if (fly->zlock) fly->zlock = 2;
@@ -2199,7 +2216,7 @@ int flyApply(FlyInfo *fly)
                                        upvec[0]=0;
                                        upvec[1]=1;
                                        upvec[2]=0;
-                                       Mat3MulVecfl(mat, upvec);
+                                       mul_m3_v3(mat, upvec);
 
                                        if(upvec[2] < 0.0f)
                                                moffset[0]= -moffset[0];
@@ -2213,11 +2230,11 @@ int flyApply(FlyInfo *fly)
                                                upvec[0]=0;
                                                upvec[1]=1;
                                                upvec[2]=0;
-                                               Mat3MulVecfl(mat, upvec);
+                                               mul_m3_v3(mat, upvec);
                                        }
 
-                                       VecRotToQuat( upvec, (float)moffset[0]*time_redraw*20, tmp_quat); /* Rotate about the relative up vec */
-                                       QuatMul(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+                                       axis_angle_to_quat( tmp_quat, upvec, (float)moffset[0]*time_redraw*20); /* Rotate about the relative up vec */
+                                       mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                        if (fly->xlock) fly->xlock = 2;/*check for rotation*/
                                        if (fly->zlock) fly->zlock = 2;
@@ -2227,7 +2244,7 @@ int flyApply(FlyInfo *fly)
                                        upvec[0]=1;
                                        upvec[1]=0;
                                        upvec[2]=0;
-                                       Mat3MulVecfl(mat, upvec);
+                                       mul_m3_v3(mat, upvec);
 
                                        /*make sure we have some z rolling*/
                                        if (fabs(upvec[2]) > 0.00001f) {
@@ -2236,9 +2253,9 @@ int flyApply(FlyInfo *fly)
                                                upvec[1]=0;
                                                upvec[2]=1;
 
-                                               Mat3MulVecfl(mat, upvec);
-                                               VecRotToQuat( upvec, roll*time_redraw_clamped*fly->zlock_momentum*0.1, tmp_quat); /* Rotate about the relative up vec */
-                                               QuatMul(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+                                               mul_m3_v3(mat, upvec);
+                                               axis_angle_to_quat( tmp_quat, upvec, roll*time_redraw_clamped*fly->zlock_momentum*0.1); /* Rotate about the relative up vec */
+                                               mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                                fly->zlock_momentum += 0.05f;
                                        } else {
@@ -2251,7 +2268,7 @@ int flyApply(FlyInfo *fly)
                                        upvec[0]=0;
                                        upvec[1]=0;
                                        upvec[2]=1;
-                                       Mat3MulVecfl(mat, upvec);
+                                       mul_m3_v3(mat, upvec);
                                        /*make sure we have some z rolling*/
                                        if (fabs(upvec[2]) > 0.00001) {
                                                roll= upvec[2] * -5;
@@ -2260,10 +2277,10 @@ int flyApply(FlyInfo *fly)
                                                upvec[1]= 0.0f;
                                                upvec[2]= 0.0f;
 
-                                               Mat3MulVecfl(mat, upvec);
+                                               mul_m3_v3(mat, upvec);
 
-                                               VecRotToQuat( upvec, roll*time_redraw_clamped*fly->xlock_momentum*0.1f, tmp_quat); /* Rotate about the relative up vec */
-                                               QuatMul(rv3d->viewquat, rv3d->viewquat, tmp_quat);
+                                               axis_angle_to_quat( tmp_quat, upvec, roll*time_redraw_clamped*fly->xlock_momentum*0.1f); /* Rotate about the relative up vec */
+                                               mul_qt_qtqt(rv3d->viewquat, rv3d->viewquat, tmp_quat);
 
                                                fly->xlock_momentum += 0.05f;
                                        } else {
@@ -2280,16 +2297,16 @@ int flyApply(FlyInfo *fly)
                                        /* move along the current axis */
                                        dvec_tmp[fly->axis]= 1.0f;
 
-                                       Mat3MulVecfl(mat, dvec_tmp);
+                                       mul_m3_v3(mat, dvec_tmp);
 
-                                       VecMulf(dvec_tmp, fly->speed * time_redraw * 0.25f);
+                                       mul_v3_fl(dvec_tmp, fly->speed * time_redraw * 0.25f);
                                }
                        }
 
                        /* impose a directional lag */
-                       VecLerpf(dvec, dvec_tmp, fly->dvec_prev, (1.0f/(1.0f+(time_redraw*5.0f))));
+                       interp_v3_v3v3(dvec, dvec_tmp, fly->dvec_prev, (1.0f/(1.0f+(time_redraw*5.0f))));
 
-                       if (rv3d->persp==V3D_CAMOB) {
+                       if (rv3d->persp==RV3D_CAMOB) {
                                if (v3d->camera->protectflag & OB_LOCK_LOCX)
                                        dvec[0] = 0.0;
                                if (v3d->camera->protectflag & OB_LOCK_LOCY)
@@ -2298,7 +2315,7 @@ int flyApply(FlyInfo *fly)
                                        dvec[2] = 0.0;
                        }
 
-                       VecAddf(rv3d->ofs, rv3d->ofs, dvec);
+                       add_v3_v3v3(rv3d->ofs, rv3d->ofs, dvec);
 #if 0 //XXX2.5
                        if (fly->zlock && fly->xlock)
                                headerprint("FlyKeys  Speed:(+/- | Wheel),  Upright Axis:X  on/Z on,   Slow:Shift,  Direction:WASDRF,  Ok:LMB,  Pan:MMB,  Cancel:RMB");
@@ -2313,18 +2330,18 @@ int flyApply(FlyInfo *fly)
 //XXX2.5                       do_screenhandlers(G.curscreen); /* advance the next frame */
 
                        /* we are in camera view so apply the view ofs and quat to the view matrix and set the camera to the view */
-                       if (rv3d->persp==V3D_CAMOB) {
-                               rv3d->persp= V3D_PERSP; /*set this so setviewmatrixview3d uses the ofs and quat instead of the camera */
+                       if (rv3d->persp==RV3D_CAMOB) {
+                               rv3d->persp= RV3D_PERSP; /*set this so setviewmatrixview3d uses the ofs and quat instead of the camera */
                                setviewmatrixview3d(scene, v3d, rv3d);
 
                                setcameratoview3d(v3d, rv3d, v3d->camera);
 
                                {       //XXX - some reason setcameratoview3d doesnt copy, shouldnt not be needed!
                                        VECCOPY(v3d->camera->loc, rv3d->ofs);
-                                       VecNegf(v3d->camera->loc);
+                                       negate_v3(v3d->camera->loc);
                                }
 
-                               rv3d->persp= V3D_CAMOB;
+                               rv3d->persp= RV3D_CAMOB;
 #if 0 //XXX2.5
                                /* record the motion */
                                if (IS_AUTOKEY_MODE(NORMAL) && (!playing_anim || cfra != G.scene->r.cfra)) {
@@ -2449,27 +2466,27 @@ void view3d_align_axis_to_vector(View3D *v3d, RegionView3D *rv3d, int axisidx, f
        else alignaxis[-axisidx-1]= -1.0;
        
        VECCOPY(norm, vec);
-       Normalize(norm);
+       normalize_v3(norm);
        
-       angle= (float)acos(Inpf(alignaxis, norm));
-       Crossf(axis, alignaxis, norm);
-       VecRotToQuat(axis, -angle, new_quat);
+       angle= (float)acos(dot_v3v3(alignaxis, norm));
+       cross_v3_v3v3(axis, alignaxis, norm);
+       axis_angle_to_quat( new_quat,axis, -angle);
        
        rv3d->view= 0;
        
-       if (rv3d->persp==V3D_CAMOB && v3d->camera) {
+       if (rv3d->persp==RV3D_CAMOB && v3d->camera) {
                /* switch out of camera view */
                float orig_ofs[3];
                float orig_dist= rv3d->dist;
                float orig_lens= v3d->lens;
                
                VECCOPY(orig_ofs, rv3d->ofs);
-               rv3d->persp= V3D_PERSP;
+               rv3d->persp= RV3D_PERSP;
                rv3d->dist= 0.0;
                view_settings_from_ob(v3d->camera, rv3d->ofs, NULL, NULL, &v3d->lens);
                smooth_view(NULL, NULL, NULL, orig_ofs, new_quat, &orig_dist, &orig_lens); // XXX
        } else {
-               if (rv3d->persp==V3D_CAMOB) rv3d->persp= V3D_PERSP; /* switch out of camera mode */
+               if (rv3d->persp==RV3D_CAMOB) rv3d->persp= RV3D_PERSP; /* switch out of camera mode */
                smooth_view(NULL, NULL, NULL, NULL, new_quat, NULL, NULL); // XXX
        }
 }