summaryrefslogtreecommitdiff
path: root/indra
diff options
context:
space:
mode:
Diffstat (limited to 'indra')
-rwxr-xr-xindra/newview/llmanipscale.cpp254
-rwxr-xr-xindra/newview/llmanipscale.h41
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;
};
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-29 01:44:54 +0000