Merge remote-tracking branch 'origin/master' into openvdbopenvdb

1 files changed, 181 insertions, 152 deletions

diff --git a/source/blender/editors/transform/transform_manipulator.c b/source/blender/editors/transform/transform_manipulator.c
index 075f311db72..9a362ee609f 100644
--- a/source/blender/editors/transform/transform_manipulator.c
+++ b/source/blender/editors/transform/transform_manipulator.c
@@ -107,15 +107,16 @@
 #define TW_AXIS_DOT_MIN 0.02f
 #define TW_AXIS_DOT_MAX 0.1f
 
+struct TransformBounds {
+	float center[3];		/* Center for transform widget. */
+	float min[3], max[3];	/* Boundbox of selection for transform widget. */
+};
+
 /* transform widget center calc helper for below */
-static void calc_tw_center(Scene *scene, const float co[3])
+static void calc_tw_center(struct TransformBounds *tbounds, const float co[3])
 {
-	float *twcent = scene->twcent;
-	float *min = scene->twmin;
-	float *max = scene->twmax;
-
-	minmax_v3v3_v3(min, max, co);
-	add_v3_v3(twcent, co);
+	minmax_v3v3_v3(tbounds->min, tbounds->max, co);
+	add_v3_v3(tbounds->center, co);
 }
 
 static void protectflag_to_drawflags(short protectflag, short *drawflags)
@@ -143,21 +144,17 @@ static void protectflag_to_drawflags(short protectflag, short *drawflags)
 }
 
 /* for pose mode */
-static void stats_pose(Scene *scene, RegionView3D *rv3d, bPoseChannel *pchan)
+static void protectflag_to_drawflags_pchan(RegionView3D *rv3d, const bPoseChannel *pchan)
 {
-	Bone *bone = pchan->bone;
-
-	if (bone) {
-		calc_tw_center(scene, pchan->pose_head);
-		protectflag_to_drawflags(pchan->protectflag, &rv3d->twdrawflag);
-	}
+	protectflag_to_drawflags(pchan->protectflag, &rv3d->twdrawflag);
 }
 
 /* for editmode*/
-static void stats_editbone(RegionView3D *rv3d, EditBone *ebo)
+static void protectflag_to_drawflags_ebone(RegionView3D *rv3d, const EditBone *ebo)
 {
-	if (ebo->flag & BONE_EDITMODE_LOCKED)
+	if (ebo->flag & BONE_EDITMODE_LOCKED) {
 		protectflag_to_drawflags(OB_LOCK_LOC | OB_LOCK_ROT | OB_LOCK_SCALE, &rv3d->twdrawflag);
+	}
 }
 
 /* could move into BLI_math however this is only useful for display/editing purposes */
@@ -192,73 +189,71 @@ static void axis_angle_to_gimbal_axis(float gmat[3][3], const float axis[3], con
 }
 
 
-static int test_rotmode_euler(short rotmode)
+static bool test_rotmode_euler(short rotmode)
 {
 	return (ELEM(rotmode, ROT_MODE_AXISANGLE, ROT_MODE_QUAT)) ? 0 : 1;
 }
 
 bool gimbal_axis(Object *ob, float gmat[3][3])
 {
-	if (ob) {
-		if (ob->mode & OB_MODE_POSE) {
-			bPoseChannel *pchan = BKE_pose_channel_active(ob);
-
-			if (pchan) {
-				float mat[3][3], tmat[3][3], obmat[3][3];
-				if (test_rotmode_euler(pchan->rotmode)) {
-					eulO_to_gimbal_axis(mat, pchan->eul, pchan->rotmode);
-				}
-				else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
-					axis_angle_to_gimbal_axis(mat, pchan->rotAxis, pchan->rotAngle);
-				}
-				else { /* quat */
-					return 0;
-				}
-
-
-				/* apply bone transformation */
-				mul_m3_m3m3(tmat, pchan->bone->bone_mat, mat);
-
-				if (pchan->parent) {
-					float parent_mat[3][3];
+	if (ob->mode & OB_MODE_POSE) {
+		bPoseChannel *pchan = BKE_pose_channel_active(ob);
 
-					copy_m3_m4(parent_mat, pchan->parent->pose_mat);
-					mul_m3_m3m3(mat, parent_mat, tmat);
-
-					/* needed if object transformation isn't identity */
-					copy_m3_m4(obmat, ob->obmat);
-					mul_m3_m3m3(gmat, obmat, mat);
-				}
-				else {
-					/* needed if object transformation isn't identity */
-					copy_m3_m4(obmat, ob->obmat);
-					mul_m3_m3m3(gmat, obmat, tmat);
-				}
-
-				normalize_m3(gmat);
-				return 1;
+		if (pchan) {
+			float mat[3][3], tmat[3][3], obmat[3][3];
+			if (test_rotmode_euler(pchan->rotmode)) {
+				eulO_to_gimbal_axis(mat, pchan->eul, pchan->rotmode);
 			}
-		}
-		else {
-			if (test_rotmode_euler(ob->rotmode)) {
-				eulO_to_gimbal_axis(gmat, ob->rot, ob->rotmode);
-			}
-			else if (ob->rotmode == ROT_MODE_AXISANGLE) {
-				axis_angle_to_gimbal_axis(gmat, ob->rotAxis, ob->rotAngle);
+			else if (pchan->rotmode == ROT_MODE_AXISANGLE) {
+				axis_angle_to_gimbal_axis(mat, pchan->rotAxis, pchan->rotAngle);
 			}
 			else { /* quat */
 				return 0;
 			}
 
-			if (ob->parent) {
+
+			/* apply bone transformation */
+			mul_m3_m3m3(tmat, pchan->bone->bone_mat, mat);
+
+			if (pchan->parent) {
 				float parent_mat[3][3];
-				copy_m3_m4(parent_mat, ob->parent->obmat);
-				normalize_m3(parent_mat);
-				mul_m3_m3m3(gmat, parent_mat, gmat);
+
+				copy_m3_m4(parent_mat, pchan->parent->pose_mat);
+				mul_m3_m3m3(mat, parent_mat, tmat);
+
+				/* needed if object transformation isn't identity */
+				copy_m3_m4(obmat, ob->obmat);
+				mul_m3_m3m3(gmat, obmat, mat);
+			}
+			else {
+				/* needed if object transformation isn't identity */
+				copy_m3_m4(obmat, ob->obmat);
+				mul_m3_m3m3(gmat, obmat, tmat);
 			}
+
+			normalize_m3(gmat);
 			return 1;
 		}
 	}
+	else {
+		if (test_rotmode_euler(ob->rotmode)) {
+			eulO_to_gimbal_axis(gmat, ob->rot, ob->rotmode);
+		}
+		else if (ob->rotmode == ROT_MODE_AXISANGLE) {
+			axis_angle_to_gimbal_axis(gmat, ob->rotAxis, ob->rotAngle);
+		}
+		else { /* quat */
+			return 0;
+		}
+
+		if (ob->parent) {
+			float parent_mat[3][3];
+			copy_m3_m4(parent_mat, ob->parent->obmat);
+			normalize_m3(parent_mat);
+			mul_m3_m3m3(gmat, parent_mat, gmat);
+		}
+		return 1;
+	}
 
 	return 0;
 }
@@ -266,7 +261,7 @@ bool gimbal_axis(Object *ob, float gmat[3][3])
 
 /* centroid, boundbox, of selection */
 /* returns total items selected */
-static int calc_manipulator_stats(const bContext *C)
+static int calc_manipulator_stats(const bContext *C, struct TransformBounds *tbounds)
 {
 	ScrArea *sa = CTX_wm_area(C);
 	ARegion *ar = CTX_wm_region(C);
@@ -286,9 +281,9 @@ static int calc_manipulator_stats(const bContext *C)
 	rv3d->twdrawflag = 0xFFFF;
 
 	/* transform widget centroid/center */
-	INIT_MINMAX(scene->twmin, scene->twmax);
-	zero_v3(scene->twcent);
-	
+	INIT_MINMAX(tbounds->min, tbounds->max);
+	zero_v3(tbounds->center);
+
 	if (is_gp_edit) {
 		float diff_mat[4][4];
 		float fpt[3];
@@ -317,12 +312,12 @@ static int calc_manipulator_stats(const bContext *C)
 						for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
 							if (pt->flag & GP_SPOINT_SELECT) {
 								if (gpl->parent == NULL) {
-									calc_tw_center(scene, &pt->x);
+									calc_tw_center(tbounds, &pt->x);
 									totsel++;
 								}
 								else {
 									mul_v3_m4v3(fpt, diff_mat, &pt->x);
-									calc_tw_center(scene, fpt);
+									calc_tw_center(tbounds, fpt);
 									totsel++;
 								}
 							}
@@ -335,7 +330,7 @@ static int calc_manipulator_stats(const bContext *C)
 
 		/* selection center */
 		if (totsel) {
-			mul_v3_fl(scene->twcent, 1.0f / (float)totsel);   /* centroid! */
+			mul_v3_fl(tbounds->center, 1.0f / (float)totsel);
 		}
 	}
 	else if (obedit) {
@@ -350,7 +345,7 @@ static int calc_manipulator_stats(const bContext *C)
 			/* USE LAST SELECTE WITH ACTIVE */
 			if ((v3d->around == V3D_AROUND_ACTIVE) && BM_select_history_active_get(em->bm, &ese)) {
 				BM_editselection_center(&ese, vec);
-				calc_tw_center(scene, vec);
+				calc_tw_center(tbounds, vec);
 				totsel = 1;
 			}
 			else {
@@ -363,7 +358,7 @@ static int calc_manipulator_stats(const bContext *C)
 					if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
 						if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) {
 							totsel++;
-							calc_tw_center(scene, eve->co);
+							calc_tw_center(tbounds, eve->co);
 						}
 					}
 				}
@@ -376,22 +371,22 @@ static int calc_manipulator_stats(const bContext *C)
 			if ((v3d->around == V3D_AROUND_ACTIVE) && (ebo = arm->act_edbone)) {
 				/* doesn't check selection or visibility intentionally */
 				if (ebo->flag & BONE_TIPSEL) {
-					calc_tw_center(scene, ebo->tail);
+					calc_tw_center(tbounds, ebo->tail);
 					totsel++;
 				}
 				if ((ebo->flag & BONE_ROOTSEL) ||
 				    ((ebo->flag & BONE_TIPSEL) == false))  /* ensure we get at least one point */
 				{
-					calc_tw_center(scene, ebo->head);
+					calc_tw_center(tbounds, ebo->head);
 					totsel++;
 				}
-				stats_editbone(rv3d, ebo);
+				protectflag_to_drawflags_ebone(rv3d, ebo);
 			}
 			else {
 				for (ebo = arm->edbo->first; ebo; ebo = ebo->next) {
 					if (EBONE_VISIBLE(arm, ebo)) {
 						if (ebo->flag & BONE_TIPSEL) {
-							calc_tw_center(scene, ebo->tail);
+							calc_tw_center(tbounds, ebo->tail);
 							totsel++;
 						}
 						if ((ebo->flag & BONE_ROOTSEL) &&
@@ -401,11 +396,11 @@ static int calc_manipulator_stats(const bContext *C)
 						     (ebo->parent->flag & BONE_TIPSEL) &&
 						     EBONE_VISIBLE(arm, ebo->parent)) == 0)
 						{
-							calc_tw_center(scene, ebo->head);
+							calc_tw_center(tbounds, ebo->head);
 							totsel++;
 						}
 						if (ebo->flag & BONE_SELECTED) {
-							stats_editbone(rv3d, ebo);
+							protectflag_to_drawflags_ebone(rv3d, ebo);
 						}
 					}
 				}
@@ -416,7 +411,7 @@ static int calc_manipulator_stats(const bContext *C)
 			float center[3];
 
 			if (v3d->around == V3D_AROUND_ACTIVE && ED_curve_active_center(cu, center)) {
-				calc_tw_center(scene, center);
+				calc_tw_center(tbounds, center);
 				totsel++;
 			}
 			else {
@@ -437,21 +432,25 @@ static int calc_manipulator_stats(const bContext *C)
 							 */
 							if (cu->drawflag & CU_HIDE_HANDLES) {
 								if (bezt->f2 & SELECT) {
-									calc_tw_center(scene, bezt->vec[1]);
+									calc_tw_center(tbounds, bezt->vec[1]);
 									totsel++;
 								}
 							}
 							else if (bezt->f2 & SELECT) {
-								calc_tw_center(scene, bezt->vec[1]);
+								calc_tw_center(tbounds, bezt->vec[1]);
 								totsel++;
 							}
 							else {
 								if (bezt->f1 & SELECT) {
-									calc_tw_center(scene, bezt->vec[(v3d->around == V3D_AROUND_LOCAL_ORIGINS) ? 1 : 0]);
+									calc_tw_center(
+									        tbounds,
+									        bezt->vec[(v3d->around == V3D_AROUND_LOCAL_ORIGINS) ? 1 : 0]);
 									totsel++;
 								}
 								if (bezt->f3 & SELECT) {
-									calc_tw_center(scene, bezt->vec[(v3d->around == V3D_AROUND_LOCAL_ORIGINS) ? 1 : 2]);
+									calc_tw_center(
+									        tbounds,
+									        bezt->vec[(v3d->around == V3D_AROUND_LOCAL_ORIGINS) ? 1 : 2]);
 									totsel++;
 								}
 							}
@@ -463,7 +462,7 @@ static int calc_manipulator_stats(const bContext *C)
 						a = nu->pntsu * nu->pntsv;
 						while (a--) {
 							if (bp->f1 & SELECT) {
-								calc_tw_center(scene, bp->vec);
+								calc_tw_center(tbounds, bp->vec);
 								totsel++;
 							}
 							bp++;
@@ -478,13 +477,13 @@ static int calc_manipulator_stats(const bContext *C)
 			MetaElem *ml;
 
 			if ((v3d->around == V3D_AROUND_ACTIVE) && (ml = mb->lastelem)) {
-				calc_tw_center(scene, &ml->x);
+				calc_tw_center(tbounds, &ml->x);
 				totsel++;
 			}
 			else {
 				for (ml = mb->editelems->first; ml; ml = ml->next) {
 					if (ml->flag & SELECT) {
-						calc_tw_center(scene, &ml->x);
+						calc_tw_center(tbounds, &ml->x);
 						totsel++;
 					}
 				}
@@ -495,7 +494,7 @@ static int calc_manipulator_stats(const bContext *C)
 			BPoint *bp;
 
 			if ((v3d->around == V3D_AROUND_ACTIVE) && (bp = BKE_lattice_active_point_get(lt))) {
-				calc_tw_center(scene, bp->vec);
+				calc_tw_center(tbounds, bp->vec);
 				totsel++;
 			}
 			else {
@@ -503,7 +502,7 @@ static int calc_manipulator_stats(const bContext *C)
 				a = lt->pntsu * lt->pntsv * lt->pntsw;
 				while (a--) {
 					if (bp->f1 & SELECT) {
-						calc_tw_center(scene, bp->vec);
+						calc_tw_center(tbounds, bp->vec);
 						totsel++;
 					}
 					bp++;
@@ -513,10 +512,10 @@ static int calc_manipulator_stats(const bContext *C)
 
 		/* selection center */
 		if (totsel) {
-			mul_v3_fl(scene->twcent, 1.0f / (float)totsel);   // centroid!
-			mul_m4_v3(obedit->obmat, scene->twcent);
-			mul_m4_v3(obedit->obmat, scene->twmin);
-			mul_m4_v3(obedit->obmat, scene->twmax);
+			mul_v3_fl(tbounds->center, 1.0f / (float)totsel);
+			mul_m4_v3(obedit->obmat, tbounds->center);
+			mul_m4_v3(obedit->obmat, tbounds->min);
+			mul_m4_v3(obedit->obmat, tbounds->max);
 		}
 	}
 	else if (ob && (ob->mode & OB_MODE_POSE)) {
@@ -530,7 +529,8 @@ static int calc_manipulator_stats(const bContext *C)
 			/* doesn't check selection or visibility intentionally */
 			Bone *bone = pchan->bone;
 			if (bone) {
-				stats_pose(scene, rv3d, pchan);
+				calc_tw_center(tbounds, pchan->pose_head);
+				protectflag_to_drawflags_pchan(rv3d, pchan);
 				totsel = 1;
 				ok = true;
 			}
@@ -543,7 +543,8 @@ static int calc_manipulator_stats(const bContext *C)
 				for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
 					Bone *bone = pchan->bone;
 					if (bone && (bone->flag & BONE_TRANSFORM)) {
-						stats_pose(scene, rv3d, pchan);
+						calc_tw_center(tbounds, pchan->pose_head);
+						protectflag_to_drawflags_pchan(rv3d, pchan);
 					}
 				}
 				ok = true;
@@ -551,10 +552,10 @@ static int calc_manipulator_stats(const bContext *C)
 		}
 
 		if (ok) {
-			mul_v3_fl(scene->twcent, 1.0f / (float)totsel);   // centroid!
-			mul_m4_v3(ob->obmat, scene->twcent);
-			mul_m4_v3(ob->obmat, scene->twmin);
-			mul_m4_v3(ob->obmat, scene->twmax);
+			mul_v3_fl(tbounds->center, 1.0f / (float)totsel);
+			mul_m4_v3(ob->obmat, tbounds->center);
+			mul_m4_v3(ob->obmat, tbounds->min);
+			mul_m4_v3(ob->obmat, tbounds->max);
 		}
 	}
 	else if (ob && (ob->mode & OB_MODE_ALL_PAINT)) {
@@ -573,7 +574,7 @@ static int calc_manipulator_stats(const bContext *C)
 
 				for (k = 0, ek = point->keys; k < point->totkey; k++, ek++) {
 					if (ek->flag & PEK_SELECT) {
-						calc_tw_center(scene, (ek->flag & PEK_USE_WCO) ? ek->world_co : ek->co);
+						calc_tw_center(tbounds, (ek->flag & PEK_USE_WCO) ? ek->world_co : ek->co);
 						totsel++;
 					}
 				}
@@ -581,7 +582,7 @@ static int calc_manipulator_stats(const bContext *C)
 
 			/* selection center */
 			if (totsel)
-				mul_v3_fl(scene->twcent, 1.0f / (float)totsel);  // centroid!
+				mul_v3_fl(tbounds->center, 1.0f / (float)totsel);
 		}
 	}
 	else {
@@ -594,7 +595,7 @@ static int calc_manipulator_stats(const bContext *C)
 			if (TESTBASELIB(v3d, base)) {
 				if (ob == NULL)
 					ob = base->object;
-				calc_tw_center(scene, base->object->obmat[3]);
+				calc_tw_center(tbounds, base->object->obmat[3]);
 				protectflag_to_drawflags(base->object->protectflag, &rv3d->twdrawflag);
 				totsel++;
 			}
@@ -602,7 +603,7 @@ static int calc_manipulator_stats(const bContext *C)
 
 		/* selection center */
 		if (totsel) {
-			mul_v3_fl(scene->twcent, 1.0f / (float)totsel);   // centroid!
+			mul_v3_fl(tbounds->center, 1.0f / (float)totsel);
 		}
 	}
 
@@ -623,7 +624,7 @@ static int calc_manipulator_stats(const bContext *C)
 					break;
 				}
 				/* if not gimbal, fall through to normal */
-				/* fall-through */
+				ATTR_FALLTHROUGH;
 			}
 			case V3D_MANIP_NORMAL:
 			{
@@ -634,7 +635,7 @@ static int calc_manipulator_stats(const bContext *C)
 					break;
 				}
 				/* no break we define 'normal' as 'local' in Object mode */
-				/* fall-through */
+				ATTR_FALLTHROUGH;
 			}
 			case V3D_MANIP_LOCAL:
 			{
@@ -1647,9 +1648,10 @@ void BIF_draw_manipulator(const bContext *C)
 	if ((v3d->twtype & (V3D_MANIP_TRANSLATE | V3D_MANIP_ROTATE | V3D_MANIP_SCALE)) == 0) return;
 
 	{
+		struct TransformBounds tbounds;
 		v3d->twflag &= ~V3D_DRAW_MANIPULATOR;
 
-		totsel = calc_manipulator_stats(C);
+		totsel = calc_manipulator_stats(C, &tbounds);
 		if (totsel == 0) return;
 
 		v3d->twflag |= V3D_DRAW_MANIPULATOR;
@@ -1669,13 +1671,13 @@ void BIF_draw_manipulator(const bContext *C)
 					copy_v3_v3(rv3d->twmat[3], ob->obmat[3]);
 				}
 				else {
-					mid_v3_v3v3(rv3d->twmat[3], scene->twmin, scene->twmax);
+					mid_v3_v3v3(rv3d->twmat[3], tbounds.min, tbounds.max);
 				}
 				break;
 			}
 			case V3D_AROUND_LOCAL_ORIGINS:
 			case V3D_AROUND_CENTER_MEAN:
-				copy_v3_v3(rv3d->twmat[3], scene->twcent);
+				copy_v3_v3(rv3d->twmat[3], tbounds.center);
 				break;
 			case V3D_AROUND_CURSOR:
 				copy_v3_v3(rv3d->twmat[3], ED_view3d_cursor3d_get(scene, v3d));
@@ -1720,19 +1722,16 @@ void BIF_draw_manipulator(const bContext *C)
 	}
 }
 
-static int manipulator_selectbuf(ScrArea *sa, ARegion *ar, const int mval[2], float hotspot)
+static int manipulator_selectbuf(Scene *scene, ScrArea *sa, ARegion *ar, const int mval[2], float hotspot)
 {
 	View3D *v3d = sa->spacedata.first;
 	RegionView3D *rv3d = ar->regiondata;
-	rctf rect, selrect;
+	rcti rect;
 	GLuint buffer[64];      // max 4 items per select, so large enuf
 	short hits;
 	const bool is_picksel = true;
 	const bool do_passes = GPU_select_query_check_active();
 
-	/* XXX check a bit later on this... (ton) */
-	extern void view3d_winmatrix_set(ARegion *ar, View3D *v3d, rctf *rect);
-
 	/* when looking through a selected camera, the manipulator can be at the
 	 * exact same position as the view, skip so we don't break selection */
 	if (fabsf(mat4_to_scale(rv3d->twmat)) < 1e-7f)
@@ -1743,15 +1742,12 @@ static int manipulator_selectbuf(ScrArea *sa, ARegion *ar, const int mval[2], fl
 	rect.ymin = mval[1] - hotspot;
 	rect.ymax = mval[1] + hotspot;
 
-	selrect = rect;
-
-	view3d_winmatrix_set(ar, v3d, &rect);
-	mul_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
+	ED_view3d_draw_setup_view(NULL, scene, ar, v3d, NULL, NULL, &rect);
 
 	if (do_passes)
-		GPU_select_begin(buffer, 64, &selrect, GPU_SELECT_NEAREST_FIRST_PASS, 0);
+		GPU_select_begin(buffer, 64, &rect, GPU_SELECT_NEAREST_FIRST_PASS, 0);
 	else
-		GPU_select_begin(buffer, 64, &selrect, GPU_SELECT_ALL, 0);
+		GPU_select_begin(buffer, 64, &rect, GPU_SELECT_ALL, 0);
 
 	/* do the drawing */
 	if (v3d->twtype & V3D_MANIP_ROTATE) {
@@ -1765,8 +1761,8 @@ static int manipulator_selectbuf(ScrArea *sa, ARegion *ar, const int mval[2], fl
 
 	hits = GPU_select_end();
 
-	if (do_passes) {
-		GPU_select_begin(buffer, 64, &selrect, GPU_SELECT_NEAREST_SECOND_PASS, hits);
+	if (do_passes && (hits > 0)) {
+		GPU_select_begin(buffer, 64, &rect, GPU_SELECT_NEAREST_SECOND_PASS, hits);
 
 		/* do the drawing */
 		if (v3d->twtype & V3D_MANIP_ROTATE) {
@@ -1781,8 +1777,7 @@ static int manipulator_selectbuf(ScrArea *sa, ARegion *ar, const int mval[2], fl
 		GPU_select_end();
 	}
 
-	view3d_winmatrix_set(ar, v3d, NULL);
-	mul_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
+	ED_view3d_draw_setup_view(NULL, scene, ar, v3d, NULL, NULL, NULL);
 
 	if (hits == 1) return buffer[3];
 	else if (hits > 1) {
@@ -1826,16 +1821,34 @@ static int manipulator_selectbuf(ScrArea *sa, ARegion *ar, const int mval[2], fl
 	return 0;
 }
 
+static const char *manipulator_get_operator_name(int man_val)
+{
+	if (man_val & MAN_TRANS_C) {
+		return "TRANSFORM_OT_translate";
+	}
+	else if (man_val == MAN_ROT_T) {
+		return "TRANSFORM_OT_trackball";
+	}
+	else if (man_val & MAN_ROT_C) {
+		return "TRANSFORM_OT_rotate";
+	}
+	else if (man_val & MAN_SCALE_C) {
+		return "TRANSFORM_OT_resize";
+	}
+
+	return NULL;
+}
 
 /* return 0; nothing happened */
 int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 {
+	Scene *scene = CTX_data_scene(C);
 	ScrArea *sa = CTX_wm_area(C);
 	View3D *v3d = sa->spacedata.first;
 	ARegion *ar = CTX_wm_region(C);
 	int constraint_axis[3] = {0, 0, 0};
 	int val;
-	int shift = event->shift;
+	const bool use_planar = RNA_boolean_get(op->ptr, "use_planar_constraint");
 
 	if (!(v3d->twflag & V3D_USE_MANIPULATOR)) return 0;
 	if (!(v3d->twflag & V3D_DRAW_MANIPULATOR)) return 0;
@@ -1844,19 +1857,32 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 	RNA_enum_set(op->ptr, "constraint_orientation", v3d->twmode);
 
 	// find the hotspots first test narrow hotspot
-	val = manipulator_selectbuf(sa, ar, event->mval, 0.5f * (float)U.tw_hotspot);
+	val = manipulator_selectbuf(scene, sa, ar, event->mval, 0.5f * (float)U.tw_hotspot);
 	if (val) {
+		wmOperatorType *ot;
+		PointerRNA props_ptr;
+		PropertyRNA *prop;
+		const char *opname;
 
 		// drawflags still global, for drawing call above
-		drawflags = manipulator_selectbuf(sa, ar, event->mval, 0.2f * (float)U.tw_hotspot);
+		drawflags = manipulator_selectbuf(scene, sa, ar, event->mval, 0.2f * (float)U.tw_hotspot);
 		if (drawflags == 0) drawflags = val;
 
+		/* Planar constraint doesn't make sense for rotation, give other keymaps a chance */
+		if ((drawflags & MAN_ROT_C) && use_planar) {
+			return 0;
+		}
+
+		opname = manipulator_get_operator_name(drawflags);
+		ot = WM_operatortype_find(opname, true);
+		WM_operator_properties_create_ptr(&props_ptr, ot);
+
 		if (drawflags & MAN_TRANS_C) {
 			switch (drawflags) {
 				case MAN_TRANS_C:
 					break;
 				case MAN_TRANS_X:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[1] = 1;
 						constraint_axis[2] = 1;
 					}
@@ -1864,7 +1890,7 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[0] = 1;
 					break;
 				case MAN_TRANS_Y:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[0] = 1;
 						constraint_axis[2] = 1;
 					}
@@ -1872,7 +1898,7 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[1] = 1;
 					break;
 				case MAN_TRANS_Z:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[0] = 1;
 						constraint_axis[1] = 1;
 					}
@@ -1880,13 +1906,12 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[2] = 1;
 					break;
 			}
-			RNA_boolean_set_array(op->ptr, "constraint_axis", constraint_axis);
-			WM_operator_name_call(C, "TRANSFORM_OT_translate", WM_OP_INVOKE_DEFAULT, op->ptr);
+			RNA_boolean_set_array(&props_ptr, "constraint_axis", constraint_axis);
 		}
 		else if (drawflags & MAN_SCALE_C) {
 			switch (drawflags) {
 				case MAN_SCALE_X:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[1] = 1;
 						constraint_axis[2] = 1;
 					}
@@ -1894,7 +1919,7 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[0] = 1;
 					break;
 				case MAN_SCALE_Y:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[0] = 1;
 						constraint_axis[2] = 1;
 					}
@@ -1902,7 +1927,7 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[1] = 1;
 					break;
 				case MAN_SCALE_Z:
-					if (shift) {
+					if (use_planar) {
 						constraint_axis[0] = 1;
 						constraint_axis[1] = 1;
 					}
@@ -1910,22 +1935,10 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 						constraint_axis[2] = 1;
 					break;
 			}
-			RNA_boolean_set_array(op->ptr, "constraint_axis", constraint_axis);
-			WM_operator_name_call(C, "TRANSFORM_OT_resize", WM_OP_INVOKE_DEFAULT, op->ptr);
+			RNA_boolean_set_array(&props_ptr, "constraint_axis", constraint_axis);
 		}
-		else if (drawflags == MAN_ROT_T) { /* trackball need special case, init is different */
-			/* Do not pass op->ptr!!! trackball has no "constraint" properties!
-			 * See [#34621], it's a miracle it did not cause more problems!!! */
-			/* However, we need to copy the "release_confirm" property, but only if defined, see T41112. */
-			PointerRNA props_ptr;
-			PropertyRNA *prop;
-			wmOperatorType *ot = WM_operatortype_find("TRANSFORM_OT_trackball", true);
-			WM_operator_properties_create_ptr(&props_ptr, ot);
-			if ((prop = RNA_struct_find_property(op->ptr, "release_confirm")) && RNA_property_is_set(op->ptr, prop)) {
-				RNA_property_boolean_set(&props_ptr, prop, RNA_property_boolean_get(op->ptr, prop));
-			}
-			WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &props_ptr);
-			WM_operator_properties_free(&props_ptr);
+		else if (drawflags == MAN_ROT_T) {
+			/* pass */
 		}
 		else if (drawflags & MAN_ROT_C) {
 			switch (drawflags) {
@@ -1939,9 +1952,25 @@ int BIF_do_manipulator(bContext *C, const struct wmEvent *event, wmOperator *op)
 					constraint_axis[2] = 1;
 					break;
 			}
-			RNA_boolean_set_array(op->ptr, "constraint_axis", constraint_axis);
-			WM_operator_name_call(C, "TRANSFORM_OT_rotate", WM_OP_INVOKE_DEFAULT, op->ptr);
+			RNA_boolean_set_array(&props_ptr, "constraint_axis", constraint_axis);
+		}
+
+		/* pass operator properties on to transform operators */
+		prop = RNA_struct_find_property(op->ptr, "use_accurate");
+		if (RNA_property_is_set(op->ptr, prop)) {
+			RNA_property_boolean_set(&props_ptr, prop, RNA_property_boolean_get(op->ptr, prop));
 		}
+		prop = RNA_struct_find_property(op->ptr, "release_confirm");
+		if (RNA_property_is_set(op->ptr, prop)) {
+			RNA_property_boolean_set(&props_ptr, prop, RNA_property_boolean_get(op->ptr, prop));
+		}
+		prop = RNA_struct_find_property(op->ptr, "constraint_orientation");
+		if (RNA_property_is_set(op->ptr, prop)) {
+			RNA_property_enum_set(&props_ptr, prop, RNA_property_enum_get(op->ptr, prop));
+		}
+
+		WM_operator_name_call_ptr(C, ot, WM_OP_INVOKE_DEFAULT, &props_ptr);
+		WM_operator_properties_free(&props_ptr);
 	}
 	/* after transform, restore drawflags */
 	drawflags = 0xFFFF;