开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lltoolgrab.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：31k
源码类别：

游戏引擎

开发平台：

C++ Builder

lltoolgrab.cpp：源码内容
  1. /** 
  2.  * @file lltoolgrab.cpp
  3.  * @brief LLToolGrab class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "lltoolgrab.h"
  36.  
  37. // library headers
  38. #include "indra_constants.h" // for agent control flags
  39. #include "llviewercontrol.h"
  40. #include "llquaternion.h"
  41. #include "llbox.h"
  42. #include "message.h"
  43. #include "llview.h"
  44. #include "llfontgl.h"
  45. #include "llui.h"
  47. // newview headers
  48. #include "llagent.h"
  49. #include "lldrawable.h"
  50. #include "llfloatertools.h"
  51. #include "llhudeffect.h"
  52. #include "llhudmanager.h"
  53. #include "llregionposition.h"
  54. #include "llselectmgr.h"
  55. #include "llstatusbar.h"
  56. #include "lltoolmgr.h"
  57. #include "lltoolpie.h"
  58. #include "llviewercamera.h"
  59. #include "llviewerobject.h"
  60. #include "llviewerobjectlist.h" 
  61. #include "llviewerregion.h"
  62. #include "llviewerwindow.h"
  63. #include "llvoavatarself.h"
  64. #include "llworld.h"
  66. const S32 SLOP_DIST_SQ = 4;
  68. // Override modifier key behavior with these buttons
  69. BOOL gGrabBtnVertical = FALSE;
  70. BOOL gGrabBtnSpin = FALSE;
  71. LLTool* gGrabTransientTool = NULL;
  72. extern BOOL gDebugClicks;
  74. //
  75. // Methods
  76. //
  77. LLToolGrab::LLToolGrab( LLToolComposite* composite )
  78. : LLTool( std::string("Grab"), composite ),
  79. mMode( GRAB_INACTIVE ),
  80. mVerticalDragging( FALSE ),
  81. mHitLand(FALSE),
  82. mLastMouseX(0),
  83. mLastMouseY(0),
  84. mAccumDeltaX(0),
  85. mAccumDeltaY(0),
  86. mHasMoved( FALSE ),
  87. mOutsideSlop(FALSE),
  88. mDeselectedThisClick(FALSE),
  89. mLastFace(0),
  90. mSpinGrabbing( FALSE ),
  91. mSpinRotation(),
  92. mHideBuildHighlight(FALSE)
  93. { }
  95. LLToolGrab::~LLToolGrab()
  96. { }
  99. // virtual
  100. void LLToolGrab::handleSelect()
  101. {
  102. if(gFloaterTools)
  103. {
  104. // viewer can crash during startup if we don't check.
  105. gFloaterTools->setStatusText("grab");
  106. }
  107. gGrabBtnVertical = FALSE;
  108. gGrabBtnSpin = FALSE;
  109. }
  111. void LLToolGrab::handleDeselect()
  112. {
  113. if( hasMouseCapture() )
  114. {
  115. setMouseCapture( FALSE );
  116. }
  118. }
  120. BOOL LLToolGrab::handleDoubleClick(S32 x, S32 y, MASK mask)
  121. {
  122. if (gDebugClicks)
  123. {
  124. llinfos << "LLToolGrab handleDoubleClick (becoming mouseDown)" << llendl;
  125. }
  127. return FALSE;
  128. }
  130. BOOL LLToolGrab::handleMouseDown(S32 x, S32 y, MASK mask)
  131. {
  132. if (gDebugClicks)
  133. {
  134. llinfos << "LLToolGrab handleMouseDown" << llendl;
  135. }
  137. // call the base class to propogate info to sim
  138. LLTool::handleMouseDown(x, y, mask);
  140. if (!gAgent.leftButtonGrabbed())
  141. {
  142. // can grab transparent objects (how touch event propagates, scripters rely on this)
  143. gViewerWindow->pickAsync(x, y, mask, pickCallback, TRUE);
  144. }
  145. return TRUE;
  146. }
  148. void LLToolGrab::pickCallback(const LLPickInfo& pick_info)
  149. {
  150. LLToolGrab::getInstance()->mGrabPick = pick_info;
  151. LLViewerObject *objectp = pick_info.getObject();
  153. BOOL extend_select = (pick_info.mKeyMask & MASK_SHIFT);
  155. if (!extend_select && !LLSelectMgr::getInstance()->getSelection()->isEmpty())
  156. {
  157. LLSelectMgr::getInstance()->deselectAll();
  158. LLToolGrab::getInstance()->mDeselectedThisClick = TRUE;
  159. }
  160. else
  161. {
  162. LLToolGrab::getInstance()->mDeselectedThisClick = FALSE;
  163. }
  165. // if not over object, do nothing
  166. if (!objectp)
  167. {
  168. LLToolGrab::getInstance()->setMouseCapture(TRUE);
  169. LLToolGrab::getInstance()->mMode = GRAB_NOOBJECT;
  170. LLToolGrab::getInstance()->mGrabPick.mObjectID.setNull();
  171. }
  172. else
  173. {
  174. LLToolGrab::getInstance()->handleObjectHit(LLToolGrab::getInstance()->mGrabPick);
  175. }
  176. }
  178. BOOL LLToolGrab::handleObjectHit(const LLPickInfo& info)
  179. {
  180. mGrabPick = info;
  181. LLViewerObject* objectp = mGrabPick.getObject();
  183. if (gDebugClicks)
  184. {
  185. llinfos << "LLToolGrab handleObjectHit " << info.mMousePt.mX << "," << info.mMousePt.mY << llendl;
  186. }
  188. if (NULL == objectp) // unexpected
  189. {
  190. llwarns << "objectp was NULL; returning FALSE" << llendl;
  191. return FALSE;
  192. }
  194. if (objectp->isAvatar())
  195. {
  196. if (gGrabTransientTool)
  197. {
  198. gBasicToolset->selectTool( gGrabTransientTool );
  199. gGrabTransientTool = NULL;
  200. }
  201. return TRUE;
  202. }
  204. setMouseCapture( TRUE );
  206. // Grabs always start from the root
  207. // objectp = (LLViewerObject *)objectp->getRoot();
  209. LLViewerObject* parent = objectp->getRootEdit();
  210. BOOL script_touch = (objectp->flagHandleTouch()) || (parent && parent->flagHandleTouch());
  212. // Clicks on scripted or physical objects are temporary grabs, so
  213. // not "Build mode"
  214. mHideBuildHighlight = script_touch || objectp->usePhysics();
  216. if (!objectp->usePhysics())
  217. {
  218. if (script_touch)
  219. {
  220. mMode = GRAB_NONPHYSICAL;  // if it has a script, use the non-physical grab
  221. }
  222. else
  223. {
  224. // In mouselook, we shouldn't be able to grab non-physical, 
  225. // non-touchable objects.  If it has a touch handler, we
  226. // do grab it (so llDetectedGrab works), but movement is
  227. // blocked on the server side. JC
  228. if (gAgent.cameraMouselook())
  229. {
  230. mMode = GRAB_LOCKED;
  231. }
  232. else
  233. {
  234. mMode = GRAB_ACTIVE_CENTER;
  235. }
  237. gViewerWindow->hideCursor();
  238. gViewerWindow->moveCursorToCenter();
  240. }
  241. }
  242. else if( !objectp->permMove() )
  243. {
  244. // if mouse is over a physical object without move permission, show feedback if user tries to move it.
  245. mMode = GRAB_LOCKED;
  247. // Don't bail out here, go on and grab so buttons can get
  248. // their "touched" event.
  249. }
  250. else
  251. {
  252. // if mouse is over a physical object with move permission, 
  253. // select it and enter "grab" mode (hiding cursor, etc.)
  255. mMode = GRAB_ACTIVE_CENTER;
  257. gViewerWindow->hideCursor();
  258. gViewerWindow->moveCursorToCenter();
  259. }
  261. // Always send "touched" message
  263. mLastMouseX = gViewerWindow->getCurrentMouseX();
  264. mLastMouseY = gViewerWindow->getCurrentMouseY();
  265. mAccumDeltaX = 0;
  266. mAccumDeltaY = 0;
  267. mHasMoved = FALSE;
  268. mOutsideSlop = FALSE;
  270. mVerticalDragging = (info.mKeyMask == MASK_VERTICAL) || gGrabBtnVertical;
  272. startGrab();
  274. if ((info.mKeyMask == MASK_SPIN) || gGrabBtnSpin)
  275. {
  276. startSpin();
  277. }
  279. LLSelectMgr::getInstance()->updateSelectionCenter(); // update selection beam
  281. // update point at
  282. LLViewerObject *edit_object = info.getObject();
  283. if (edit_object && info.mPickType != LLPickInfo::PICK_FLORA)
  284. {
  285. LLVector3 local_edit_point = gAgent.getPosAgentFromGlobal(info.mPosGlobal);
  286. local_edit_point -= edit_object->getPositionAgent();
  287. local_edit_point = local_edit_point * ~edit_object->getRenderRotation();
  288. gAgent.setPointAt(POINTAT_TARGET_GRAB, edit_object, local_edit_point );
  289. gAgent.setLookAt(LOOKAT_TARGET_SELECT, edit_object, local_edit_point );
  290. }
  292. // on transient grabs (clicks on world objects), kill the grab immediately
  293. if (!gViewerWindow->getLeftMouseDown() 
  294. && gGrabTransientTool 
  295. && (mMode == GRAB_NONPHYSICAL || mMode == GRAB_LOCKED))
  296. {
  297. gBasicToolset->selectTool( gGrabTransientTool );
  298. gGrabTransientTool = NULL;
  299. }
  301. return TRUE;
  302. }
  305. void LLToolGrab::startSpin()
  306. {
  307. LLViewerObject* objectp = mGrabPick.getObject();
  308. if (!objectp)
  309. {
  310. return;
  311. }
  312. mSpinGrabbing = TRUE;
  314. // Was saveSelectedObjectTransform()
  315. LLViewerObject *root = (LLViewerObject *)objectp->getRoot();
  316. mSpinRotation = root->getRotation();
  318. LLMessageSystem *msg = gMessageSystem;
  319. msg->newMessageFast(_PREHASH_ObjectSpinStart);
  320. msg->nextBlockFast(_PREHASH_AgentData);
  321. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  322. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  323. msg->nextBlockFast(_PREHASH_ObjectData);
  324. msg->addUUIDFast(_PREHASH_ObjectID, mGrabPick.mObjectID );
  325. msg->sendMessage( objectp->getRegion()->getHost() );
  326. }
  329. void LLToolGrab::stopSpin()
  330. {
  331. mSpinGrabbing = FALSE;
  333. LLViewerObject* objectp = mGrabPick.getObject();
  334. if (!objectp)
  335. {
  336. return;
  337. }
  339. LLMessageSystem *msg = gMessageSystem;
  340. switch(mMode)
  341. {
  342. case GRAB_ACTIVE_CENTER:
  343. case GRAB_NONPHYSICAL:
  344. case GRAB_LOCKED:
  345. msg->newMessageFast(_PREHASH_ObjectSpinStop);
  346. msg->nextBlockFast(_PREHASH_AgentData);
  347. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  348. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  349. msg->nextBlockFast(_PREHASH_ObjectData);
  350. msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
  351. msg->sendMessage( objectp->getRegion()->getHost() );
  352. break;
  354. case GRAB_NOOBJECT:
  355. case GRAB_INACTIVE:
  356. default:
  357. // do nothing
  358. break;
  359. }
  360. }
  363. void LLToolGrab::startGrab()
  364. {
  365. // Compute grab_offset in the OBJECT's root's coordinate frame
  366. // (sometimes root == object)
  367. LLViewerObject* objectp = mGrabPick.getObject();
  368. if (!objectp)
  369. {
  370. return;
  371. }
  373. LLViewerObject *root = (LLViewerObject *)objectp->getRoot();
  375. // drag from center
  376. LLVector3d grab_start_global = root->getPositionGlobal();
  378. // Where the grab starts, relative to the center of the root object of the set.
  379. // JC - This code looks wonky, but I believe it does the right thing.
  380. // Otherwise, when you grab a linked object set, it "pops" on the start
  381. // of the drag.
  382. LLVector3d grab_offsetd = root->getPositionGlobal() - objectp->getPositionGlobal();
  384. LLVector3 grab_offset;
  385. grab_offset.setVec(grab_offsetd);
  387. LLQuaternion rotation = root->getRotation();
  388. rotation.conjQuat();
  389. grab_offset = grab_offset * rotation;
  391. // This planar drag starts at the grab point
  392. mDragStartPointGlobal = grab_start_global;
  393. mDragStartFromCamera = grab_start_global - gAgent.getCameraPositionGlobal();
  395. LLMessageSystem *msg = gMessageSystem;
  396. msg->newMessageFast(_PREHASH_ObjectGrab);
  397. msg->nextBlockFast(_PREHASH_AgentData);
  398. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  399. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  400. msg->nextBlockFast(_PREHASH_ObjectData);
  401. msg->addU32Fast(_PREHASH_LocalID, objectp->mLocalID);
  402. msg->addVector3Fast(_PREHASH_GrabOffset, grab_offset );
  403. msg->nextBlock("SurfaceInfo");
  404. msg->addVector3("UVCoord", LLVector3(mGrabPick.mUVCoords));
  405. msg->addVector3("STCoord", LLVector3(mGrabPick.mSTCoords));
  406. msg->addS32Fast(_PREHASH_FaceIndex, mGrabPick.mObjectFace);
  407. msg->addVector3("Position", mGrabPick.mIntersection);
  408. msg->addVector3("Normal", mGrabPick.mNormal);
  409. msg->addVector3("Binormal", mGrabPick.mBinormal);
  410. msg->sendMessage( objectp->getRegion()->getHost());
  412. mGrabOffsetFromCenterInitial = grab_offset;
  413. mGrabHiddenOffsetFromCamera = mDragStartFromCamera;
  415. mGrabTimer.reset();
  417. mLastUVCoords = mGrabPick.mUVCoords;
  418. mLastSTCoords = mGrabPick.mSTCoords;
  419. mLastFace = mGrabPick.mObjectFace;
  420. mLastIntersection = mGrabPick.mIntersection;
  421. mLastNormal = mGrabPick.mNormal;
  422. mLastBinormal = mGrabPick.mBinormal;
  423. mLastGrabPos = LLVector3(-1.f, -1.f, -1.f);
  424. }
  427. BOOL LLToolGrab::handleHover(S32 x, S32 y, MASK mask)
  428. {
  429. if (!gViewerWindow->getLeftMouseDown())
  430. {
  431. gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
  432. setMouseCapture(FALSE);
  433. return TRUE;
  434. }
  436. // Do the right hover based on mode
  437. switch( mMode )
  438. {
  439. case GRAB_ACTIVE_CENTER:
  440. handleHoverActive( x, y, mask ); // cursor hidden
  441. break;
  443. case GRAB_NONPHYSICAL:
  444. handleHoverNonPhysical(x, y, mask);
  445. break;
  447. case GRAB_INACTIVE:
  448. handleHoverInactive( x, y, mask );  // cursor set here
  449. break;
  451. case GRAB_NOOBJECT:
  452. case GRAB_LOCKED:
  453. handleHoverFailed( x, y, mask );
  454. break;
  456. }
  458. mLastMouseX = x;
  459. mLastMouseY = y;
  461. return TRUE;
  462. }
  464. const F32 GRAB_SENSITIVITY_X = 0.0075f;
  465. const F32 GRAB_SENSITIVITY_Y = 0.0075f;
  470. // Dragging.
  471. void LLToolGrab::handleHoverActive(S32 x, S32 y, MASK mask)
  472. {
  473. LLViewerObject* objectp = mGrabPick.getObject();
  474. if (!objectp || !hasMouseCapture() ) return;
  475. if (objectp->isDead())
  476. {
  477. // Bail out of drag because object has been killed
  478. setMouseCapture(FALSE);
  479. return;
  480. }
  482. //--------------------------------------------------
  483. // Toggle spinning
  484. //--------------------------------------------------
  485. if (mSpinGrabbing && !(mask == MASK_SPIN) && !gGrabBtnSpin)
  486. {
  487. // user released ALT key, stop spinning
  488. stopSpin();
  489. }
  490. else if (!mSpinGrabbing && (mask == MASK_SPIN) )
  491. {
  492. // user pressed ALT key, start spinning
  493. startSpin();
  494. }
  496. //--------------------------------------------------
  497. // Toggle vertical dragging
  498. //--------------------------------------------------
  499. if (mVerticalDragging && !(mask == MASK_VERTICAL) && !gGrabBtnVertical)
  500. {
  501. // ...switch to horizontal dragging
  502. mVerticalDragging = FALSE;
  504. mDragStartPointGlobal = gViewerWindow->clickPointInWorldGlobal(x, y, objectp);
  505. mDragStartFromCamera = mDragStartPointGlobal - gAgent.getCameraPositionGlobal();
  506. }
  507. else if (!mVerticalDragging && (mask == MASK_VERTICAL) )
  508. {
  509. // ...switch to vertical dragging
  510. mVerticalDragging = TRUE;
  512. mDragStartPointGlobal = gViewerWindow->clickPointInWorldGlobal(x, y, objectp);
  513. mDragStartFromCamera = mDragStartPointGlobal - gAgent.getCameraPositionGlobal();
  514. }
  516. const F32 RADIANS_PER_PIXEL_X = 0.01f;
  517. const F32 RADIANS_PER_PIXEL_Y = 0.01f;
  519. S32 dx = x - (gViewerWindow->getWorldViewWidthScaled() / 2);
  520. S32 dy = y - (gViewerWindow->getWorldViewHeightScaled() / 2);
  522. if (dx != 0 || dy != 0)
  523. {
  524. mAccumDeltaX += dx;
  525. mAccumDeltaY += dy;
  526. S32 dist_sq = mAccumDeltaX * mAccumDeltaX + mAccumDeltaY * mAccumDeltaY;
  527. if (dist_sq > SLOP_DIST_SQ)
  528. {
  529. mOutsideSlop = TRUE;
  530. }
  532. // mouse has moved outside center
  533. mHasMoved = TRUE;
  535. if (mSpinGrabbing)
  536. {
  537. //------------------------------------------------------
  538. // Handle spinning
  539. //------------------------------------------------------
  541. // x motion maps to rotation around vertical axis
  542. LLVector3 up(0.f, 0.f, 1.f);
  543. LLQuaternion rotation_around_vertical( dx*RADIANS_PER_PIXEL_X, up );
  545. // y motion maps to rotation around left axis
  546. const LLVector3 &agent_left = LLViewerCamera::getInstance()->getLeftAxis();
  547. LLQuaternion rotation_around_left( dy*RADIANS_PER_PIXEL_Y, agent_left );
  549. // compose with current rotation
  550. mSpinRotation = mSpinRotation * rotation_around_vertical;
  551. mSpinRotation = mSpinRotation * rotation_around_left;
  553. // TODO: Throttle these
  554. LLMessageSystem *msg = gMessageSystem;
  555. msg->newMessageFast(_PREHASH_ObjectSpinUpdate);
  556. msg->nextBlockFast(_PREHASH_AgentData);
  557. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
  558. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  559. msg->nextBlockFast(_PREHASH_ObjectData);
  560. msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
  561. msg->addQuatFast(_PREHASH_Rotation, mSpinRotation );
  562. msg->sendMessage( objectp->getRegion()->getHost() );
  563. }
  564. else
  565. {
  566. //------------------------------------------------------
  567. // Handle grabbing
  568. //------------------------------------------------------
  570. LLVector3d x_part;
  571. x_part.setVec(LLViewerCamera::getInstance()->getLeftAxis());
  572. x_part.mdV[VZ] = 0.0;
  573. x_part.normVec();
  575. LLVector3d y_part;
  576. if( mVerticalDragging )
  577. {
  578. y_part.setVec(LLViewerCamera::getInstance()->getUpAxis());
  579. // y_part.setVec(0.f, 0.f, 1.f);
  580. }
  581. else
  582. {
  583. // drag toward camera
  584. y_part = x_part % LLVector3d::z_axis;
  585. y_part.mdV[VZ] = 0.0;
  586. y_part.normVec();
  587. }
  589. mGrabHiddenOffsetFromCamera = mGrabHiddenOffsetFromCamera 
  590. + (x_part * (-dx * GRAB_SENSITIVITY_X)) 
  591. + (y_part * ( dy * GRAB_SENSITIVITY_Y));
  594. // Send the message to the viewer.
  595. F32 dt = mGrabTimer.getElapsedTimeAndResetF32();
  596. U32 dt_milliseconds = (U32) (1000.f * dt);
  598. // need to return offset from mGrabStartPoint
  599. LLVector3d grab_point_global;
  601. grab_point_global = gAgent.getCameraPositionGlobal() + mGrabHiddenOffsetFromCamera;
  603. /* Snap to grid disabled for grab tool - very confusing
  604. // Handle snapping to grid, but only when the tool is formally selected.
  605. BOOL snap_on = gSavedSettings.getBOOL("SnapEnabled");
  606. if (snap_on && !gGrabTransientTool)
  607. {
  608. F64 snap_size = gSavedSettings.getF32("GridResolution");
  609. U8 snap_dimensions = (mVerticalDragging ? 3 : 2);
  611. for (U8 i = 0; i < snap_dimensions; i++)
  612. {
  613. grab_point_global.mdV[i] += snap_size / 2;
  614. grab_point_global.mdV[i] -= fmod(grab_point_global.mdV[i], snap_size);
  615. }
  616. }
  617. */
  619. // Don't let object centers go underground.
  620. F32 land_height = LLWorld::getInstance()->resolveLandHeightGlobal(grab_point_global);
  622. if (grab_point_global.mdV[VZ] < land_height)
  623. {
  624. grab_point_global.mdV[VZ] = land_height;
  625. }
  627. // For safety, cap heights where objects can be dragged
  628. if (grab_point_global.mdV[VZ] > MAX_OBJECT_Z)
  629. {
  630. grab_point_global.mdV[VZ] = MAX_OBJECT_Z;
  631. }
  633. grab_point_global = LLWorld::getInstance()->clipToVisibleRegions(mDragStartPointGlobal, grab_point_global);
  634. // propagate constrained grab point back to grab offset
  635. mGrabHiddenOffsetFromCamera = grab_point_global - gAgent.getCameraPositionGlobal();
  637. // Handle auto-rotation at screen edge.
  638. LLVector3 grab_pos_agent = gAgent.getPosAgentFromGlobal( grab_point_global );
  640. LLCoordGL grab_center_gl( gViewerWindow->getWorldViewWidthScaled() / 2, gViewerWindow->getWorldViewHeightScaled() / 2);
  641. LLViewerCamera::getInstance()->projectPosAgentToScreen(grab_pos_agent, grab_center_gl);
  643. const S32 ROTATE_H_MARGIN = gViewerWindow->getWorldViewWidthScaled() / 20;
  644. const F32 ROTATE_ANGLE_PER_SECOND = 30.f * DEG_TO_RAD;
  645. const F32 rotate_angle = ROTATE_ANGLE_PER_SECOND / gFPSClamped;
  646. // ...build mode moves camera about focus point
  647. if (grab_center_gl.mX < ROTATE_H_MARGIN)
  648. {
  649. if (gAgent.getFocusOnAvatar())
  650. {
  651. gAgent.yaw(rotate_angle);
  652. }
  653. else
  654. {
  655. gAgent.cameraOrbitAround(rotate_angle);
  656. }
  657. }
  658. else if (grab_center_gl.mX > gViewerWindow->getWorldViewWidthScaled() - ROTATE_H_MARGIN)
  659. {
  660. if (gAgent.getFocusOnAvatar())
  661. {
  662. gAgent.yaw(-rotate_angle);
  663. }
  664. else
  665. {
  666. gAgent.cameraOrbitAround(-rotate_angle);
  667. }
  668. }
  670. // Don't move above top of screen or below bottom
  671. if ((grab_center_gl.mY < gViewerWindow->getWorldViewHeightScaled() - 6)
  672. && (grab_center_gl.mY > 24))
  673. {
  674. // Transmit update to simulator
  675. LLVector3 grab_pos_region = objectp->getRegion()->getPosRegionFromGlobal( grab_point_global );
  677. LLMessageSystem *msg = gMessageSystem;
  678. msg->newMessageFast(_PREHASH_ObjectGrabUpdate);
  679. msg->nextBlockFast(_PREHASH_AgentData);
  680. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  681. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  682. msg->nextBlockFast(_PREHASH_ObjectData);
  683. msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
  684. msg->addVector3Fast(_PREHASH_GrabOffsetInitial, mGrabOffsetFromCenterInitial );
  685. msg->addVector3Fast(_PREHASH_GrabPosition, grab_pos_region );
  686. msg->addU32Fast(_PREHASH_TimeSinceLast, dt_milliseconds );
  687. msg->nextBlock("SurfaceInfo");
  688. msg->addVector3("UVCoord", LLVector3(mGrabPick.mUVCoords));
  689. msg->addVector3("STCoord", LLVector3(mGrabPick.mSTCoords));
  690. msg->addS32Fast(_PREHASH_FaceIndex, mGrabPick.mObjectFace);
  691. msg->addVector3("Position", mGrabPick.mIntersection);
  692. msg->addVector3("Normal", mGrabPick.mNormal);
  693. msg->addVector3("Binormal", mGrabPick.mBinormal);
  695. msg->sendMessage( objectp->getRegion()->getHost() );
  696. }
  697. }
  699. gViewerWindow->moveCursorToCenter();
  701. LLSelectMgr::getInstance()->updateSelectionCenter();
  703. }
  705. // once we've initiated a drag, lock the camera down
  706. if (mHasMoved)
  707. {
  708. if (!gAgent.cameraMouselook() && 
  709. !objectp->isHUDAttachment() && 
  710. objectp->getRoot() == gAgent.getAvatarObject()->getRoot())
  711. {
  712. // force focus to point in space where we were looking previously
  713. gAgent.setFocusGlobal(gAgent.calcFocusPositionTargetGlobal(), LLUUID::null);
  714. gAgent.setFocusOnAvatar(FALSE, ANIMATE);
  715. }
  716. else
  717. {
  718. gAgent.clearFocusObject();
  719. }
  720. }
  722. // 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.
  723. gViewerWindow->setCursor(UI_CURSOR_ARROW);  
  725. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (active) [cursor hidden]" << llendl;
  726. }
  727.  
  729. void LLToolGrab::handleHoverNonPhysical(S32 x, S32 y, MASK mask)
  730. {
  731. LLViewerObject* objectp = mGrabPick.getObject();
  732. if (!objectp || !hasMouseCapture() ) return;
  733. if (objectp->isDead())
  734. {
  735. // Bail out of drag because object has been killed
  736. setMouseCapture(FALSE);
  737. return;
  738. }
  740. LLPickInfo pick = mGrabPick;
  741. pick.mMousePt = LLCoordGL(x, y);
  742. pick.getSurfaceInfo();
  744. // compute elapsed time
  745. F32 dt = mGrabTimer.getElapsedTimeAndResetF32();
  746. U32 dt_milliseconds = (U32) (1000.f * dt);
  748. // i'm not a big fan of the following code - it's been culled from the physical grab case.
  749. // ideally these two would be nicely integrated - but the code in that method is a serious
  750. // mess of spaghetti.  so here we go:
  752. LLVector3 grab_pos_region(0,0,0);
  754. const BOOL SUPPORT_LLDETECTED_GRAB = TRUE;
  755. if (SUPPORT_LLDETECTED_GRAB)
  756. {
  757. //--------------------------------------------------
  758. // Toggle vertical dragging
  759. //--------------------------------------------------
  760. if (mVerticalDragging && !(mask == MASK_VERTICAL) && !gGrabBtnVertical)
  761. {
  762. mVerticalDragging = FALSE;
  763. }
  765. else if (!mVerticalDragging && (mask == MASK_VERTICAL) )
  766. {
  767. mVerticalDragging = TRUE;
  768. }
  770. S32 dx = x - mLastMouseX;
  771. S32 dy = y - mLastMouseY;
  773. if (dx != 0 || dy != 0)
  774. {
  775. mAccumDeltaX += dx;
  776. mAccumDeltaY += dy;
  778. S32 dist_sq = mAccumDeltaX * mAccumDeltaX + mAccumDeltaY * mAccumDeltaY;
  779. if (dist_sq > SLOP_DIST_SQ)
  780. {
  781. mOutsideSlop = TRUE;
  782. }
  784. // mouse has moved 
  785. mHasMoved = TRUE;
  787. //------------------------------------------------------
  788. // Handle grabbing
  789. //------------------------------------------------------
  791. LLVector3d x_part;
  792. x_part.setVec(LLViewerCamera::getInstance()->getLeftAxis());
  793. x_part.mdV[VZ] = 0.0;
  794. x_part.normVec();
  796. LLVector3d y_part;
  797. if( mVerticalDragging )
  798. {
  799. y_part.setVec(LLViewerCamera::getInstance()->getUpAxis());
  800. // y_part.setVec(0.f, 0.f, 1.f);
  801. }
  802. else
  803. {
  804. // drag toward camera
  805. y_part = x_part % LLVector3d::z_axis;
  806. y_part.mdV[VZ] = 0.0;
  807. y_part.normVec();
  808. }
  810. mGrabHiddenOffsetFromCamera = mGrabHiddenOffsetFromCamera 
  811. + (x_part * (-dx * GRAB_SENSITIVITY_X)) 
  812. + (y_part * ( dy * GRAB_SENSITIVITY_Y));
  814. }
  816. // need to return offset from mGrabStartPoint
  817. LLVector3d grab_point_global = gAgent.getCameraPositionGlobal() + mGrabHiddenOffsetFromCamera;
  818. grab_pos_region = objectp->getRegion()->getPosRegionFromGlobal( grab_point_global );
  819. }
  822. // only send message if something has changed since last message
  824. BOOL changed_since_last_update = FALSE;
  826. // test if touch data needs to be updated
  827. if ((pick.mObjectFace != mLastFace) ||
  828. (pick.mUVCoords != mLastUVCoords) ||
  829. (pick.mSTCoords != mLastSTCoords) ||
  830. (pick.mIntersection != mLastIntersection) ||
  831. (pick.mNormal != mLastNormal) ||
  832. (pick.mBinormal != mLastBinormal) ||
  833. (grab_pos_region != mLastGrabPos))
  834. {
  835. changed_since_last_update = TRUE;
  836. }
  838. if (changed_since_last_update)
  839. {
  840. LLMessageSystem *msg = gMessageSystem;
  841. msg->newMessageFast(_PREHASH_ObjectGrabUpdate);
  842. msg->nextBlockFast(_PREHASH_AgentData);
  843. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  844. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  845. msg->nextBlockFast(_PREHASH_ObjectData);
  846. msg->addUUIDFast(_PREHASH_ObjectID, objectp->getID() );
  847. msg->addVector3Fast(_PREHASH_GrabOffsetInitial, mGrabOffsetFromCenterInitial );
  848. msg->addVector3Fast(_PREHASH_GrabPosition, grab_pos_region );
  849. msg->addU32Fast(_PREHASH_TimeSinceLast, dt_milliseconds );
  850. msg->nextBlock("SurfaceInfo");
  851. msg->addVector3("UVCoord", LLVector3(pick.mUVCoords));
  852. msg->addVector3("STCoord", LLVector3(pick.mSTCoords));
  853. msg->addS32Fast(_PREHASH_FaceIndex, pick.mObjectFace);
  854. msg->addVector3("Position", pick.mIntersection);
  855. msg->addVector3("Normal", pick.mNormal);
  856. msg->addVector3("Binormal", pick.mBinormal);
  858. msg->sendMessage( objectp->getRegion()->getHost() );
  860. mLastUVCoords = pick.mUVCoords;
  861. mLastSTCoords = pick.mSTCoords;
  862. mLastFace = pick.mObjectFace;
  863. mLastIntersection = pick.mIntersection;
  864. mLastNormal= pick.mNormal;
  865. mLastBinormal= pick.mBinormal;
  866. mLastGrabPos = grab_pos_region;
  867. }
  869. // update point-at / look-at
  870. if (pick.mObjectFace != -1) // if the intersection was on the surface of the obejct
  871. {
  872. LLVector3 local_edit_point = pick.mIntersection;
  873. local_edit_point -= objectp->getPositionAgent();
  874. local_edit_point = local_edit_point * ~objectp->getRenderRotation();
  875. gAgent.setPointAt(POINTAT_TARGET_GRAB, objectp, local_edit_point );
  876. gAgent.setLookAt(LOOKAT_TARGET_SELECT, objectp, local_edit_point );
  877. }
  881. gViewerWindow->setCursor(UI_CURSOR_HAND);  
  882. }
  883.  
  885. // Not dragging.  Just showing affordances
  886. void LLToolGrab::handleHoverInactive(S32 x, S32 y, MASK mask)
  887. {
  888. const F32 ROTATE_ANGLE_PER_SECOND = 40.f * DEG_TO_RAD;
  889. const F32 rotate_angle = ROTATE_ANGLE_PER_SECOND / gFPSClamped;
  891. // Look for cursor against the edge of the screen
  892. // Only works in fullscreen
  893. if (gSavedSettings.getBOOL("WindowFullScreen"))
  894. {
  895. if (gAgent.cameraThirdPerson() )
  896. {
  897. if (x == 0)
  898. {
  899. gAgent.yaw(rotate_angle);
  900. //gAgent.setControlFlags(AGENT_CONTROL_YAW_POS);
  901. }
  902. else if (x == (gViewerWindow->getWorldViewWidthScaled() - 1) )
  903. {
  904. gAgent.yaw(-rotate_angle);
  905. //gAgent.setControlFlags(AGENT_CONTROL_YAW_NEG);
  906. }
  907. }
  908. }
  910. // JC - TODO - change cursor based on gGrabBtnVertical, gGrabBtnSpin
  911. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (inactive-not over editable object)" << llendl;
  912. gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
  913. }
  915. // User is trying to do something that's not allowed.
  916. void LLToolGrab::handleHoverFailed(S32 x, S32 y, MASK mask)
  917. {
  918. if( GRAB_NOOBJECT == mMode )
  919. {
  920. gViewerWindow->setCursor(UI_CURSOR_NO);
  921. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (not on object)" << llendl;
  922. }
  923. else
  924. {
  925. S32 dist_sq = (x-mGrabPick.mMousePt.mX) * (x-mGrabPick.mMousePt.mX) + (y-mGrabPick.mMousePt.mY) * (y-mGrabPick.mMousePt.mY);
  926. if( mOutsideSlop || dist_sq > SLOP_DIST_SQ )
  927. {
  928. mOutsideSlop = TRUE;
  930. switch( mMode )
  931. {
  932. case GRAB_LOCKED:
  933. gViewerWindow->setCursor(UI_CURSOR_GRABLOCKED);
  934. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (grab failed, no move permission)" << llendl;
  935. break;
  937. //  Non physical now handled by handleHoverActive - CRO
  938. // case GRAB_NONPHYSICAL:
  939. // gViewerWindow->setCursor(UI_CURSOR_ARROW);
  940. // lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (grab failed, nonphysical)" << llendl;
  941. // break;
  942. default:
  943. llassert(0);
  944. }
  945. }
  946. else
  947. {
  948. gViewerWindow->setCursor(UI_CURSOR_ARROW);
  949. lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolGrab (grab failed but within slop)" << llendl;
  950. }
  951. }
  952. }
  957. BOOL LLToolGrab::handleMouseUp(S32 x, S32 y, MASK mask)
  958. {
  959. // call the base class to propogate info to sim
  960. LLTool::handleMouseUp(x, y, mask);
  962. if( hasMouseCapture() )
  963. {
  964. setMouseCapture( FALSE );
  965. }
  966. mMode = GRAB_INACTIVE;
  968. // HACK: Make some grabs temporary
  969. if (gGrabTransientTool)
  970. {
  971. gBasicToolset->selectTool( gGrabTransientTool );
  972. gGrabTransientTool = NULL;
  973. }
  975. //gAgent.setObjectTracking(gSavedSettings.getBOOL("TrackFocusObject"));
  977. return TRUE;
  978. } 
  980. void LLToolGrab::stopEditing()
  981. {
  982. if( hasMouseCapture() )
  983. {
  984. setMouseCapture( FALSE );
  985. }
  986. }
  988. void LLToolGrab::onMouseCaptureLost()
  989. {
  990. LLViewerObject* objectp = mGrabPick.getObject();
  991. if (!objectp)
  992. {
  993. gViewerWindow->showCursor();
  994. return;
  995. }
  996. // First, fix cursor placement
  997. if( !gAgent.cameraMouselook() 
  998. && (GRAB_ACTIVE_CENTER == mMode))
  999. {
  1000. if (objectp->isHUDAttachment())
  1001. {
  1002. // ...move cursor "naturally", as if it had moved when hidden
  1003. S32 x = mGrabPick.mMousePt.mX + mAccumDeltaX;
  1004. S32 y = mGrabPick.mMousePt.mY + mAccumDeltaY;
  1005. LLUI::setMousePositionScreen(x, y);
  1006. }
  1007. else if (mHasMoved)
  1008. {
  1009. // ...move cursor back to the center of the object
  1010. LLVector3 grab_point_agent = objectp->getRenderPosition();
  1012. LLCoordGL gl_point;
  1013. if (LLViewerCamera::getInstance()->projectPosAgentToScreen(grab_point_agent, gl_point))
  1014. {
  1015. LLUI::setMousePositionScreen(gl_point.mX, gl_point.mY);
  1016. }
  1017. }
  1018. else
  1019. {
  1020. // ...move cursor back to click position
  1021. LLUI::setMousePositionScreen(mGrabPick.mMousePt.mX, mGrabPick.mMousePt.mY);
  1022. }
  1024. gViewerWindow->showCursor();
  1025. }
  1027. stopGrab();
  1028. if (mSpinGrabbing)
  1029. stopSpin();
  1031. mMode = GRAB_INACTIVE;
  1033. mHideBuildHighlight = FALSE;
  1035. mGrabPick.mObjectID.setNull();
  1037. LLSelectMgr::getInstance()->updateSelectionCenter();
  1038. gAgent.setPointAt(POINTAT_TARGET_CLEAR);
  1039. gAgent.setLookAt(LOOKAT_TARGET_CLEAR);
  1041. dialog_refresh_all();
  1042. }
  1045. void LLToolGrab::stopGrab()
  1046. {
  1047. LLViewerObject* objectp = mGrabPick.getObject();
  1048. if (!objectp)
  1049. {
  1050. return;
  1051. }
  1053. LLPickInfo pick = mGrabPick;
  1055. if (mMode == GRAB_NONPHYSICAL)
  1056. {
  1057. // for non-physical (touch) grabs,
  1058. // gather surface info for this degrab (mouse-up)
  1059. S32 x = gViewerWindow->getCurrentMouseX();
  1060. S32 y = gViewerWindow->getCurrentMouseY();
  1061. pick.mMousePt = LLCoordGL(x, y);
  1062. pick.getSurfaceInfo();
  1063. }
  1065. // Next, send messages to simulator
  1066. LLMessageSystem *msg = gMessageSystem;
  1067. switch(mMode)
  1068. {
  1069. case GRAB_ACTIVE_CENTER:
  1070. case GRAB_NONPHYSICAL:
  1071. case GRAB_LOCKED:
  1072. msg->newMessageFast(_PREHASH_ObjectDeGrab);
  1073. msg->nextBlockFast(_PREHASH_AgentData);
  1074. msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
  1075. msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
  1076. msg->nextBlockFast(_PREHASH_ObjectData);
  1077. msg->addU32Fast(_PREHASH_LocalID, objectp->mLocalID);
  1078. msg->nextBlock("SurfaceInfo");
  1079. msg->addVector3("UVCoord", LLVector3(pick.mUVCoords));
  1080. msg->addVector3("STCoord", LLVector3(pick.mSTCoords));
  1081. msg->addS32Fast(_PREHASH_FaceIndex, pick.mObjectFace);
  1082. msg->addVector3("Position", pick.mIntersection);
  1083. msg->addVector3("Normal", pick.mNormal);
  1084. msg->addVector3("Binormal", pick.mBinormal);
  1086. msg->sendMessage(objectp->getRegion()->getHost());
  1088. mVerticalDragging = FALSE;
  1089. break;
  1091. case GRAB_NOOBJECT:
  1092. case GRAB_INACTIVE:
  1093. default:
  1094. // do nothing
  1095. break;
  1096. }
  1098. mHideBuildHighlight = FALSE;
  1099. }
  1102. void LLToolGrab::draw()
  1103. { }
  1105. void LLToolGrab::render()
  1106. { }
  1108. BOOL LLToolGrab::isEditing()
  1109. {
  1110. return (mGrabPick.getObject().notNull());
  1111. }
  1113. LLViewerObject* LLToolGrab::getEditingObject()
  1114. {
  1115. return mGrabPick.getObject();
  1116. }
  1119. LLVector3d LLToolGrab::getEditingPointGlobal()
  1120. {
  1121. return getGrabPointGlobal();
  1122. }
  1124. LLVector3d LLToolGrab::getGrabPointGlobal()
  1125. {
  1126. switch(mMode)
  1127. {
  1128. case GRAB_ACTIVE_CENTER:
  1129. case GRAB_NONPHYSICAL:
  1130. case GRAB_LOCKED:
  1131. return gAgent.getCameraPositionGlobal() + mGrabHiddenOffsetFromCamera;
  1133. case GRAB_NOOBJECT:
  1134. case GRAB_INACTIVE:
  1135. default:
  1136. return gAgent.getPositionGlobal();
  1137. }
  1138. }