STORM-1920: Corrected bug where snap values would highlight that weren’t supposed to be highlighting. Did some more cleanup and documentation.

Also corrected a bug in Richard’s patch that resulted in the object scaling up when the mouse went the opposite direction from the scale.  The issue is that the vector length is an absolute value.  To allow for "negative" results to be found and discarded, I instead used a dot product with a parallel unit vector to get the signed magnitude - or, if you prefer, the mono-dimensional vector.

This bug only surfaced once the code made to actually work as intended in regards to the highlighting.  Turns out that if the snapped value was at 2, any axis that was showing values would highlight its "2" text - and the same for all other values.
To fix this, I used a simple enum and repurposed the property that tracked whether or not the cursor was in a snap regime.  Now it not only tracks whether or not the cursor is in a snap regime, but which one it is in.  This allowed the highlight render code to be able to differentiate which row was supposed to highlight and which did not.

A couple more duplicated math operations were reduced by rearranging the order of some variable definitions.  If at all possible, only do division once.  The result is much cleaner and easier to read code.
Several deprecated vector functions were updated to match their new versions.  If you are going to mark something deprecated, why not just take the time to go through and find all uses and clean it up!?
faceToUnitVector() was cleaned up to use the single-output design, matching cornerToUnitVector().
A mess of trailing whitespace was cleaned out.
Many more LLManipScale private variables are now documented - though I only documented those I understood fully while reading where they were created and how they were used.

2 files changed, 152 insertions, 143 deletions

diff --git a/indra/newview/llmanipscale.cpp b/indra/newview/llmanipscale.cpp
index af9fe385b2..23cbc580f6 100755
--- a/indra/newview/llmanipscale.cpp
+++ b/indra/newview/llmanipscale.cpp
@@ -68,7 +68,7 @@ const F32 SELECTED_MANIPULATOR_SCALE = 1.2f;
 const F32 MANIPULATOR_SCALE_HALF_LIFE = 0.07f;
 const S32 NUM_MANIPULATORS = 14;
 
-const LLManip::EManipPart MANIPULATOR_IDS[NUM_MANIPULATORS] = 
+const LLManip::EManipPart MANIPULATOR_IDS[NUM_MANIPULATORS] =
 {
 	LLManip::LL_CORNER_NNN,
 	LLManip::LL_CORNER_NNP,
@@ -87,7 +87,7 @@ const LLManip::EManipPart MANIPULATOR_IDS[NUM_MANIPULATORS] =
 };
 
 
-F32 get_default_max_prim_scale(bool is_flora) 
+F32 get_default_max_prim_scale(bool is_flora)
 {
 	// a bit of a hack, but if it's foilage, we don't want to use the
 	// new larger scale which would result in giant trees and grass
@@ -97,7 +97,7 @@ F32 get_default_max_prim_scale(bool is_flora)
 		return DEFAULT_MAX_PRIM_SCALE;
 	}
 	else
-	{	
+	{
 		return DEFAULT_MAX_PRIM_SCALE_NO_MESH;
 	}
 }
@@ -179,7 +179,7 @@ void LLManipScale::handleSelect()
 }
 
 LLManipScale::LLManipScale( LLToolComposite* composite )
-	: 
+	:
 	LLManip( std::string("Scale"), composite ),
 	mBoxHandleSize( 1.f ),
 	mScaledBoxHandleSize( 1.f ),
@@ -193,9 +193,9 @@ LLManipScale::LLManipScale( LLToolComposite* composite )
 	mTickPixelSpacing1(0.f),
 	mTickPixelSpacing2(0.f),
 	mSnapGuideLength(0.f),
-	mInSnapRegime(FALSE),
+	mSnapRegime(SNAP_REGIME_NONE),
 	mScaleSnappedValue(0.f)
-{ 
+{
 	mManipulatorScales = new F32[NUM_MANIPULATORS];
 	for (S32 i = 0; i < NUM_MANIPULATORS; i++)
 	{
@@ -216,7 +216,7 @@ void LLManipScale::render()
 	LLGLDepthTest gls_depth(GL_TRUE);
 	LLGLEnable gl_blend(GL_BLEND);
 	LLGLEnable gls_alpha_test(GL_ALPHA_TEST);
-	
+
 	if( canAffectSelection() )
 	{
 		gGL.matrixMode(LLRender::MM_MODELVIEW);
@@ -228,11 +228,11 @@ void LLManipScale::render()
 		}
 
 		////////////////////////////////////////////////////////////////////////
-		// Calculate size of drag handles 	
+		// Calculate size of drag handles
 
 		const F32 BOX_HANDLE_BASE_SIZE		= 50.0f;   // box size in pixels = BOX_HANDLE_BASE_SIZE * BOX_HANDLE_BASE_FACTOR
 		const F32 BOX_HANDLE_BASE_FACTOR	= 0.2f;
-		
+
 		LLVector3 center_agent = gAgent.getPosAgentFromGlobal(LLSelectMgr::getInstance()->getSelectionCenterGlobal());
 
 		if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
@@ -285,7 +285,7 @@ void LLManipScale::render()
 			rot.getAngleAxis(&angle_radians, &x, &y, &z);
 			gGL.rotatef(angle_radians * RAD_TO_DEG, x, y, z);
 
-			
+
 			{
 				LLGLEnable poly_offset(GL_POLYGON_OFFSET_FILL);
 				glPolygonOffset( -2.f, -2.f);
@@ -347,7 +347,7 @@ BOOL LLManipScale::handleMouseDownOnPart( S32 x, S32 y, MASK mask )
 	LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
 	LLVector3 box_center_agent = bbox.getCenterAgent();
 	LLVector3 box_corner_agent = bbox.localToAgent( unitVectorToLocalBBoxExtent( partToUnitVector( mManipPart ), bbox ) );
-	
+
 	updateSnapGuides(bbox);
 
 	mDragStartPointGlobal = gAgent.getPosGlobalFromAgent(box_corner_agent);
@@ -374,27 +374,27 @@ BOOL LLManipScale::handleMouseUp(S32 x, S32 y, MASK mask)
 
 	if( hasMouseCapture() )
 	{
-		if( (LL_FACE_MIN <= (S32)mManipPart) 
+		if( (LL_FACE_MIN <= (S32)mManipPart)
 			&& ((S32)mManipPart <= LL_FACE_MAX) )
 		{
 			sendUpdates(TRUE,TRUE,FALSE);
 		}
 		else
-		if( (LL_CORNER_MIN <= (S32)mManipPart) 
+		if( (LL_CORNER_MIN <= (S32)mManipPart)
 			&& ((S32)mManipPart <= LL_CORNER_MAX) )
 		{
 			sendUpdates(TRUE,TRUE,TRUE);
 		}
-		
+
 		//send texture update
 		LLSelectMgr::getInstance()->adjustTexturesByScale(TRUE, getStretchTextures());
-		
+
 		LLSelectMgr::getInstance()->enableSilhouette(TRUE);
 		mManipPart = LL_NO_PART;
 
 		// Might have missed last update due to UPDATE_DELAY timing
 		LLSelectMgr::getInstance()->sendMultipleUpdate( mLastUpdateFlags );
-		
+
 		//gAgent.setObjectTracking(gSavedSettings.getBOOL("TrackFocusObject"));
 		LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK);
 	}
@@ -415,15 +415,15 @@ BOOL LLManipScale::handleHover(S32 x, S32 y, MASK mask)
 		{
 			drag( x, y );
 		}
-		lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipScale (active)" << llendl;		
+		lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipScale (active)" << llendl;
 	}
 	else
 	{
-		mInSnapRegime = FALSE;
+		mSnapRegime = SNAP_REGIME_NONE;
 		// not dragging...
 		highlightManipulators(x, y);
 	}
-	
+
 	// Patch up textures, if possible.
 	LLSelectMgr::getInstance()->adjustTexturesByScale(FALSE, getStretchTextures());
 
@@ -460,7 +460,7 @@ void LLManipScale::highlightManipulators(S32 x, S32 y)
 			LLMatrix4 projMatrix = LLViewerCamera::getInstance()->getProjection();
 			LLMatrix4 modelView = LLViewerCamera::getInstance()->getModelview();
 			transform.initAll(LLVector3(1.f, 1.f, 1.f), bbox.getRotation(), bbox.getPositionAgent());
-			
+
 			transform *= modelView;
 			transform *= projMatrix;
 		}
@@ -479,7 +479,7 @@ void LLManipScale::highlightManipulators(S32 x, S32 y)
 		mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], min.mV[VY], max.mV[VZ], 1.f);
 		mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], max.mV[VY], min.mV[VZ], 1.f);
 		mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], max.mV[VY], max.mV[VZ], 1.f);
-		
+
 		// 1-D highlights are applicable iff one object is selected
 		if( mObjectSelection->getObjectCount() == 1 )
 		{
@@ -494,13 +494,13 @@ void LLManipScale::highlightManipulators(S32 x, S32 y)
 
 		for_each(mProjectedManipulators.begin(), mProjectedManipulators.end(), DeletePointer());
 		mProjectedManipulators.clear();
-		
+
 		for (S32 i = 0; i < numManips; i++)
 		{
 			LLVector4 projectedVertex = mManipulatorVertices[i] * transform;
 			projectedVertex = projectedVertex * (1.f / projectedVertex.mV[VW]);
 
-			ManipulatorHandle* projManipulator = new ManipulatorHandle(LLVector3(projectedVertex.mV[VX], projectedVertex.mV[VY], 
+			ManipulatorHandle* projManipulator = new ManipulatorHandle(LLVector3(projectedVertex.mV[VX], projectedVertex.mV[VY],
 				projectedVertex.mV[VZ]), MANIPULATOR_IDS[i], (i < 7) ? SCALE_MANIP_CORNER : SCALE_MANIP_FACE);
 			mProjectedManipulators.insert(projManipulator);
 		}
@@ -514,13 +514,13 @@ void LLManipScale::highlightManipulators(S32 x, S32 y)
 
 		mHighlightedPart = LL_NO_PART;
 
-		for (minpulator_list_t::iterator iter = mProjectedManipulators.begin();
+		for (manipulator_list_t::iterator iter = mProjectedManipulators.begin();
 			 iter != mProjectedManipulators.end(); ++iter)
 		{
 			ManipulatorHandle* manipulator = *iter;
 			{
-				manip2d.setVec(manipulator->mPosition.mV[VX] * half_width, manipulator->mPosition.mV[VY] * half_height);
-				
+				manip2d.set(manipulator->mPosition.mV[VX] * half_width, manipulator->mPosition.mV[VY] * half_height);
+
 				delta = manip2d - mousePos;
 				if (delta.magVecSquared() < MAX_MANIP_SELECT_DISTANCE_SQUARED)
 				{
@@ -551,7 +551,7 @@ void LLManipScale::highlightManipulators(S32 x, S32 y)
 
 void LLManipScale::renderFaces( const LLBBox& bbox )
 {
-	// Don't bother to render the drag handles for 1-D scaling if 
+	// Don't bother to render the drag handles for 1-D scaling if
 	// more than one object is selected or if it is an attachment
 	if ( mObjectSelection->getObjectCount() > 1 )
 	{
@@ -604,7 +604,7 @@ void LLManipScale::renderFaces( const LLBBox& bbox )
 	{
 		gGL.color4fv( default_normal_color.mV );
 		LLGLDepthTest gls_depth(GL_FALSE);
-		gGL.begin(LLRender::QUADS); 
+		gGL.begin(LLRender::QUADS);
 		{
 			// Face 0
 			gGL.vertex3f(min.mV[VX], max.mV[VY], max.mV[VZ]);
@@ -647,9 +647,9 @@ void LLManipScale::renderFaces( const LLBBox& bbox )
 
 	// Find nearest vertex
 	LLVector3 orientWRTHead = bbox.agentToLocalBasis( bbox.getCenterAgent() - gAgentCamera.getCameraPositionAgent() );
-	U32 nearest = 
-		(orientWRTHead.mV[0] < 0.0f ? 1 : 0) + 
-		(orientWRTHead.mV[1] < 0.0f ? 2 : 0) + 
+	U32 nearest =
+		(orientWRTHead.mV[0] < 0.0f ? 1 : 0) +
+		(orientWRTHead.mV[1] < 0.0f ? 2 : 0) +
 		(orientWRTHead.mV[2] < 0.0f ? 4 : 0);
 
 	// opposite faces on Linden cubes:
@@ -658,7 +658,7 @@ void LLManipScale::renderFaces( const LLBBox& bbox )
 	// 2 & 4
 
 	// Table of order to draw faces, based on nearest vertex
-	static U32 face_list[8][6] = { 
+	static U32 face_list[8][6] = {
 		{ 2,0,1, 4,5,3 }, // v6  F201 F453
 		{ 2,0,3, 4,5,1 }, // v7  F203 F451
 		{ 4,0,1, 2,5,3 }, // v5  F401 F253
@@ -725,7 +725,7 @@ void LLManipScale::renderEdges( const LLBBox& bbox )
 		{
 			gGL.translatef( center_to_edge.mV[0], center_to_edge.mV[1], center_to_edge.mV[2] );
 			conditionalHighlight( part );
-			gGL.scalef( 
+			gGL.scalef(
 				direction.mV[0] ? edge_width : extent.mV[VX],
 				direction.mV[1] ? edge_width : extent.mV[VY],
 				direction.mV[2] ? edge_width : extent.mV[VZ] );
@@ -793,7 +793,7 @@ void LLManipScale::renderAxisHandle( const LLVector3& start, const LLVector3& en
 		gGL.pushMatrix();
 		{
 			gGL.translatef( pos.mV[VX], pos.mV[VY], pos.mV[VZ] );
-			gGL.scalef( 
+			gGL.scalef(
 				mBoxHandleSize + llabs(delta.mV[VX]),
 				mBoxHandleSize + llabs(delta.mV[VY]),
 				mBoxHandleSize + llabs(delta.mV[VZ]));
@@ -810,18 +810,18 @@ void LLManipScale::renderAxisHandle( const LLVector3& start, const LLVector3& en
 
 void LLManipScale::drag( S32 x, S32 y )
 {
-	if( (LL_FACE_MIN <= (S32)mManipPart) 
+	if( (LL_FACE_MIN <= (S32)mManipPart)
 		&& ((S32)mManipPart <= LL_FACE_MAX) )
 	{
 		dragFace( x, y );
 	}
 	else
-	if( (LL_CORNER_MIN <= (S32)mManipPart) 
+	if( (LL_CORNER_MIN <= (S32)mManipPart)
 		&& ((S32)mManipPart <= LL_CORNER_MAX) )
 	{
 		dragCorner( x, y );
 	}
-	
+
 	// store changes to override updates
 	for (LLObjectSelection::iterator iter = LLSelectMgr::getInstance()->getSelection()->begin();
 		 iter != LLSelectMgr::getInstance()->getSelection()->end(); iter++)
@@ -842,7 +842,7 @@ void LLManipScale::drag( S32 x, S32 y )
 	gAgentCamera.clearFocusObject();
 }
 
-// Scale around the 
+// Scale around the
 void LLManipScale::dragCorner( S32 x, S32 y )
 {
 	// Suppress scale if mouse hasn't moved.
@@ -857,11 +857,11 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 	LLVector3 drag_start_center_agent = gAgent.getPosAgentFromGlobal(mDragStartCenterGlobal);
 
 	LLVector3d drag_start_dir_d;
-	drag_start_dir_d.setVec(mDragStartPointGlobal - mDragStartCenterGlobal);
+	drag_start_dir_d.set(mDragStartPointGlobal - mDragStartCenterGlobal);
 
 	F32 s = 0;
 	F32 t = 0;
-	nearestPointOnLineFromMouse(x, y, 
+	nearestPointOnLineFromMouse(x, y,
 								drag_start_center_agent,
 								drag_start_point_agent,
 								s, t );
@@ -872,7 +872,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 	}
 	mDragPointGlobal = lerp(mDragStartCenterGlobal, mDragStartPointGlobal, t);
 
-	LLBBox bbox      = LLSelectMgr::getInstance()->getBBoxOfSelection();
+	LLBBox bbox	     = LLSelectMgr::getInstance()->getBBoxOfSelection();
 	F32 scale_factor = 1.f;
 	F32 max_scale    = partToMaxScale(mManipPart, bbox);
 	F32 min_scale    = partToMinScale(mManipPart, bbox);
@@ -893,7 +893,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 	BOOL snap_enabled = gSavedSettings.getBOOL("SnapEnabled");
 	if (snap_enabled && (mouse_on_plane1 - projected_drag_pos1) * mSnapGuideDir1 > mSnapRegimeOffset)
 	{
-		F32 drag_dist = projected_drag_pos1.length();
+		F32 drag_dist = mScaleDir * projected_drag_pos1; // Projecting the drag position allows for negative results, vs using the length which will result in a "reverse scaling" bug.
 
 		F32 cur_subdivisions = llclamp(getSubdivisionLevel(mScaleCenter + projected_drag_pos1, mScaleDir, mScaleSnapUnit1, mTickPixelSpacing1), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
 		F32 snap_dist = mScaleSnapUnit1 / (2.f * cur_subdivisions);
@@ -902,7 +902,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 		mScaleSnappedValue = llclamp((drag_dist - (relative_snap_dist - snap_dist)), min_scale, max_scale);
 		scale_factor  =  mScaleSnappedValue / dist_vec(drag_start_point_agent, drag_start_center_agent);
 		mScaleSnappedValue /= mScaleSnapUnit1 * 2.f;
-		mInSnapRegime = TRUE;
+		mSnapRegime = SNAP_REGIME_UPPER;
 
 		if (!uniform)
 		{
@@ -911,7 +911,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 	}
 	else if (snap_enabled && (mouse_on_plane2 - projected_drag_pos2) * mSnapGuideDir2 > mSnapRegimeOffset )
 	{
-		F32 drag_dist = projected_drag_pos2.length();
+		F32 drag_dist = mScaleDir * projected_drag_pos2; // Projecting the drag position allows for negative results, vs using the length which will result in a "reverse scaling" bug.
 
 		F32 cur_subdivisions = llclamp(getSubdivisionLevel(mScaleCenter + projected_drag_pos2, mScaleDir, mScaleSnapUnit2, mTickPixelSpacing2), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
 		F32 snap_dist = mScaleSnapUnit2 / (2.f * cur_subdivisions);
@@ -920,16 +920,16 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 		mScaleSnappedValue = llclamp((drag_dist - (relative_snap_dist - snap_dist)), min_scale, max_scale);
 		scale_factor = mScaleSnappedValue / dist_vec(drag_start_point_agent, drag_start_center_agent);
 		mScaleSnappedValue /= mScaleSnapUnit2 * 2.f;
-		mInSnapRegime = TRUE;
+		mSnapRegime = SNAP_REGIME_LOWER;
 
 		if (!uniform)
 		{
 			scale_factor *= 0.5f;
 		}
 	}
-	else 
+	else
 	{
-		mInSnapRegime = FALSE;
+		mSnapRegime = SNAP_REGIME_NONE;
 		scale_factor = t;
 		if (!uniform)
 		{
@@ -979,7 +979,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 		{
 			const LLVector3& scale = selectNode->mSavedScale;
 			cur->setScale( scale_factor * scale );
-			
+
 			LLVector3 delta_pos;
 			LLVector3 original_pos = cur->getPositionEdit();
 			LLVector3d new_pos_global = drag_global + (selectNode->mSavedPositionGlobal - drag_global) * scale_factor;
@@ -989,7 +989,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 			}
 			cur->setPositionAbsoluteGlobal( new_pos_global );
 			rebuild(cur);
-			
+
 			delta_pos = cur->getPositionEdit() - original_pos;
 
 			if (selectNode->mIndividualSelection)
@@ -1030,7 +1030,7 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 		{
 			const LLVector3& scale = selectNode->mSavedScale;
 			cur->setScale( scale_factor * scale, FALSE );
-							
+
 			if (!selectNode->mIndividualSelection)
 			{
 				cur->setPosition(selectNode->mSavedPositionLocal * scale_factor);
@@ -1039,16 +1039,14 @@ void LLManipScale::dragCorner( S32 x, S32 y )
 			rebuild(cur);
 		}
 	}
-
 }
 
-	
+
 void LLManipScale::dragFace( S32 x, S32 y )
 {
 	// Suppress scale if mouse hasn't moved.
 	if (x == mLastMouseX && y == mLastMouseY)
 	{
-	//	sendUpdates(TRUE,TRUE,FALSE);
 		return;
 	}
 
@@ -1061,9 +1059,9 @@ void LLManipScale::dragFace( S32 x, S32 y )
 	LLVector3 drag_start_center_agent = gAgent.getPosAgentFromGlobal(drag_start_center_global);
 
 	LLVector3d drag_start_dir_d;
-	drag_start_dir_d.setVec(drag_start_point_global - drag_start_center_global);
+	drag_start_dir_d.set(drag_start_point_global - drag_start_center_global);
 	LLVector3 drag_start_dir_f;
-	drag_start_dir_f.setVec(drag_start_dir_d);
+	drag_start_dir_f.set(drag_start_dir_d);
 
 	LLBBox bbox	= LLSelectMgr::getInstance()->getBBoxOfSelection();
 
@@ -1107,21 +1105,21 @@ void LLManipScale::dragFace( S32 x, S32 y )
 
 	if (snap_enabled && dist_from_scale_line > mSnapRegimeOffset)
 	{
-		mInSnapRegime = TRUE;
+		mSnapRegime = SNAP_REGIME_UPPER | SNAP_REGIME_LOWER; // A face drag doesn't have split regimes.
 
 		if (dist_along_scale_line > max_drag_dist)
 		{
 			mScaleSnappedValue = max_drag_dist;
 
 			LLVector3 clamp_point = mScaleCenter + max_drag_dist * mScaleDir;
-			drag_delta.setVec(clamp_point - drag_start_point_agent);
+			drag_delta.set(clamp_point - drag_start_point_agent);
 		}
 		else if (dist_along_scale_line < min_drag_dist)
 		{
 			mScaleSnappedValue = min_drag_dist;
 
 			LLVector3 clamp_point = mScaleCenter + min_drag_dist * mScaleDir;
-			drag_delta.setVec(clamp_point - drag_start_point_agent);
+			drag_delta.set(clamp_point - drag_start_point_agent);
 		}
 		else
 		{
@@ -1154,9 +1152,9 @@ void LLManipScale::dragFace( S32 x, S32 y )
 			}
 		}
 	}
-	else 
+	else
 	{
-		mInSnapRegime = FALSE;
+		mSnapRegime = SNAP_REGIME_NONE;
 	}
 
 	LLVector3 dir_agent;
@@ -1172,7 +1170,7 @@ void LLManipScale::dragFace( S32 x, S32 y )
 	{
 		dir_agent = bbox.localToAgentBasis( LLVector3::z_axis );
 	}
-	stretchFace( 
+	stretchFace(
 		projected_vec(drag_start_dir_f, dir_agent) + drag_start_center_agent,
 		projected_vec(drag_delta, dir_agent));
 
@@ -1191,7 +1189,7 @@ void LLManipScale::sendUpdates( BOOL send_position_update, BOOL send_scale_updat
 		U32 update_flags = UPD_NONE;
 		if (send_position_update)	update_flags |= UPD_POSITION;
 		if (send_scale_update)		update_flags |= UPD_SCALE;
-		
+
 // 		BOOL send_type = SEND_INDIVIDUALS;
 		if (corner)
 		{
@@ -1239,7 +1237,7 @@ void LLManipScale::stretchFace( const LLVector3& drag_start_agent, const LLVecto
 			S32 axis_index			= axis.mV[0] ? 0 : (axis.mV[1] ? 1 : 2 );
 
 			LLVector3 delta_local	= end_local - start_local;
-			F32 delta_local_mag		= delta_local.magVec();
+			F32 delta_local_mag		= delta_local.length();
 			LLVector3 dir_local;
 			if (delta_local_mag == 0.f)
 			{
@@ -1259,13 +1257,13 @@ void LLManipScale::stretchFace( const LLVector3& drag_start_agent, const LLVecto
 			LLVector3 scale			= cur->getScale();
 			scale.mV[axis_index]	= desired_scale;
 			cur->setScale(scale, FALSE);
-			rebuild(cur);				
+			rebuild(cur);
 			LLVector3 delta_pos;
 			if( !getUniform() )
 			{
 				LLVector3 delta_pos_local = axis * (0.5f * desired_delta_size);
 				LLVector3d delta_pos_global;
-				delta_pos_global.setVec(cur_bbox.localToAgent( delta_pos_local ) - cur_bbox.getCenterAgent());
+				delta_pos_global.set(cur_bbox.localToAgent( delta_pos_local ) - cur_bbox.getCenterAgent());
 				LLVector3 cur_pos = cur->getPositionEdit();
 
 				if (cur->isRootEdit() && !cur->isAttachment())
@@ -1314,7 +1312,7 @@ void LLManipScale::stretchFace( const LLVector3& drag_start_agent, const LLVecto
 void LLManipScale::renderGuidelinesPart( const LLBBox& bbox )
 {
 	LLVector3 guideline_start = bbox.getCenterLocal();
-	
+
 	LLVector3 guideline_end = unitVectorToLocalBBoxExtent( partToUnitVector( mManipPart ), bbox );
 
 	if (!getUniform())
@@ -1364,7 +1362,7 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 	F32 snap_guide_length;
 	if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
 	{
-		cam_at_axis.setVec(1.f, 0.f, 0.f);
+		cam_at_axis.set(1.f, 0.f, 0.f);
 		snap_guide_length = SNAP_GUIDE_SCREEN_LENGTH / gAgentCamera.mHUDCurZoom;
 	}
 	else
@@ -1373,7 +1371,7 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 		F32 manipulator_distance = dist_vec(box_corner_agent, LLViewerCamera::getInstance()->getOrigin());
 		snap_guide_length = (SNAP_GUIDE_SCREEN_LENGTH * gViewerWindow->getWorldViewWidthRaw() * manipulator_distance) / LLViewerCamera::getInstance()->getPixelMeterRatio();
 	}
-	
+
 	mSnapGuideLength = snap_guide_length / llmax(0.1f, (llmin(mSnapGuideDir1 * cam_at_axis, mSnapGuideDir2 * cam_at_axis)));
 
 	LLVector3 off_axis_dir = mScaleDir % cam_at_axis;
@@ -1397,7 +1395,7 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 		}
 
 		LLVector3 scale_snap = grid_scale;
-		mScaleSnapUnit1 = scale_snap.scaleVec(partToUnitVector( mManipPart )).magVec();
+		mScaleSnapUnit1 = scale_snap.scaleVec(partToUnitVector( mManipPart )).length();
 		mScaleSnapUnit2 = mScaleSnapUnit1;
 		mSnapGuideDir1 *= mSnapGuideDir1 * LLViewerCamera::getInstance()->getUpAxis() > 0.f ? 1.f : -1.f;
 		mSnapGuideDir2 = mSnapGuideDir1 * -1.f;
@@ -1421,28 +1419,28 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 		switch (mManipPart)
 		{
 		case LL_CORNER_NNN:
-			axis_flip.setVec(1.f, 1.f, 1.f);
+			axis_flip.set(1.f, 1.f, 1.f);
 			break;
 		case LL_CORNER_NNP:
-			axis_flip.setVec(1.f, 1.f, -1.f);
+			axis_flip.set(1.f, 1.f, -1.f);
 			break;
 		case LL_CORNER_NPN:
-			axis_flip.setVec(1.f, -1.f, 1.f);
+			axis_flip.set(1.f, -1.f, 1.f);
 			break;
 		case LL_CORNER_NPP:
-			axis_flip.setVec(1.f, -1.f, -1.f);
+			axis_flip.set(1.f, -1.f, -1.f);
 			break;
 		case LL_CORNER_PNN:
-			axis_flip.setVec(-1.f, 1.f, 1.f);
+			axis_flip.set(-1.f, 1.f, 1.f);
 			break;
 		case LL_CORNER_PNP:
-			axis_flip.setVec(-1.f, 1.f, -1.f);
+			axis_flip.set(-1.f, 1.f, -1.f);
 			break;
 		case LL_CORNER_PPN:
-			axis_flip.setVec(-1.f, -1.f, 1.f);
+			axis_flip.set(-1.f, -1.f, 1.f);
 			break;
 		case LL_CORNER_PPP:
-			axis_flip.setVec(-1.f, -1.f, -1.f);
+			axis_flip.set(-1.f, -1.f, -1.f);
 			break;
 		default:
 			break;
@@ -1515,7 +1513,7 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 			mSnapGuideDir1 = LLVector3::y_axis.scaledVec(axis_flip);
 			mScaleSnapUnit1 = grid_scale.mV[VZ];
 			mSnapGuideDir2 = LLVector3::z_axis.scaledVec(axis_flip);
-			mScaleSnapUnit2 = grid_scale.mV[VY];			
+			mScaleSnapUnit2 = grid_scale.mV[VY];
 			break;
 		case VY:
 			// y axis facing being scaled, use x and z for snap guides
@@ -1532,10 +1530,10 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 			mScaleSnapUnit2 = grid_scale.mV[VX];
 			break;
 		default:
-			mSnapGuideDir1.zeroVec();
+			mSnapGuideDir1.setZero();
 			mScaleSnapUnit1 = 0.f;
 
-			mSnapGuideDir2.zeroVec();
+			mSnapGuideDir2.setZero();
 			mScaleSnapUnit2 = 0.f;
 			break;
 		}
@@ -1550,7 +1548,7 @@ void LLManipScale::updateSnapGuides(const LLBBox& bbox)
 	mScalePlaneNormal1.normalize();
 
 	mScalePlaneNormal2 = mSnapGuideDir2 % mScaleDir;
-	mScalePlaneNormal2.normalize();	
+	mScalePlaneNormal2.normalize();
 
 	mScaleSnapUnit1 = mScaleSnapUnit1 / (mSnapDir1 * mScaleDir);
 	mScaleSnapUnit2 = mScaleSnapUnit2 / (mSnapDir2 * mScaleDir);
@@ -1588,7 +1586,7 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 		LLVector3 line_mid = mScaleCenter + (mScaleSnappedValue * mScaleDir) + (mSnapGuideDir1 * mSnapRegimeOffset);
 		LLVector3 line_start = line_mid - (mScaleDir * (llmin(mScaleSnappedValue, mSnapGuideLength * 0.5f)));
 		LLVector3 line_end = line_mid + (mScaleDir * llmin(max_point_on_scale_line - mScaleSnappedValue, mSnapGuideLength * 0.5f));
-		
+
 		gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * 0.1f);
 		gGL.vertex3fv(line_start.mV);
 		gGL.color4fv(tick_color.mV);
@@ -1613,13 +1611,16 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 		LLGLDepthTest gls_depth(GL_FALSE);
 
 		F32 dist_grid_axis = llmax(0.f, (drag_point - mScaleCenter) * mScaleDir);
-
+		
 		F32 smallest_subdivision1 = mScaleSnapUnit1 / sGridMaxSubdivisionLevel;
 		F32 smallest_subdivision2 = mScaleSnapUnit2 / sGridMaxSubdivisionLevel;
-
+		
+		F32 dist_scale_units_1 = dist_grid_axis / smallest_subdivision1;
+		F32 dist_scale_units_2 = dist_grid_axis / smallest_subdivision2;
+		
 		// find distance to nearest smallest grid unit
-		F32 grid_multiple1 = llfloor(dist_grid_axis / smallest_subdivision1);
-		F32 grid_multiple2 = llfloor(dist_grid_axis / smallest_subdivision2);
+		F32 grid_multiple1 = llfloor(dist_scale_units_1);
+		F32 grid_multiple2 = llfloor(dist_scale_units_2);
 		F32 grid_offset1 = fmodf(dist_grid_axis, smallest_subdivision1);
 		F32 grid_offset2 = fmodf(dist_grid_axis, smallest_subdivision2);
 
@@ -1629,8 +1630,6 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 
 		S32 num_ticks_per_side1 = llmax(1, lltrunc(0.5f * mSnapGuideLength / smallest_subdivision1));
 		S32 num_ticks_per_side2 = llmax(1, lltrunc(0.5f * mSnapGuideLength / smallest_subdivision2));
-		F32 dist_scale_units_1 = dist_grid_axis / smallest_subdivision1;
-		F32 dist_scale_units_2 = dist_grid_axis / smallest_subdivision2;
 		S32 ticks_from_scale_center_1 = lltrunc(dist_scale_units_1);
 		S32 ticks_from_scale_center_2 = lltrunc(dist_scale_units_2);
 		S32 max_ticks1 = llceil(max_point_on_scale_line / smallest_subdivision1 - dist_scale_units_1);
@@ -1638,7 +1637,7 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 		S32 start_tick = 0;
 		S32 stop_tick = 0;
 
-		if (mInSnapRegime)
+		if (mSnapRegime != SNAP_REGIME_NONE)
 		{
 			// draw snap guide line
 			gGL.begin(LLRender::LINES);
@@ -1677,7 +1676,7 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 			}
 			gGL.end();
 		}
-	
+
 		LLVector2 screen_translate_axis(llabs(mScaleDir * LLViewerCamera::getInstance()->getLeftAxis()), llabs(mScaleDir * LLViewerCamera::getInstance()->getUpAxis()));
 		screen_translate_axis.normalize();
 
@@ -1791,12 +1790,13 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 				}
 				else
 				{
-					tick_value = (grid_multiple1 + i) / (2.f * max_subdivisions);
+					tick_value = (grid_multiple1 + i) / (2.f * sGridMaxSubdivisionLevel);
 				}
 
 				F32 text_highlight = 0.8f;
 
-				if (is_approx_equal(tick_value, mScaleSnappedValue) && mInSnapRegime)
+				// Highlight this text if the tick value matches the snapped to value, and if either the second set of ticks isn't going to be shown or cursor is in the first snap regime.
+				if (is_approx_equal(tick_value, mScaleSnappedValue) && (mScaleSnapUnit2 == mScaleSnapUnit1 || (mSnapRegime & SNAP_REGIME_UPPER)))
 				{
 					text_highlight = 1.f;
 				}
@@ -1840,10 +1840,9 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 						tick_value = (grid_multiple2 + i) / (2.f * sGridMaxSubdivisionLevel);
 					}
 
-
 					F32 text_highlight = 0.8f;
 
-					if (is_approx_equal(tick_value, mScaleSnappedValue) && mInSnapRegime)
+					if (is_approx_equal(tick_value, mScaleSnappedValue) && (mSnapRegime & SNAP_REGIME_LOWER))
 					{
 						text_highlight = 1.f;
 					}
@@ -1889,17 +1888,15 @@ void LLManipScale::renderSnapGuides(const LLBBox& bbox)
 // Returns unit vector in direction of part of an origin-centered cube
 LLVector3 LLManipScale::partToUnitVector( S32 part ) const
 {
-	if( (LL_FACE_MIN <= part) && (part <= LL_FACE_MAX) )
+	if ( (LL_FACE_MIN <= part) && (part <= LL_FACE_MAX) )
 	{
 		return faceToUnitVector( part );
 	}
-	else
-	if( (LL_CORNER_MIN <= part) && (part <= LL_CORNER_MAX) )
+	else if ( (LL_CORNER_MIN <= part) && (part <= LL_CORNER_MAX) )
 	{
 		return cornerToUnitVector( part );
 	}
-	else
-	if( (LL_EDGE_MIN <= part) && (part <= LL_EDGE_MAX ) )
+	else if ( (LL_EDGE_MIN <= part) && (part <= LL_EDGE_MAX ) )
 	{
 		return edgeToUnitVector( part );
 	}
@@ -1911,27 +1908,32 @@ LLVector3 LLManipScale::partToUnitVector( S32 part ) const
 LLVector3 LLManipScale::faceToUnitVector( S32 part ) const
 {
 	llassert( (LL_FACE_MIN <= part) && (part <= LL_FACE_MAX) );
+	LLVector3 vec;
 	switch( part )
 	{
 		case LL_FACE_POSX:
-			return LLVector3(  1.f,  0.f,  0.f );
-
+			vec.set(  1.f,  0.f,  0.f );
+			break;
 		case LL_FACE_NEGX:
-			return LLVector3( -1.f,  0.f,  0.f );
-
+			vec.set( -1.f,  0.f,  0.f );
+			break;
 		case LL_FACE_POSY:
-			return LLVector3(  0.f,  1.f,  0.f );
-
+			vec.set(  0.f,  1.f,  0.f );
+			break;
 		case LL_FACE_NEGY:
-			return LLVector3(  0.f, -1.f,  0.f );
-
+			vec.set(  0.f, -1.f,  0.f );
+			break;
 		case LL_FACE_POSZ:
-			return LLVector3(  0.f,  0.f,  1.f );
-
+			vec.set(  0.f,  0.f,  1.f );
+			break;
 		case LL_FACE_NEGZ:
-			return LLVector3(  0.f,  0.f, -1.f );
+			vec.set(  0.f,  0.f, -1.f );
+			break;
+		default:
+			vec.clear();
 	}
-	return LLVector3();
+
+	return vec;
 }
 
 
@@ -1943,31 +1945,31 @@ LLVector3 LLManipScale::cornerToUnitVector( S32 part ) const
 	switch(part)
 	{
 		case LL_CORNER_NNN:
-			vec.setVec(-OO_SQRT3, -OO_SQRT3, -OO_SQRT3);
+			vec.set(-OO_SQRT3, -OO_SQRT3, -OO_SQRT3);
 			break;
-		case LL_CORNER_NNP:		
-			vec.setVec(-OO_SQRT3, -OO_SQRT3, OO_SQRT3);
+		case LL_CORNER_NNP:
+			vec.set(-OO_SQRT3, -OO_SQRT3, OO_SQRT3);
 			break;
 		case LL_CORNER_NPN:
-			vec.setVec(-OO_SQRT3, OO_SQRT3, -OO_SQRT3);
+			vec.set(-OO_SQRT3, OO_SQRT3, -OO_SQRT3);
 			break;
 		case LL_CORNER_NPP:
-			vec.setVec(-OO_SQRT3, OO_SQRT3, OO_SQRT3);
+			vec.set(-OO_SQRT3, OO_SQRT3, OO_SQRT3);
 			break;
 		case LL_CORNER_PNN:
-			vec.setVec(OO_SQRT3, -OO_SQRT3, -OO_SQRT3);
+			vec.set(OO_SQRT3, -OO_SQRT3, -OO_SQRT3);
 			break;
 		case LL_CORNER_PNP:
-			vec.setVec(OO_SQRT3, -OO_SQRT3, OO_SQRT3);
+			vec.set(OO_SQRT3, -OO_SQRT3, OO_SQRT3);
 			break;
 		case LL_CORNER_PPN:
-			vec.setVec(OO_SQRT3, OO_SQRT3, -OO_SQRT3);
+			vec.set(OO_SQRT3, OO_SQRT3, -OO_SQRT3);
 			break;
 		case LL_CORNER_PPP:
-			vec.setVec(OO_SQRT3, OO_SQRT3, OO_SQRT3);
+			vec.set(OO_SQRT3, OO_SQRT3, OO_SQRT3);
 			break;
 		default:
-			vec.clearVec();
+			vec.clear();
 	}
 
 	return vec;
@@ -1994,8 +1996,8 @@ LLVector3 LLManipScale::unitVectorToLocalBBoxExtent( const LLVector3& v, const L
 	LLVector3 ctr = bbox.getCenterLocal();
 
 	return LLVector3(
-		v.mV[0] ? (v.mV[0]>0 ? max.mV[0] : min.mV[0] ) : ctr.mV[0], 
-		v.mV[1] ? (v.mV[1]>0 ? max.mV[1] : min.mV[1] ) : ctr.mV[1], 
+		v.mV[0] ? (v.mV[0]>0 ? max.mV[0] : min.mV[0] ) : ctr.mV[0],
+		v.mV[1] ? (v.mV[1]>0 ? max.mV[1] : min.mV[1] ) : ctr.mV[1],
 		v.mV[2] ? (v.mV[2]>0 ? max.mV[2] : min.mV[2] ) : ctr.mV[2] );
 }
 
@@ -2013,7 +2015,7 @@ F32		LLManipScale::partToMaxScale( S32 part, const LLBBox &bbox ) const
 			max_extent = bbox_extents.mV[i];
 		}
 	}
-	max_scale_factor = bbox_extents.magVec() * get_default_max_prim_scale() / max_extent;
+	max_scale_factor = bbox_extents.length() * get_default_max_prim_scale() / max_extent;
 
 	if (getUniform())
 	{
@@ -2036,7 +2038,7 @@ F32		LLManipScale::partToMinScale( S32 part, const LLBBox &bbox ) const
 			min_extent = bbox_extents.mV[i];
 		}
 	}
-	F32 min_scale_factor = bbox_extents.magVec() * MIN_PRIM_SCALE / min_extent;
+	F32 min_scale_factor = bbox_extents.length() * MIN_PRIM_SCALE / min_extent;
 
 	if (getUniform())
 	{
@@ -2087,7 +2089,7 @@ LLVector3 LLManipScale::nearestAxis( const LLVector3& v ) const
 // virtual
 BOOL LLManipScale::canAffectSelection()
 {
-	// An selection is scalable if you are allowed to both edit and move 
+	// An selection is scalable if you are allowed to both edit and move
 	// everything in it, and it does not have any sitting agents
 	BOOL can_scale = mObjectSelection->getObjectCount() != 0;
 	if (can_scale)
diff --git a/indra/newview/llmanipscale.h b/indra/newview/llmanipscale.h
index 2874c5dcd5..e1da7a1bb5 100755
--- a/indra/newview/llmanipscale.h
+++ b/indra/newview/llmanipscale.h
@@ -51,6 +51,13 @@ typedef	enum e_scale_manipulator_type
 	SCALE_MANIP_FACE
 } EScaleManipulatorType;
 
+typedef	enum e_snap_regimes
+{
+	SNAP_REGIME_NONE = 0, //!< The cursor is not in either of the snap regimes.
+	SNAP_REGIME_UPPER = 0x1, //!< The cursor is, non-exclusively, in the first of the snap regimes. Prefer to treat as bitmask.
+	SNAP_REGIME_LOWER = 0x2 //!< The cursor is, non-exclusively, in the second of the snap regimes. Prefer to treat as bitmask.
+} ESnapRegimes;
+
 
 class LLManipScale : public LLManip
 {
@@ -96,7 +103,7 @@ private:
 	void			renderSnapGuides( const LLBBox& local_bbox );
 
 	void			revert();
-	
+
 	inline void		conditionalHighlight( U32 part, const LLColor4* highlight = NULL, const LLColor4* normal = NULL );
 
 	void			drag( S32 x, S32 y );
@@ -135,35 +142,35 @@ private:
 	};
 
 
-	F32				mBoxHandleSize;		// The size of the handles at the corners of the bounding box
-	F32				mScaledBoxHandleSize; // handle size after scaling for selection feedback
+	F32				mBoxHandleSize; //!< The size of the handles at the corners of the bounding box.
+	F32				mScaledBoxHandleSize; //!< Handle size after scaling for selection feedback.
 	LLVector3d		mDragStartPointGlobal;
-	LLVector3d		mDragStartCenterGlobal;	// The center of the bounding box of all selected objects at time of drag start
+	LLVector3d		mDragStartCenterGlobal; //!< The center of the bounding box of all selected objects at time of drag start.
 	LLVector3d		mDragPointGlobal;
 	LLVector3d 		mDragFarHitGlobal;
 	S32				mLastMouseX;
 	S32				mLastMouseY;
 	BOOL			mSendUpdateOnMouseUp;
 	U32 			mLastUpdateFlags;
-	typedef std::set<ManipulatorHandle*, compare_manipulators> minpulator_list_t;
-	minpulator_list_t mProjectedManipulators;
+	typedef std::set<ManipulatorHandle*, compare_manipulators> manipulator_list_t;
+	manipulator_list_t mProjectedManipulators;
 	LLVector4		mManipulatorVertices[14];
-	F32				mScaleSnapUnit1;  //!< Size of snap multiples for axis 1.
-	F32				mScaleSnapUnit2;  //!< Size of snap multiples for axis 2.
+	F32				mScaleSnapUnit1; //!< Size of snap multiples for the upper scale.
+	F32				mScaleSnapUnit2; //!< Size of snap multiples for the lower scale.
 	LLVector3		mScalePlaneNormal1; //!< Normal of plane in which scale occurs that most faces camera.
 	LLVector3		mScalePlaneNormal2; //!< Normal of plane in which scale occurs that most faces camera.
-	LLVector3		mSnapGuideDir1;
-	LLVector3		mSnapGuideDir2;
-	LLVector3		mSnapDir1;
-	LLVector3		mSnapDir2;
-	F32				mSnapRegimeOffset;
-	F32				mTickPixelSpacing1;
-	F32				mTickPixelSpacing2;
+	LLVector3		mSnapGuideDir1; //!< The direction in which the upper snap guide tick marks face.
+	LLVector3		mSnapGuideDir2; //!< The direction in which the lower snap guide tick marks face.
+	LLVector3		mSnapDir1; //!< The direction in which the upper snap guides face.
+	LLVector3		mSnapDir2; //!< The direction in which the lower snap guides face.
+	F32				mSnapRegimeOffset; //!< How far off the scale axis centerline the mouse can be before it exits/enters the snap regime.
+	F32				mTickPixelSpacing1; //!< The pixel spacing between snap guide tick marks for the upper scale.
+	F32				mTickPixelSpacing2; //!< The pixel spacing between snap guide tick marks for the lower scale.
 	F32				mSnapGuideLength;
-	LLVector3		mScaleCenter;
+	LLVector3		mScaleCenter; //!< The location of the origin of the scaling operation.
 	LLVector3		mScaleDir; //!< The direction of the scaling action.  In face-dragging this is aligned with one of the cardinal axis relative to the prim, but in corner-dragging this is along the diagonal.
 	F32				mScaleSnappedValue; //!< The distance of the current position nearest the mouse location, measured along mScaleDir.  Is measured either from the center or from the far face/corner depending upon whether uniform scaling is true or false respectively.
-	BOOL			mInSnapRegime;
+	ESnapRegimes	mSnapRegime; //<! Which, if any, snap regime the cursor is currently residing in.
 	F32*			mManipulatorScales;
 };