// virtual
void LLToolObjPicker::handleDeselect()
{
if (hasMouseCapture())
{
LLTool::handleDeselect();
setMouseCapture(FALSE);
}
}
void LLToolGrab::handleDeselect()
{
if( hasMouseCapture() )
{
setMouseCapture( FALSE );
}
}
BOOL LLPathfindingPathTool::handleRightMouseDown(S32 pX, S32 pY, MASK pMask)
{
setMouseCapture(TRUE);
mIsRightMouseButtonHeld = true;
gViewerWindow->setCursor(UI_CURSOR_TOOLNO);
return TRUE;
}
BOOL LLToolPipette::handleMouseDown(S32 x, S32 y, MASK mask)
{
mSuccess = TRUE;
mTooltipMsg.clear();
setMouseCapture(TRUE);
gViewerWindow->pickAsync(x, y, mask, pickCallback);
return TRUE;
}
void LLToolCompGun::handleDeselect()
{
LLToolComposite::handleDeselect();
if (mTimerFOV.getStarted()) // <singu/> Note: Load Default FOV if we were zooming in
{
LLViewerCamera::getInstance()->loadDefaultFOV();
}
setMouseCapture(FALSE);
}
void LLToolPie::handleDeselect()
{
if( hasMouseCapture() )
{
setMouseCapture( FALSE ); // Calls onMouseCaptureLost() indirectly
}
// remove temporary selection for pie menu
LLSelectMgr::getInstance()->validateSelection();
}
BOOL LLToolPipette::handleMouseUp(S32 x, S32 y, MASK mask)
{
mSuccess = TRUE;
LLSelectMgr::getInstance()->unhighlightAll();
// *NOTE: This assumes the pipette tool is a transient tool.
LLToolMgr::getInstance()->clearTransientTool();
setMouseCapture(FALSE);
return TRUE;
}
BOOL LLPathfindingPathTool::handleRightMouseUp(S32 pX, S32 pY, MASK pMask)
{
if (!mIsLeftMouseButtonHeld && !mIsMiddleMouseButtonHeld && mIsRightMouseButtonHeld)
{
setMouseCapture(FALSE);
}
mIsRightMouseButtonHeld = false;
return TRUE;
}
BOOL LLManip::handleMouseUp(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
if( hasMouseCapture() )
{
handled = TRUE;
setMouseCapture( FALSE );
}
return handled;
}
bool LLToolPie::handleMediaClick(const LLPickInfo& pick)
{
//FIXME: how do we handle object in different parcel than us?
LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
LLPointer<LLViewerObject> objectp = pick.getObject();
if (!parcel ||
objectp.isNull() ||
pick.mObjectFace < 0 ||
pick.mObjectFace >= objectp->getNumTEs())
{
LLViewerMediaFocus::getInstance()->clearFocus();
return false;
}
// Does this face have media?
const LLTextureEntry* tep = objectp->getTE(pick.mObjectFace);
if(!tep)
return false;
LLMediaEntry* mep = (tep->hasMedia()) ? tep->getMediaData() : NULL;
if(!mep)
return false;
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mep->getMediaID());
if (gSavedSettings.getBOOL("MediaOnAPrimUI"))
{
if (!LLViewerMediaFocus::getInstance()->isFocusedOnFace(pick.getObject(), pick.mObjectFace) || media_impl.isNull())
{
// It's okay to give this a null impl
LLViewerMediaFocus::getInstance()->setFocusFace(pick.getObject(), pick.mObjectFace, media_impl, pick.mNormal);
}
else
{
// Make sure keyboard focus is set to the media focus object.
gFocusMgr.setKeyboardFocus(LLViewerMediaFocus::getInstance());
media_impl->mouseDown(pick.mUVCoords, gKeyboard->currentMask(TRUE));
mMediaMouseCaptureID = mep->getMediaID();
setMouseCapture(TRUE); // This object will send a mouse-up to the media when it loses capture.
}
return true;
}
LLViewerMediaFocus::getInstance()->clearFocus();
return false;
}
BOOL LLPathfindingPathTool::handleMouseUp(S32 pX, S32 pY, MASK pMask)
{
BOOL returnVal = FALSE;
if (mIsLeftMouseButtonHeld && !mIsMiddleMouseButtonHeld && !mIsRightMouseButtonHeld)
{
computeFinalPoints(pX, pY, pMask);
setMouseCapture(FALSE);
returnVal = TRUE;
}
mIsLeftMouseButtonHeld = false;
return returnVal;
}
void LLToolSelectRect::handlePick(const LLPickInfo& pick)
{
mPick = pick;
// start dragging rectangle
setMouseCapture( TRUE );
mDragStartX = pick.mMousePt.mX;
mDragStartY = pick.mMousePt.mY;
mDragEndX = pick.mMousePt.mX;
mDragEndY = pick.mMousePt.mY;
mMouseOutsideSlop = FALSE;
}
BOOL LLToolSelectRect::handleMouseDown(S32 x, S32 y, MASK mask)
{
// start dragging rectangle
setMouseCapture( TRUE );
mDragStartX = x;
mDragStartY = y;
mDragEndX = x;
mDragEndY = y;
mMouseOutsideSlop = FALSE;
LLToolSelect::handleMouseDown(x, y, mask);
return TRUE;
}
BOOL LLToolBrushLand::handleMouseUp(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
mLastAffectedRegions.clear();
if( hasMouseCapture() )
{
// Release the mouse
setMouseCapture( FALSE );
LLViewerParcelMgr::getInstance()->setSelectionVisible(TRUE);
gIdleCallbacks.deleteFunction( &LLToolBrushLand::onIdle, (void*)this );
handled = TRUE;
}
return handled;
}
BOOL LLToolCamera::handleMouseUp(S32 x, S32 y, MASK mask)
{
// Claim that we're mousing up somewhere
mMouseUpX = x;
mMouseUpY = y;
mMouseUpMask = mask;
if (hasMouseCapture())
{
if (mValidClickPoint)
{
if( CAMERA_MODE_CUSTOMIZE_AVATAR == gAgent.getCameraMode() )
{
LLCoordGL mouse_pos;
LLVector3 focus_pos = gAgent.getPosAgentFromGlobal(gAgent.getFocusGlobal());
BOOL success = LLViewerCamera::getInstance()->projectPosAgentToScreen(focus_pos, mouse_pos);
if (success)
{
LLUI::setCursorPositionScreen(mouse_pos.mX, mouse_pos.mY);
}
}
else if (mMouseSteering)
{
LLUI::setCursorPositionScreen(mMouseDownX, mMouseDownY);
}
else
{
gViewerWindow->moveCursorToCenter();
}
}
else
{
// not a valid zoomable object
LLUI::setCursorPositionScreen(mMouseDownX, mMouseDownY);
}
// calls releaseMouse() internally
setMouseCapture(FALSE);
}
else
{
releaseMouse();
}
return TRUE;
}
BOOL LLToolObjPicker::handleMouseUp(S32 x, S32 y, MASK mask)
{
LLView* viewp = gViewerWindow->getRootView();
BOOL handled = viewp->handleHover(x, y, mask);
if (handled)
{
// let UI handle this
}
LLTool::handleMouseUp(x, y, mask);
if (hasMouseCapture())
{
setMouseCapture(FALSE);
}
else
{
llwarns << "PickerTool doesn't have mouse capture on mouseUp" << llendl;
}
return handled;
}
BOOL LLManip::handleHover(S32 x, S32 y, MASK mask)
{
// We only handle the event if mousedown started with us
if( hasMouseCapture() )
{
if( mObjectSelection->isEmpty() )
{
// Somehow the object got deselected while we were dragging it.
// Release the mouse
setMouseCapture( FALSE );
}
LL_DEBUGS("UserInput") << "hover handled by LLManip (active)" << LL_ENDL;
}
else
{
LL_DEBUGS("UserInput") << "hover handled by LLManip (inactive)" << LL_ENDL;
}
gViewerWindow->setCursor(UI_CURSOR_ARROW);
return TRUE;
}
BOOL LLManip::handleHover(S32 x, S32 y, MASK mask)
{
// We only handle the event if mousedown started with us
if( hasMouseCapture() )
{
if( mObjectSelection->isEmpty() )
{
// Somehow the object got deselected while we were dragging it.
// Release the mouse
setMouseCapture( FALSE );
}
lldebugst(LLERR_USER_INPUT) << "hover handled by LLManip (active)" << llendl;
}
else
{
lldebugst(LLERR_USER_INPUT) << "hover handled by LLManip (inactive)" << llendl;
}
gViewerWindow->setCursor(UI_CURSOR_ARROW);
return TRUE;
}
bool LLToolPie::handleMediaMouseUp()
{
bool result = false;
if(mMediaMouseCaptureID.notNull())
{
// Face media needs to know the mouse went up.
viewer_media_t media_impl = LLViewerMedia::getMediaImplFromTextureID(mMediaMouseCaptureID);
if(media_impl)
{
// This will send a mouseUp event to the plugin using the last known mouse coordinate (from a mouseDown or mouseMove), which is what we want.
media_impl->onMouseCaptureLost();
}
mMediaMouseCaptureID.setNull();
setMouseCapture(FALSE);
result = true;
}
return result;
}
BOOL LLToolGrab::handleMouseUp(S32 x, S32 y, MASK mask)
{
// call the base class to propogate info to sim
LLTool::handleMouseUp(x, y, mask);
if( hasMouseCapture() )
{
setMouseCapture( FALSE );
}
mMode = GRAB_INACTIVE;
// HACK: Make some grabs temporary
if (gGrabTransientTool)
{
gBasicToolset->selectTool( gGrabTransientTool );
gGrabTransientTool = NULL;
}
//gAgent.setObjectTracking(gSavedSettings.getBOOL("TrackFocusObject"));
return TRUE;
}
void LLFocusMgr::releaseFocusIfNeeded( LLView* view )
{
if( childHasMouseCapture( view ) )
{
setMouseCapture( NULL );
}
if( childHasKeyboardFocus( view ))
{
if (view == mLockedView)
{
mLockedView = NULL;
setKeyboardFocus( NULL );
}
else
{
setKeyboardFocus( mLockedView );
}
}
LLUI::removePopup(view);
}
BOOL LLToolBrushLand::handleMouseDown(S32 x, S32 y, MASK mask)
{
BOOL handled = FALSE;
// Find the z value of the initial click.
LLVector3d spot;
if( gViewerWindow->mousePointOnLandGlobal( x, y, &spot ) )
{
// Round to nearest X,Y grid
spot.mdV[VX] = floor( spot.mdV[VX] + 0.5 );
spot.mdV[VY] = floor( spot.mdV[VY] + 0.5 );
LLRegionPosition region_position( spot );
LLViewerRegion* regionp = region_position.getRegion();
if (!canTerraform(regionp))
{
alertNoTerraform(regionp);
return TRUE;
}
LLVector3 pos_region = region_position.getPositionRegion();
U32 grids = regionp->getLand().mGridsPerEdge;
S32 i = llclamp( (S32)pos_region.mV[VX], 0, (S32)grids );
S32 j = llclamp( (S32)pos_region.mV[VY], 0, (S32)grids );
mStartingZ = regionp->getLand().getZ(i+j*grids);
mMouseX = x;
mMouseY = y;
gIdleCallbacks.addFunction( &LLToolBrushLand::onIdle, (void*)this );
setMouseCapture( TRUE );
LLViewerParcelMgr::getInstance()->setSelectionVisible(FALSE);
handled = TRUE;
}
return handled;
}
BOOL LLToolGrab::handleHover(S32 x, S32 y, MASK mask)
{
if (!gViewerWindow->getLeftMouseDown())
{
gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
setMouseCapture(FALSE);
return TRUE;
}
// Do the right hover based on mode
switch( mMode )
{
case GRAB_ACTIVE_CENTER:
handleHoverActive( x, y, mask ); // cursor hidden
break;
case GRAB_NONPHYSICAL:
handleHoverNonPhysical(x, y, mask);
break;
case GRAB_INACTIVE:
handleHoverInactive( x, y, mask ); // cursor set here
break;
case GRAB_NOOBJECT:
case GRAB_LOCKED:
handleHoverFailed( x, y, mask );
break;
}
mLastMouseX = x;
mLastMouseY = y;
return TRUE;
}
// Dragging.
void LLToolGrab::handleHoverActive(S32 x, S32 y, MASK mask)
{
LLViewerObject* objectp = mGrabPick.getObject();
if (!objectp || !hasMouseCapture() ) return;
if (objectp->isDead())
{
// Bail out of drag because object has been killed
setMouseCapture(FALSE);
return;
}
//--------------------------------------------------
// Toggle spinning
//--------------------------------------------------
if (mSpinGrabbing && !(mask == MASK_SPIN) && !gGrabBtnSpin)
{
// user released ALT key, stop spinning
stopSpin();
}
else if (!mSpinGrabbing && (mask == MASK_SPIN) )
{
// user pressed ALT key, start spinning
startSpin();
}
//--------------------------------------------------
// Toggle vertical dragging
//--------------------------------------------------
if (mVerticalDragging && !(mask == MASK_VERTICAL) && !gGrabBtnVertical)
{
// ...switch to horizontal dragging
mVerticalDragging = FALSE;
mDragStartPointGlobal = gViewerWindow->clickPointInWorldGlobal(x, y, objectp);
mDragStartFromCamera = mDragStartPointGlobal - gAgent.getCameraPositionGlobal();
}
else if (!mVerticalDragging && (mask == MASK_VERTICAL) )
{
// ...switch to vertical dragging
mVerticalDragging = TRUE;
mDragStartPointGlobal = gViewerWindow->clickPointInWorldGlobal(x, y, objectp);
mDragStartFromCamera = mDragStartPointGlobal - gAgent.getCameraPositionGlobal();
}
const F32 RADIANS_PER_PIXEL_X = 0.01f;
const F32 RADIANS_PER_PIXEL_Y = 0.01f;
S32 dx = x - (gViewerWindow->getWindowWidth() / 2);
S32 dy = y - (gViewerWindow->getWindowHeight() / 2);
if (dx != 0 || dy != 0)
{
mAccumDeltaX += dx;
mAccumDeltaY += dy;
S32 dist_sq = mAccumDeltaX * mAccumDeltaX + mAccumDeltaY * mAccumDeltaY;
if (dist_sq > SLOP_DIST_SQ)
{
mOutsideSlop = TRUE;
}
// mouse has moved outside center
mHasMoved = TRUE;
if (mSpinGrabbing)
{
//------------------------------------------------------
// Handle spinning
//------------------------------------------------------
// x motion maps to rotation around vertical axis
LLVector3 up(0.f, 0.f, 1.f);
LLQuaternion rotation_around_vertical( dx*RADIANS_PER_PIXEL_X, up );
// y motion maps to rotation around left axis
const LLVector3 &agent_left = LLViewerCamera::getInstance()->getLeftAxis();
LLQuaternion rotation_around_left( dy*RADIANS_PER_PIXEL_Y, agent_left );
// compose with current rotation
mSpinRotation = mSpinRotation * rotation_around_vertical;
mSpinRotation = mSpinRotation * rotation_around_left;
// TODO: Throttle these
LLMessageSystem *msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectSpinUpdate);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
msg->addQuatFast(_PREHASH_Rotation, mSpinRotation );
msg->sendMessage( objectp->getRegion()->getHost() );
}
else
{
//------------------------------------------------------
// Handle grabbing
//------------------------------------------------------
LLVector3d x_part;
x_part.setVec(LLViewerCamera::getInstance()->getLeftAxis());
x_part.mdV[VZ] = 0.0;
x_part.normVec();
LLVector3d y_part;
if( mVerticalDragging )
{
y_part.setVec(LLViewerCamera::getInstance()->getUpAxis());
// y_part.setVec(0.f, 0.f, 1.f);
}
else
{
// drag toward camera
y_part = x_part % LLVector3d::z_axis;
y_part.mdV[VZ] = 0.0;
y_part.normVec();
}
mGrabHiddenOffsetFromCamera = mGrabHiddenOffsetFromCamera
+ (x_part * (-dx * GRAB_SENSITIVITY_X))
+ (y_part * ( dy * GRAB_SENSITIVITY_Y));
// Send the message to the viewer.
F32 dt = mGrabTimer.getElapsedTimeAndResetF32();
U32 dt_milliseconds = (U32) (1000.f * dt);
// need to return offset from mGrabStartPoint
LLVector3d grab_point_global;
grab_point_global = gAgent.getCameraPositionGlobal() + mGrabHiddenOffsetFromCamera;
/* Snap to grid disabled for grab tool - very confusing
// Handle snapping to grid, but only when the tool is formally selected.
BOOL snap_on = gSavedSettings.getBOOL("SnapEnabled");
if (snap_on && !gGrabTransientTool)
{
F64 snap_size = gSavedSettings.getF32("GridResolution");
U8 snap_dimensions = (mVerticalDragging ? 3 : 2);
for (U8 i = 0; i < snap_dimensions; i++)
{
grab_point_global.mdV[i] += snap_size / 2;
grab_point_global.mdV[i] -= fmod(grab_point_global.mdV[i], snap_size);
}
}
*/
// Don't let object centers go underground.
F32 land_height = LLWorld::getInstance()->resolveLandHeightGlobal(grab_point_global);
if (grab_point_global.mdV[VZ] < land_height)
{
grab_point_global.mdV[VZ] = land_height;
}
// For safety, cap heights where objects can be dragged
if (grab_point_global.mdV[VZ] > MAX_OBJECT_Z)
{
grab_point_global.mdV[VZ] = MAX_OBJECT_Z;
}
grab_point_global = LLWorld::getInstance()->clipToVisibleRegions(mDragStartPointGlobal, grab_point_global);
// propagate constrained grab point back to grab offset
mGrabHiddenOffsetFromCamera = grab_point_global - gAgent.getCameraPositionGlobal();
// Handle auto-rotation at screen edge.
LLVector3 grab_pos_agent = gAgent.getPosAgentFromGlobal( grab_point_global );
LLCoordGL grab_center_gl( gViewerWindow->getWindowWidth() / 2, gViewerWindow->getWindowHeight() / 2);
LLViewerCamera::getInstance()->projectPosAgentToScreen(grab_pos_agent, grab_center_gl);
const S32 ROTATE_H_MARGIN = gViewerWindow->getWindowWidth() / 20;
const F32 ROTATE_ANGLE_PER_SECOND = 30.f * DEG_TO_RAD;
const F32 rotate_angle = ROTATE_ANGLE_PER_SECOND / gFPSClamped;
// ...build mode moves camera about focus point
if (grab_center_gl.mX < ROTATE_H_MARGIN)
{
if (gAgent.getFocusOnAvatar())
{
gAgent.yaw(rotate_angle);
}
else
{
gAgent.cameraOrbitAround(rotate_angle);
}
}
else if (grab_center_gl.mX > gViewerWindow->getWindowWidth() - ROTATE_H_MARGIN)
{
if (gAgent.getFocusOnAvatar())
{
gAgent.yaw(-rotate_angle);
}
else
{
gAgent.cameraOrbitAround(-rotate_angle);
}
}
// Don't move above top of screen or below bottom
if ((grab_center_gl.mY < gViewerWindow->getWindowHeight() - 6)
&& (grab_center_gl.mY > 24))
{
// Transmit update to simulator
LLVector3 grab_pos_region = objectp->getRegion()->getPosRegionFromGlobal( grab_point_global );
LLMessageSystem *msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectGrabUpdate);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
msg->addVector3Fast(_PREHASH_GrabOffsetInitial, mGrabOffsetFromCenterInitial );
msg->addVector3Fast(_PREHASH_GrabPosition, grab_pos_region );
msg->addU32Fast(_PREHASH_TimeSinceLast, dt_milliseconds );
msg->nextBlock("SurfaceInfo");
msg->addVector3("UVCoord", LLVector3(mGrabPick.mUVCoords));
msg->addVector3("STCoord", LLVector3(mGrabPick.mSTCoords));
msg->addS32Fast(_PREHASH_FaceIndex, mGrabPick.mObjectFace);
msg->addVector3("Position", mGrabPick.mIntersection);
msg->addVector3("Normal", mGrabPick.mNormal);
msg->addVector3("Binormal", mGrabPick.mBinormal);
msg->sendMessage( objectp->getRegion()->getHost() );
}
}
gViewerWindow->moveCursorToCenter();
LLSelectMgr::getInstance()->updateSelectionCenter();
}
// once we've initiated a drag, lock the camera down
if (mHasMoved)
{
if (!gAgent.cameraMouselook() &&
!objectp->isHUDAttachment() &&
objectp->getRoot() == gAgent.getAvatarObject()->getRoot())
{
// force focus to point in space where we were looking previously
gAgent.setFocusGlobal(gAgent.calcFocusPositionTargetGlobal(), LLUUID::null);
gAgent.setFocusOnAvatar(FALSE, ANIMATE);
}
else
{
gAgent.clearFocusObject();
}
}
// HACK to avoid assert: error checking system makes sure that the cursor is set during every handleHover. This is actually a no-op since the cursor is hidden.
gViewerWindow->setCursor(UI_CURSOR_ARROW);
lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (active) [cursor hidden]" << llendl;
}
BOOL LLToolGrab::handleObjectHit(const LLPickInfo& info)
{
mGrabPick = info;
LLViewerObject* objectp = mGrabPick.getObject();
if (gDebugClicks)
{
llinfos << "LLToolGrab handleObjectHit " << info.mMousePt.mX << "," << info.mMousePt.mY << llendl;
}
if (NULL == objectp) // unexpected
{
llwarns << "objectp was NULL; returning FALSE" << llendl;
return FALSE;
}
//if (objectp->isAvatar())
// [RLVa:KB] - Checked: 2009-07-10 (RLVa-1.0.0g) | Modified: RLVa-0.2.0f
if ( (objectp->isAvatar()) ||
( (gRlvHandler.hasBehaviour(RLV_BHVR_FARTOUCH)) && ((!objectp->isAttachment()) || (!objectp->permYouOwner())) &&
(dist_vec_squared(gAgent.getPositionAgent(), mGrabPick.mIntersection) > 1.5f * 1.5f) ) )
// [/RLVa:KB]
{
if (gGrabTransientTool)
{
gBasicToolset->selectTool( gGrabTransientTool );
gGrabTransientTool = NULL;
}
return TRUE;
}
setMouseCapture( TRUE );
// Grabs always start from the root
// objectp = (LLViewerObject *)objectp->getRoot();
LLViewerObject* parent = objectp->getRootEdit();
BOOL script_touch = (objectp->flagHandleTouch()) || (parent && parent->flagHandleTouch());
// Clicks on scripted or physical objects are temporary grabs, so
// not "Build mode"
mHideBuildHighlight = script_touch || objectp->usePhysics();
if (!objectp->usePhysics())
{
// In mouselook, we shouldn't be able to grab non-physical,
// non-touchable objects. If it has a touch handler, we
// do grab it (so llDetectedGrab works), but movement is
// blocked on the server side. JC
if (gAgent.cameraMouselook() && !script_touch)
{
mMode = GRAB_LOCKED;
gViewerWindow->hideCursor();
gViewerWindow->moveCursorToCenter();
}
else
{
mMode = GRAB_NONPHYSICAL;
}
// Don't bail out here, go on and grab so buttons can get
// their "touched" event.
}
else if( !objectp->permMove() )
{
// if mouse is over a physical object without move permission, show feedback if user tries to move it.
mMode = GRAB_LOCKED;
// Don't bail out here, go on and grab so buttons can get
// their "touched" event.
}
else
{
// if mouse is over a physical object with move permission,
// select it and enter "grab" mode (hiding cursor, etc.)
mMode = GRAB_ACTIVE_CENTER;
gViewerWindow->hideCursor();
gViewerWindow->moveCursorToCenter();
}
// Always send "touched" message
mLastMouseX = gViewerWindow->getCurrentMouseX();
mLastMouseY = gViewerWindow->getCurrentMouseY();
mAccumDeltaX = 0;
mAccumDeltaY = 0;
mHasMoved = FALSE;
mOutsideSlop = FALSE;
mVerticalDragging = (info.mKeyMask == MASK_VERTICAL) || gGrabBtnVertical;
startGrab();
if ((info.mKeyMask == MASK_SPIN) || gGrabBtnSpin)
{
startSpin();
}
LLSelectMgr::getInstance()->updateSelectionCenter(); // update selection beam
// update point at
LLViewerObject *edit_object = info.getObject();
if (edit_object && info.mPickType != LLPickInfo::PICK_FLORA)
{
LLVector3 local_edit_point = gAgent.getPosAgentFromGlobal(info.mPosGlobal);
local_edit_point -= edit_object->getPositionAgent();
local_edit_point = local_edit_point * ~edit_object->getRenderRotation();
gAgent.setPointAt(POINTAT_TARGET_GRAB, edit_object, local_edit_point );
gAgent.setLookAt(LOOKAT_TARGET_SELECT, edit_object, local_edit_point );
}
// on transient grabs (clicks on world objects), kill the grab immediately
if (!gViewerWindow->getLeftMouseDown()
&& gGrabTransientTool
&& (mMode == GRAB_NONPHYSICAL || mMode == GRAB_LOCKED))
{
gBasicToolset->selectTool( gGrabTransientTool );
gGrabTransientTool = NULL;
}
return TRUE;
}
void LLToolCompGun::handleSelect()
{
LLToolComposite::handleSelect();
setMouseCapture(TRUE);
}
void LLToolGrab::handleHoverNonPhysical(S32 x, S32 y, MASK mask)
{
LLViewerObject* objectp = mGrabPick.getObject();
if (!objectp || !hasMouseCapture() ) return;
if (objectp->isDead())
{
// Bail out of drag because object has been killed
setMouseCapture(FALSE);
return;
}
LLPickInfo pick = mGrabPick;
pick.mMousePt = LLCoordGL(x, y);
pick.getSurfaceInfo();
// compute elapsed time
F32 dt = mGrabTimer.getElapsedTimeAndResetF32();
U32 dt_milliseconds = (U32) (1000.f * dt);
// i'm not a big fan of the following code - it's been culled from the physical grab case.
// ideally these two would be nicely integrated - but the code in that method is a serious
// mess of spaghetti. so here we go:
LLVector3 grab_pos_region(0,0,0);
const BOOL SUPPORT_LLDETECTED_GRAB = TRUE;
if (SUPPORT_LLDETECTED_GRAB)
{
//--------------------------------------------------
// Toggle vertical dragging
//--------------------------------------------------
if (mVerticalDragging && !(mask == MASK_VERTICAL) && !gGrabBtnVertical)
{
mVerticalDragging = FALSE;
}
else if (!mVerticalDragging && (mask == MASK_VERTICAL) )
{
mVerticalDragging = TRUE;
}
S32 dx = x - mLastMouseX;
S32 dy = y - mLastMouseY;
if (dx != 0 || dy != 0)
{
mAccumDeltaX += dx;
mAccumDeltaY += dy;
S32 dist_sq = mAccumDeltaX * mAccumDeltaX + mAccumDeltaY * mAccumDeltaY;
if (dist_sq > SLOP_DIST_SQ)
{
mOutsideSlop = TRUE;
}
// mouse has moved
mHasMoved = TRUE;
//------------------------------------------------------
// Handle grabbing
//------------------------------------------------------
LLVector3d x_part;
x_part.setVec(LLViewerCamera::getInstance()->getLeftAxis());
x_part.mdV[VZ] = 0.0;
x_part.normVec();
LLVector3d y_part;
if( mVerticalDragging )
{
y_part.setVec(LLViewerCamera::getInstance()->getUpAxis());
// y_part.setVec(0.f, 0.f, 1.f);
}
else
{
// drag toward camera
y_part = x_part % LLVector3d::z_axis;
y_part.mdV[VZ] = 0.0;
y_part.normVec();
}
mGrabHiddenOffsetFromCamera = mGrabHiddenOffsetFromCamera
+ (x_part * (-dx * GRAB_SENSITIVITY_X))
+ (y_part * ( dy * GRAB_SENSITIVITY_Y));
}
// need to return offset from mGrabStartPoint
LLVector3d grab_point_global = gAgent.getCameraPositionGlobal() + mGrabHiddenOffsetFromCamera;
grab_pos_region = objectp->getRegion()->getPosRegionFromGlobal( grab_point_global );
}
LLMessageSystem *msg = gMessageSystem;
msg->newMessageFast(_PREHASH_ObjectGrabUpdate);
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_ObjectData);
msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
msg->addVector3Fast(_PREHASH_GrabOffsetInitial, mGrabOffsetFromCenterInitial );
msg->addVector3Fast(_PREHASH_GrabPosition, grab_pos_region );
msg->addU32Fast(_PREHASH_TimeSinceLast, dt_milliseconds );
msg->nextBlock("SurfaceInfo");
msg->addVector3("UVCoord", LLVector3(pick.mUVCoords));
msg->addVector3("STCoord", LLVector3(pick.mSTCoords));
msg->addS32Fast(_PREHASH_FaceIndex, pick.mObjectFace);
msg->addVector3("Position", pick.mIntersection);
msg->addVector3("Normal", pick.mNormal);
msg->addVector3("Binormal", pick.mBinormal);
msg->sendMessage( objectp->getRegion()->getHost() );
// update point-at / look-at
if (pick.mObjectFace != -1) // if the intersection was on the surface of the obejct
{
LLVector3 local_edit_point = pick.mIntersection;
local_edit_point -= objectp->getPositionAgent();
local_edit_point = local_edit_point * ~objectp->getRenderRotation();
gAgent.setPointAt(POINTAT_TARGET_GRAB, objectp, local_edit_point );
gAgent.setLookAt(LOOKAT_TARGET_SELECT, objectp, local_edit_point );
}
gViewerWindow->setCursor(UI_CURSOR_HAND);
}
void LLToolCompGun::handleDeselect()
{
LLToolComposite::handleDeselect();
setMouseCapture(FALSE);
}
// virtual
void LLToolObjPicker::handleSelect()
{
LLTool::handleSelect();
setMouseCapture(TRUE);
}