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

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

游戏引擎

开发平台：

C++ Builder

llmaniptranslate.cpp：源码内容
  1. /** 
  2.  * @file llmaniptranslate.cpp
  3.  * @brief LLManipTranslate class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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. /**
  34.  * Positioning tool
  35.  */
  37. #include "llviewerprecompiledheaders.h"
  39. #include "llmaniptranslate.h"
  41. #include "llgl.h"
  42. #include "llrender.h"
  44. #include "llagent.h"
  45. #include "llbbox.h"
  46. #include "llbox.h"
  47. #include "llviewercontrol.h"
  48. #include "llcriticaldamp.h"
  49. #include "llcylinder.h"
  50. #include "lldrawable.h"
  51. #include "llfloatertools.h"
  52. #include "llfontgl.h"
  53. #include "llglheaders.h"
  54. #include "llhudrender.h"
  55. #include "llresmgr.h"
  56. #include "llselectmgr.h"
  57. #include "llrendersphere.h"
  58. #include "llstatusbar.h"
  59. #include "lltoolmgr.h"
  60. #include "llviewercamera.h"
  61. #include "llviewerjoint.h"
  62. #include "llviewerobject.h"
  63. #include "llviewerwindow.h"
  64. #include "llvoavatarself.h"
  65. #include "llworld.h"
  66. #include "llui.h"
  67. #include "pipeline.h"
  69. const S32 NUM_AXES = 3;
  70. const S32 MOUSE_DRAG_SLOP = 2;       // pixels
  71. const F32 HANDLE_HIDE_ANGLE = 0.15f; // radians
  72. const F32 SELECTED_ARROW_SCALE = 1.3f;
  73. const F32 MANIPULATOR_HOTSPOT_START = 0.2f;
  74. const F32 MANIPULATOR_HOTSPOT_END = 1.2f;
  75. const F32 SNAP_GUIDE_SCREEN_SIZE = 0.7f;
  76. const F32 MIN_PLANE_MANIP_DOT_PRODUCT = 0.25f;
  77. const F32 PLANE_TICK_SIZE = 0.4f;
  78. const F32 MANIPULATOR_SCALE_HALF_LIFE = 0.07f;
  79. const F32 SNAP_ARROW_SCALE = 0.7f;
  81. static LLPointer<LLViewerTexture> sGridTex = NULL ;
  83. const LLManip::EManipPart MANIPULATOR_IDS[9] = 
  84. {
  85. LLManip::LL_X_ARROW,
  86. LLManip::LL_Y_ARROW,
  87. LLManip::LL_Z_ARROW,
  88. LLManip::LL_X_ARROW,
  89. LLManip::LL_Y_ARROW,
  90. LLManip::LL_Z_ARROW,
  91. LLManip::LL_YZ_PLANE,
  92. LLManip::LL_XZ_PLANE,
  93. LLManip::LL_XY_PLANE
  94. };
  96. const U32 ARROW_TO_AXIS[4] = 
  97. {
  98. VX,
  99. VX,
  100. VY,
  101. VZ
  102. };
  104. // Sort manipulator handles by their screen-space projection
  105. struct ClosestToCamera
  106. {
  107. bool operator()(const LLManipTranslate::ManipulatorHandle& a,
  108. const LLManipTranslate::ManipulatorHandle& b) const
  109. {
  110. return a.mEndPosition.mV[VZ] < b.mEndPosition.mV[VZ];
  111. }
  112. };
  114. LLManipTranslate::LLManipTranslate( LLToolComposite* composite )
  115. : LLManip( std::string("Move"), composite ),
  116. mLastHoverMouseX(-1),
  117. mLastHoverMouseY(-1),
  118. mSendUpdateOnMouseUp(FALSE),
  119. mMouseOutsideSlop(FALSE),
  120. mCopyMadeThisDrag(FALSE),
  121. mMouseDownX(-1),
  122. mMouseDownY(-1),
  123. mAxisArrowLength(50),
  124. mConeSize(0),
  125. mArrowLengthMeters(0.f),
  126. mGridSizeMeters(1.f),
  127. mPlaneManipOffsetMeters(0.f),
  128. mUpdateTimer(),
  129. mSnapOffsetMeters(0.f),
  130. mSubdivisions(10.f),
  131. mInSnapRegime(FALSE),
  132. mSnapped(FALSE),
  133. mArrowScales(1.f, 1.f, 1.f),
  134. mPlaneScales(1.f, 1.f, 1.f),
  135. mPlaneManipPositions(1.f, 1.f, 1.f, 1.f)
  136. { 
  137. if (sGridTex.isNull())
  138. { 
  139. restoreGL();
  140. }
  141. }
  143. //static
  144. U32 LLManipTranslate::getGridTexName()
  145. {
  146. if(sGridTex.isNull())
  147. {
  148. restoreGL() ;
  149. }
  151. return sGridTex.isNull() ? 0 : sGridTex->getTexName() ;
  152. }
  154. //static
  155. void LLManipTranslate::destroyGL()
  156. {
  157. if (sGridTex)
  158. {
  159. sGridTex = NULL ;
  160. }
  161. }
  163. //static
  164. void LLManipTranslate::restoreGL()
  165. {
  166. //generate grid texture
  167. U32 rez = 512;
  168. U32 mip = 0;
  170. destroyGL() ;
  171. sGridTex = LLViewerTextureManager::getLocalTexture() ;
  172. if(!sGridTex->createGLTexture())
  173. {
  174. sGridTex = NULL ;
  175. return ;
  176. }
  178. GLuint* d = new GLuint[rez*rez];
  180. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, sGridTex->getTexName(), true);
  181. gGL.getTexUnit(0)->setTextureFilteringOption(LLTexUnit::TFO_TRILINEAR);
  183. while (rez >= 1)
  184. {
  185. for (U32 i = 0; i < rez*rez; i++)
  186. {
  187. d[i] = 0x00FFFFFF;
  188. }
  190. U32 subcol = 0xFFFFFFFF;
  191. if (rez >= 4)
  192. { //large grain grid
  193. for (U32 i = 0; i < rez; i++)
  194. {
  195. if (rez <= 16)
  196. {
  197. if (rez == 16)
  198. {
  199. subcol = 0xA0FFFFFF;
  200. }
  201. else if (rez == 8)
  202. {
  203. subcol = 0x80FFFFFF;
  204. }
  205. else
  206. {
  207. subcol = 0x40FFFFFF;
  208. }
  209. }
  210. else
  211. {
  212. subcol = 0xFFFFFFFF;
  213. }
  214. d[i *rez+ 0  ] = subcol;
  215. d[0 *rez+ i  ] = subcol;
  216. if (rez >= 32)
  217. {
  218. d[i *rez+ (rez-1)] = subcol;
  219. d[(rez-1) *rez+ i  ] = subcol;
  220. }
  222. if (rez >= 64)
  223. {
  224. subcol = 0xFFFFFFFF;
  226. if (i > 0 && i < (rez-1))
  227. {
  228. d[i *rez+ 1  ] = subcol;
  229. d[i *rez+ (rez-2)] = subcol;
  230. d[1 *rez+ i  ] = subcol;
  231. d[(rez-2) *rez+ i  ] = subcol;
  232. }
  233. }
  234. }
  235. }
  237. subcol = 0x50A0A0A0;
  238. if (rez >= 128)
  239. { //small grain grid
  240. for (U32 i = 8; i < rez; i+=8)
  241. {
  242. for (U32 j = 2; j < rez-2; j++)
  243. {
  244. d[i *rez+ j] = subcol;
  245. d[j *rez+ i] = subcol;
  246. }
  247. }
  248. }
  249. if (rez >= 64)
  250. { //medium grain grid
  251. if (rez == 64)
  252. {
  253. subcol = 0x50A0A0A0;
  254. }
  255. else
  256. {
  257. subcol = 0xA0D0D0D0;
  258. }
  260. for (U32 i = 32; i < rez; i+=32)
  261. {
  262. U32 pi = i-1;
  263. for (U32 j = 2; j < rez-2; j++)
  264. {
  265. d[i *rez+ j] = subcol;
  266. d[j *rez+ i] = subcol;
  268. if (rez > 128)
  269. {
  270. d[pi *rez+ j] = subcol;
  271. d[j *rez+ pi] = subcol;
  272. }
  273. }
  274. }
  275. }
  276. #ifdef LL_WINDOWS
  277. LLImageGL::setManualImage(GL_TEXTURE_2D, mip, GL_RGBA, rez, rez, GL_RGBA, GL_UNSIGNED_BYTE, d);
  278. #else
  279. LLImageGL::setManualImage(GL_TEXTURE_2D, mip, GL_RGBA, rez, rez, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, d);
  280. #endif
  281. rez = rez >> 1;
  282. mip++;
  283. }
  284. delete [] d;
  285. }
  288. LLManipTranslate::~LLManipTranslate()
  289. {
  290. }
  293. void LLManipTranslate::handleSelect()
  294. {
  295. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK);
  296. gFloaterTools->setStatusText("move");
  297. LLManip::handleSelect();
  298. }
  300. BOOL LLManipTranslate::handleMouseDown(S32 x, S32 y, MASK mask)
  301. {
  302. BOOL handled = FALSE;
  304. // didn't click in any UI object, so must have clicked in the world
  305. if( (mHighlightedPart == LL_X_ARROW ||
  306.  mHighlightedPart == LL_Y_ARROW ||
  307.  mHighlightedPart == LL_Z_ARROW ||
  308.  mHighlightedPart == LL_YZ_PLANE ||
  309.  mHighlightedPart == LL_XZ_PLANE ||
  310.  mHighlightedPart == LL_XY_PLANE ) )
  311. {
  312. handled = handleMouseDownOnPart( x, y, mask );
  313. }
  315. return handled;
  316. }
  318. // Assumes that one of the arrows on an object was hit.
  319. BOOL LLManipTranslate::handleMouseDownOnPart( S32 x, S32 y, MASK mask )
  320. {
  321. BOOL can_move = canAffectSelection();
  322. if (!can_move)
  323. {
  324. return FALSE;
  325. }
  327. highlightManipulators(x, y);
  328. S32 hit_part = mHighlightedPart;
  330. if( (hit_part != LL_X_ARROW) && 
  331. (hit_part != LL_Y_ARROW) &&
  332. (hit_part != LL_Z_ARROW) &&
  333. (hit_part != LL_YZ_PLANE) &&
  334. (hit_part != LL_XZ_PLANE) &&
  335. (hit_part != LL_XY_PLANE) )
  336. {
  337. return TRUE;
  338. }
  340. mHelpTextTimer.reset();
  341. sNumTimesHelpTextShown++;
  343. LLSelectMgr::getInstance()->getGrid(mGridOrigin, mGridRotation, mGridScale);
  345. LLSelectMgr::getInstance()->enableSilhouette(FALSE);
  347. // we just started a drag, so save initial object positions
  348. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_MOVE);
  350. mManipPart = (EManipPart)hit_part;
  351. mMouseDownX = x;
  352. mMouseDownY = y;
  353. mMouseOutsideSlop = FALSE;
  355. LLVector3 axis;
  357. LLSelectNode *selectNode = mObjectSelection->getFirstMoveableNode(TRUE);
  359. if (!selectNode)
  360. {
  361. // didn't find the object in our selection...oh well
  362. llwarns << "Trying to translate an unselected object" << llendl;
  363. return TRUE;
  364. }
  366. LLViewerObject *selected_object = selectNode->getObject();
  367. if (!selected_object)
  368. {
  369. // somehow we lost the object!
  370. llwarns << "Translate manip lost the object, no selected object" << llendl;
  371. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  372. return TRUE;
  373. }
  375. // Compute unit vectors for arrow hit and a plane through that vector
  376. BOOL axis_exists = getManipAxis(selected_object, mManipPart, axis);
  377. getManipNormal(selected_object, mManipPart, mManipNormal);
  379. //LLVector3 select_center_agent = gAgent.getPosAgentFromGlobal(LLSelectMgr::getInstance()->getSelectionCenterGlobal());
  380. // TomY: The above should (?) be identical to the below
  381. LLVector3 select_center_agent = getPivotPoint();
  382. mSubdivisions = llclamp(getSubdivisionLevel(select_center_agent, axis_exists ? axis : LLVector3::z_axis, getMinGridScale()), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  384. // if we clicked on a planar manipulator, recenter mouse cursor
  385. if (mManipPart >= LL_YZ_PLANE && mManipPart <= LL_XY_PLANE)
  386. {
  387. LLCoordGL mouse_pos;
  388. if (!LLViewerCamera::getInstance()->projectPosAgentToScreen(select_center_agent, mouse_pos))
  389. {
  390. // mouse_pos may be nonsense
  391. llwarns << "Failed to project object center to screen" << llendl;
  392. }
  393. else if (gSavedSettings.getBOOL("SnapToMouseCursor"))
  394. {
  395. LLUI::setMousePositionScreen(mouse_pos.mX, mouse_pos.mY);
  396. x = mouse_pos.mX;
  397. y = mouse_pos.mY;
  398. }
  399. }
  401. LLSelectMgr::getInstance()->updateSelectionCenter();
  402. LLVector3d object_start_global = gAgent.getPosGlobalFromAgent(getPivotPoint());
  403. getMousePointOnPlaneGlobal(mDragCursorStartGlobal, x, y, object_start_global, mManipNormal);
  404. mDragSelectionStartGlobal = object_start_global;
  405. mCopyMadeThisDrag = FALSE;
  407. // Route future Mouse messages here preemptively.  (Release on mouse up.)
  408. setMouseCapture( TRUE );
  410. return TRUE;
  411. }
  413. BOOL LLManipTranslate::handleHover(S32 x, S32 y, MASK mask)
  414. {
  415. // Translation tool only works if mouse button is down.
  416. // Bail out if mouse not down.
  417. if( !hasMouseCapture() )
  418. {
  419. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (inactive)" << llendl;
  420. // Always show cursor
  421. // gViewerWindow->setCursor(UI_CURSOR_ARROW);
  422. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  424. highlightManipulators(x, y);
  425. return TRUE;
  426. }
  428. // Handle auto-rotation if necessary.
  429. LLRect world_rect = gViewerWindow->getWorldViewRectScaled();
  430. const F32 ROTATE_ANGLE_PER_SECOND = 30.f * DEG_TO_RAD;
  431. const S32 ROTATE_H_MARGIN = world_rect.getWidth() / 20;
  432. const F32 rotate_angle = ROTATE_ANGLE_PER_SECOND / gFPSClamped;
  433. BOOL rotated = FALSE;
  435. // ...build mode moves camera about focus point
  436. if (mObjectSelection->getSelectType() != SELECT_TYPE_HUD)
  437. {
  438. if (x < ROTATE_H_MARGIN)
  439. {
  440. gAgent.cameraOrbitAround(rotate_angle);
  441. rotated = TRUE;
  442. }
  443. else if (x > world_rect.getWidth() - ROTATE_H_MARGIN)
  444. {
  445. gAgent.cameraOrbitAround(-rotate_angle);
  446. rotated = TRUE;
  447. }
  448. }
  450. // Suppress processing if mouse hasn't actually moved.
  451. // This may cause problems if the camera moves outside of the
  452. // rotation above.
  453. if( x == mLastHoverMouseX && y == mLastHoverMouseY && !rotated)
  454. {
  455. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (mouse unmoved)" << llendl;
  456. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  457. return TRUE;
  458. }
  459. mLastHoverMouseX = x;
  460. mLastHoverMouseY = y;
  462. // Suppress if mouse hasn't moved past the initial slop region
  463. // Reset once we start moving
  464. if( !mMouseOutsideSlop )
  465. {
  466. if (abs(mMouseDownX - x) < MOUSE_DRAG_SLOP && abs(mMouseDownY - y) < MOUSE_DRAG_SLOP )
  467. {
  468. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (mouse inside slop)" << llendl;
  469. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  470. return TRUE;
  471. }
  472. else
  473. {
  474. // ...just went outside the slop region
  475. mMouseOutsideSlop = TRUE;
  476. // If holding down shift, leave behind a copy.
  477. if (mask == MASK_COPY)
  478. {
  479. // ...we're trying to make a copy
  480. LLSelectMgr::getInstance()->selectDuplicate(LLVector3::zero, FALSE);
  481. mCopyMadeThisDrag = TRUE;
  483. // When we make the copy, we don't want to do any other processing.
  484. // If so, the object will also be moved, and the copy will be offset.
  485. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (made copy)" << llendl;
  486. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  487. }
  488. }
  489. }
  491. // Throttle updates to 10 per second.
  492. BOOL send_update = FALSE;
  494. LLVector3 axis_f;
  495. LLVector3d axis_d;
  497. // pick the first object to constrain to grid w/ common origin
  498. // this is so we don't screw up groups
  499. LLSelectNode* selectNode = mObjectSelection->getFirstMoveableNode(TRUE);
  500. if (!selectNode)
  501. {
  502. // somehow we lost the object!
  503. llwarns << "Translate manip lost the object, no selectNode" << llendl;
  504. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  505. return TRUE;
  506. }
  508. LLViewerObject* object = selectNode->getObject();
  509. if (!object)
  510. {
  511. // somehow we lost the object!
  512. llwarns << "Translate manip lost the object, no object in selectNode" << llendl;
  513. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  514. return TRUE;
  515. }
  517. // Compute unit vectors for arrow hit and a plane through that vector
  518. BOOL axis_exists = getManipAxis(object, mManipPart, axis_f); // TODO: move this
  520. axis_d.setVec(axis_f);
  522. LLSelectMgr::getInstance()->updateSelectionCenter();
  523. LLVector3d current_pos_global = gAgent.getPosGlobalFromAgent(getPivotPoint());
  525. mSubdivisions = llclamp(getSubdivisionLevel(getPivotPoint(), axis_f, getMinGridScale()), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  527. // Project the cursor onto that plane
  528. LLVector3d relative_move;
  529. getMousePointOnPlaneGlobal(relative_move, x, y, current_pos_global, mManipNormal);
  530. relative_move -= mDragCursorStartGlobal;
  532. // You can't move more than some distance from your original mousedown point.
  533. if (gSavedSettings.getBOOL("LimitDragDistance"))
  534. {
  535. F32 max_drag_distance = gSavedSettings.getF32("MaxDragDistance");
  537. if (relative_move.magVecSquared() > max_drag_distance * max_drag_distance)
  538. {
  539. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (too far)" << llendl;
  540. gViewerWindow->setCursor(UI_CURSOR_NOLOCKED);
  541. return TRUE;
  542. }
  543. }
  545. F64 axis_magnitude = relative_move * axis_d; // dot product
  546. LLVector3d cursor_point_snap_line;
  548. F64 off_axis_magnitude;
  550. getMousePointOnPlaneGlobal(cursor_point_snap_line, x, y, current_pos_global, mSnapOffsetAxis % axis_f);
  551. off_axis_magnitude = axis_exists ? llabs((cursor_point_snap_line - current_pos_global) * LLVector3d(mSnapOffsetAxis)) : 0.f;
  553. if (gSavedSettings.getBOOL("SnapEnabled"))
  554. {
  555. if (off_axis_magnitude > mSnapOffsetMeters)
  556. {
  557. mInSnapRegime = TRUE;
  558. LLVector3 mouse_down_offset(mDragCursorStartGlobal - mDragSelectionStartGlobal);
  559. LLVector3 cursor_snap_agent = gAgent.getPosAgentFromGlobal(cursor_point_snap_line);
  560. if (!gSavedSettings.getBOOL("SnapToMouseCursor"))
  561. {
  562. cursor_snap_agent -= mouse_down_offset;
  563. }
  565. F32 cursor_grid_dist = (cursor_snap_agent - mGridOrigin) * axis_f;
  567. F32 snap_dist = getMinGridScale() / (2.f * mSubdivisions);
  568. F32 relative_snap_dist = fmodf(llabs(cursor_grid_dist) + snap_dist, getMinGridScale() / mSubdivisions);
  569. if (relative_snap_dist < snap_dist * 2.f)
  570. {
  571. if (cursor_grid_dist > 0.f)
  572. {
  573. cursor_grid_dist -= relative_snap_dist - snap_dist;
  574. }
  575. else
  576. {
  577. cursor_grid_dist += relative_snap_dist - snap_dist;
  578. }
  579. }
  581. F32 object_start_on_axis = (gAgent.getPosAgentFromGlobal(mDragSelectionStartGlobal) - mGridOrigin) * axis_f;
  582. axis_magnitude = cursor_grid_dist - object_start_on_axis;
  583. }
  584. else if (mManipPart >= LL_YZ_PLANE && mManipPart <= LL_XY_PLANE)
  585. {
  586. // subtract offset from object center
  587. LLVector3d cursor_point_global;
  588. getMousePointOnPlaneGlobal( cursor_point_global, x, y, current_pos_global, mManipNormal );
  589. cursor_point_global -= (mDragCursorStartGlobal - mDragSelectionStartGlobal);
  591. // snap to planar grid
  592. LLVector3 cursor_point_agent = gAgent.getPosAgentFromGlobal(cursor_point_global);
  593. LLVector3 camera_plane_projection = LLViewerCamera::getInstance()->getAtAxis();
  594. camera_plane_projection -= projected_vec(camera_plane_projection, mManipNormal);
  595. camera_plane_projection.normVec();
  596. LLVector3 camera_projected_dir = camera_plane_projection;
  597. camera_plane_projection.rotVec(~mGridRotation);
  598. camera_plane_projection.scaleVec(mGridScale);
  599. camera_plane_projection.abs();
  600. F32 max_grid_scale;
  601. if (camera_plane_projection.mV[VX] > camera_plane_projection.mV[VY] &&
  602. camera_plane_projection.mV[VX] > camera_plane_projection.mV[VZ])
  603. {
  604. max_grid_scale = mGridScale.mV[VX];
  605. }
  606. else if (camera_plane_projection.mV[VY] > camera_plane_projection.mV[VZ])
  607. {
  608. max_grid_scale = mGridScale.mV[VY];
  609. }
  610. else
  611. {
  612. max_grid_scale = mGridScale.mV[VZ];
  613. }
  615. F32 num_subdivisions = llclamp(getSubdivisionLevel(getPivotPoint(), camera_projected_dir, max_grid_scale), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  617. F32 grid_scale_a;
  618. F32 grid_scale_b;
  619. LLVector3 cursor_point_grid = (cursor_point_agent - mGridOrigin) * ~mGridRotation;
  621. switch (mManipPart)
  622. {
  623. case LL_YZ_PLANE:
  624. grid_scale_a = mGridScale.mV[VY] / num_subdivisions;
  625. grid_scale_b = mGridScale.mV[VZ] / num_subdivisions;
  626. cursor_point_grid.mV[VY] -= fmod(cursor_point_grid.mV[VY] + grid_scale_a * 0.5f, grid_scale_a) - grid_scale_a * 0.5f;
  627. cursor_point_grid.mV[VZ] -= fmod(cursor_point_grid.mV[VZ] + grid_scale_b * 0.5f, grid_scale_b) - grid_scale_b * 0.5f;
  628. break;
  629. case LL_XZ_PLANE:
  630. grid_scale_a = mGridScale.mV[VX] / num_subdivisions;
  631. grid_scale_b = mGridScale.mV[VZ] / num_subdivisions;
  632. cursor_point_grid.mV[VX] -= fmod(cursor_point_grid.mV[VX] + grid_scale_a * 0.5f, grid_scale_a) - grid_scale_a * 0.5f;
  633. cursor_point_grid.mV[VZ] -= fmod(cursor_point_grid.mV[VZ] + grid_scale_b * 0.5f, grid_scale_b) - grid_scale_b * 0.5f;
  634. break;
  635. case LL_XY_PLANE:
  636. grid_scale_a = mGridScale.mV[VX] / num_subdivisions;
  637. grid_scale_b = mGridScale.mV[VY] / num_subdivisions;
  638. cursor_point_grid.mV[VX] -= fmod(cursor_point_grid.mV[VX] + grid_scale_a * 0.5f, grid_scale_a) - grid_scale_a * 0.5f;
  639. cursor_point_grid.mV[VY] -= fmod(cursor_point_grid.mV[VY] + grid_scale_b * 0.5f, grid_scale_b) - grid_scale_b * 0.5f;
  640. break;
  641. default:
  642. break;
  643. }
  644. cursor_point_agent = (cursor_point_grid * mGridRotation) + mGridOrigin;
  645. relative_move.setVec(cursor_point_agent - gAgent.getPosAgentFromGlobal(mDragSelectionStartGlobal));
  646. mInSnapRegime = TRUE;
  647. }
  648. else
  649. {
  650. mInSnapRegime = FALSE;
  651. }
  652. }
  653. else
  654. {
  655. mInSnapRegime = FALSE;
  656. }
  658. // Clamp to arrow direction
  659. // *FIX: does this apply anymore?
  660. if (!axis_exists)
  661. {
  662. axis_magnitude = relative_move.normVec();
  663. axis_d.setVec(relative_move);
  664. axis_d.normVec();
  665. axis_f.setVec(axis_d);
  666. }
  668. LLVector3d clamped_relative_move = axis_magnitude * axis_d; // scalar multiply
  669. LLVector3 clamped_relative_move_f = (F32)axis_magnitude * axis_f; // scalar multiply
  671. for (LLObjectSelection::iterator iter = mObjectSelection->begin();
  672.  iter != mObjectSelection->end(); iter++)
  673. {
  674. LLSelectNode* selectNode = *iter;
  675. LLViewerObject* object = selectNode->getObject();
  677. // Only apply motion to root objects and objects selected
  678. // as "individual".
  679. if (!object->isRootEdit() && !selectNode->mIndividualSelection)
  680. {
  681. continue;
  682. }
  684. if (!object->isRootEdit())
  685. {
  686. // child objects should not update if parent is selected
  687. LLViewerObject* editable_root = (LLViewerObject*)object->getParent();
  688. if (editable_root->isSelected())
  689. {
  690. // we will be moved properly by our parent, so skip
  691. continue;
  692. }
  693. }
  695. if (object->permMove())
  696. {
  697. // handle attachments in local space
  698. if (object->isAttachment() && object->mDrawable.notNull())
  699. {
  700. // calculate local version of relative move
  701. LLQuaternion objWorldRotation = object->mDrawable->mXform.getParent()->getWorldRotation();
  702. objWorldRotation.transQuat();
  704. LLVector3 old_position_local = object->getPosition();
  705. LLVector3 new_position_local = selectNode->mSavedPositionLocal + (clamped_relative_move_f * objWorldRotation);
  707. // move and clamp root object first, before adjusting children
  708. if (new_position_local != old_position_local)
  709. {
  710. send_update = TRUE;
  711. }
  712. //RN: I forget, but we need to do this because of snapping which doesn't often result
  713. // in position changes even when the mouse moves
  714. object->setPosition(new_position_local);
  715. rebuild(object);
  716. gAgent.getAvatarObject()->clampAttachmentPositions();
  717. new_position_local = object->getPosition();
  719. if (selectNode->mIndividualSelection)
  720. {
  721. send_update = FALSE;
  723. // counter-translate child objects if we are moving the root as an individual
  724. object->resetChildrenPosition(old_position_local - new_position_local, TRUE) ;
  725. }
  726. }
  727. else
  728. {
  729. // compute new position to send to simulators, but don't set it yet.
  730. // We need the old position to know which simulator to send the move message to.
  731. LLVector3d new_position_global = selectNode->mSavedPositionGlobal + clamped_relative_move;
  733. // Don't let object centers go too far underground
  734. F64 min_height = LLWorld::getInstance()->getMinAllowedZ(object);
  735. if (new_position_global.mdV[VZ] < min_height)
  736. {
  737. new_position_global.mdV[VZ] = min_height;
  738. }
  740. // For safety, cap heights where objects can be dragged
  741. if (new_position_global.mdV[VZ] > MAX_OBJECT_Z)
  742. {
  743. new_position_global.mdV[VZ] = MAX_OBJECT_Z;
  744. }
  746. // Grass is always drawn on the ground, so clamp its position to the ground
  747. if (object->getPCode() == LL_PCODE_LEGACY_GRASS)
  748. {
  749. new_position_global.mdV[VZ] = LLWorld::getInstance()->resolveLandHeightGlobal(new_position_global) + 1.f;
  750. }
  752. if (object->isRootEdit())
  753. {
  754. new_position_global = LLWorld::getInstance()->clipToVisibleRegions(object->getPositionGlobal(), new_position_global);
  755. }
  757. // PR: Only update if changed
  758. LLVector3d old_position_global = object->getPositionGlobal();
  759. LLVector3 old_position_agent = object->getPositionAgent();
  760. LLVector3 new_position_agent = gAgent.getPosAgentFromGlobal(new_position_global);
  761. if (object->isRootEdit())
  762. {
  763. // finally, move parent object after children have calculated new offsets
  764. object->setPositionAgent(new_position_agent);
  765. rebuild(object);
  766. }
  767. else
  768. {
  769. LLViewerObject* root_object = object->getRootEdit();
  770. new_position_agent -= root_object->getPositionAgent();
  771. new_position_agent = new_position_agent * ~root_object->getRotation();
  772. object->setPositionParent(new_position_agent, FALSE);
  773. rebuild(object);
  774. }
  776. if (selectNode->mIndividualSelection)
  777. {
  778. // counter-translate child objects if we are moving the root as an individual
  779. object->resetChildrenPosition(old_position_agent - new_position_agent, TRUE) ;
  780. send_update = FALSE;
  781. }
  782. else if (old_position_global != new_position_global)
  783. {
  784. send_update = TRUE;
  785. }
  786. }
  787. selectNode->mLastPositionLocal  = object->getPosition();
  788. }
  789. }
  791. LLSelectMgr::getInstance()->updateSelectionCenter();
  792. gAgent.clearFocusObject();
  793. dialog_refresh_all(); // ??? is this necessary?
  795. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipTranslate (active)" << llendl;
  796. gViewerWindow->setCursor(UI_CURSOR_TOOLTRANSLATE);
  797. return TRUE;
  798. }
  800. void LLManipTranslate::highlightManipulators(S32 x, S32 y)
  801. {
  802. mHighlightedPart = LL_NO_PART;
  804. if (!mObjectSelection->getObjectCount())
  805. {
  806. return;
  807. }
  809. //LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  810. LLMatrix4 projMatrix = LLViewerCamera::getInstance()->getProjection();
  811. LLMatrix4 modelView = LLViewerCamera::getInstance()->getModelview();
  813. LLVector3 object_position = getPivotPoint();
  815. LLVector3 grid_origin;
  816. LLVector3 grid_scale;
  817. LLQuaternion grid_rotation;
  819. LLSelectMgr::getInstance()->getGrid(grid_origin, grid_rotation, grid_scale);
  821. LLVector3 relative_camera_dir;
  823. LLMatrix4 transform;
  825. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  826. {
  827. relative_camera_dir = LLVector3(1.f, 0.f, 0.f) * ~grid_rotation;
  828. LLVector4 translation(object_position);
  829. transform.initRotTrans(grid_rotation, translation);
  830. LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
  831. transform *= cfr;
  832. LLMatrix4 window_scale;
  833. F32 zoom_level = 2.f * gAgent.mHUDCurZoom;
  834. window_scale.initAll(LLVector3(zoom_level / LLViewerCamera::getInstance()->getAspect(), zoom_level, 0.f),
  835. LLQuaternion::DEFAULT,
  836. LLVector3::zero);
  837. transform *= window_scale;
  838. }
  839. else
  840. {
  841. relative_camera_dir = (object_position - LLViewerCamera::getInstance()->getOrigin()) * ~grid_rotation;
  842. relative_camera_dir.normVec();
  844. transform.initRotTrans(grid_rotation, LLVector4(object_position));
  845. transform *= modelView;
  846. transform *= projMatrix;
  847. }
  849. S32 numManips = 0;
  851. // edges
  852. mManipulatorVertices[numManips++] = LLVector4(mArrowLengthMeters * MANIPULATOR_HOTSPOT_START, 0.f, 0.f, 1.f);
  853. mManipulatorVertices[numManips++] = LLVector4(mArrowLengthMeters * MANIPULATOR_HOTSPOT_END, 0.f, 0.f, 1.f);
  855. mManipulatorVertices[numManips++] = LLVector4(0.f, mArrowLengthMeters * MANIPULATOR_HOTSPOT_START, 0.f, 1.f);
  856. mManipulatorVertices[numManips++] = LLVector4(0.f, mArrowLengthMeters * MANIPULATOR_HOTSPOT_END, 0.f, 1.f);
  858. mManipulatorVertices[numManips++] = LLVector4(0.f, 0.f, mArrowLengthMeters * MANIPULATOR_HOTSPOT_START, 1.f);
  859. mManipulatorVertices[numManips++] = LLVector4(0.f, 0.f, mArrowLengthMeters * MANIPULATOR_HOTSPOT_END, 1.f);
  861. mManipulatorVertices[numManips++] = LLVector4(mArrowLengthMeters * -MANIPULATOR_HOTSPOT_START, 0.f, 0.f, 1.f);
  862. mManipulatorVertices[numManips++] = LLVector4(mArrowLengthMeters * -MANIPULATOR_HOTSPOT_END, 0.f, 0.f, 1.f);
  864. mManipulatorVertices[numManips++] = LLVector4(0.f, mArrowLengthMeters * -MANIPULATOR_HOTSPOT_START, 0.f, 1.f);
  865. mManipulatorVertices[numManips++] = LLVector4(0.f, mArrowLengthMeters * -MANIPULATOR_HOTSPOT_END, 0.f, 1.f);
  867. mManipulatorVertices[numManips++] = LLVector4(0.f, 0.f, mArrowLengthMeters * -MANIPULATOR_HOTSPOT_START, 1.f);
  868. mManipulatorVertices[numManips++] = LLVector4(0.f, 0.f, mArrowLengthMeters * -MANIPULATOR_HOTSPOT_END, 1.f);
  870. S32 num_arrow_manips = numManips;
  872. // planar manipulators
  873. BOOL planar_manip_yz_visible = FALSE;
  874. BOOL planar_manip_xz_visible = FALSE;
  875. BOOL planar_manip_xy_visible = FALSE;
  877. mManipulatorVertices[numManips] = LLVector4(0.f, mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), 1.f);
  878. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  879. mManipulatorVertices[numManips] = LLVector4(0.f, mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), 1.f);
  880. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  881. if (llabs(relative_camera_dir.mV[VX]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  882. {
  883. planar_manip_yz_visible = TRUE;
  884. }
  886. mManipulatorVertices[numManips] = LLVector4(mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), 0.f, mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), 1.f);
  887. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  888. mManipulatorVertices[numManips] = LLVector4(mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), 0.f, mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), 1.f);
  889. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  890. if (llabs(relative_camera_dir.mV[VY]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  891. {
  892. planar_manip_xz_visible = TRUE;
  893. }
  895. mManipulatorVertices[numManips] = LLVector4(mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), mPlaneManipOffsetMeters * (1.f - PLANE_TICK_SIZE * 0.5f), 0.f, 1.f);
  896. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  897. mManipulatorVertices[numManips] = LLVector4(mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), mPlaneManipOffsetMeters * (1.f + PLANE_TICK_SIZE * 0.5f), 0.f, 1.f);
  898. mManipulatorVertices[numManips++].scaleVec(mPlaneManipPositions);
  899. if (llabs(relative_camera_dir.mV[VZ]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  900. {
  901. planar_manip_xy_visible = TRUE;
  902. }
  904. // Project up to 9 manipulators to screen space 2*X, 2*Y, 2*Z, 3*planes
  905. std::vector<ManipulatorHandle> projected_manipulators;
  906. projected_manipulators.reserve(9);
  908. for (S32 i = 0; i < num_arrow_manips; i+= 2)
  909. {
  910. LLVector4 projected_start = mManipulatorVertices[i] * transform;
  911. projected_start = projected_start * (1.f / projected_start.mV[VW]);
  913. LLVector4 projected_end = mManipulatorVertices[i + 1] * transform;
  914. projected_end = projected_end * (1.f / projected_end.mV[VW]);
  916. ManipulatorHandle projected_manip(
  917. LLVector3(projected_start.mV[VX], projected_start.mV[VY], projected_start.mV[VZ]), 
  918. LLVector3(projected_end.mV[VX], projected_end.mV[VY], projected_end.mV[VZ]), 
  919. MANIPULATOR_IDS[i / 2],
  920. 10.f); // 10 pixel hotspot for arrows
  921. projected_manipulators.push_back(projected_manip);
  922. }
  924. if (planar_manip_yz_visible)
  925. {
  926. S32 i = num_arrow_manips;
  927. LLVector4 projected_start = mManipulatorVertices[i] * transform;
  928. projected_start = projected_start * (1.f / projected_start.mV[VW]);
  930. LLVector4 projected_end = mManipulatorVertices[i + 1] * transform;
  931. projected_end = projected_end * (1.f / projected_end.mV[VW]);
  933. ManipulatorHandle projected_manip(
  934. LLVector3(projected_start.mV[VX], projected_start.mV[VY], projected_start.mV[VZ]), 
  935. LLVector3(projected_end.mV[VX], projected_end.mV[VY], projected_end.mV[VZ]), 
  936. MANIPULATOR_IDS[i / 2],
  937. 20.f); // 20 pixels for planar manipulators
  938. projected_manipulators.push_back(projected_manip);
  939. }
  941. if (planar_manip_xz_visible)
  942. {
  943. S32 i = num_arrow_manips + 2;
  944. LLVector4 projected_start = mManipulatorVertices[i] * transform;
  945. projected_start = projected_start * (1.f / projected_start.mV[VW]);
  947. LLVector4 projected_end = mManipulatorVertices[i + 1] * transform;
  948. projected_end = projected_end * (1.f / projected_end.mV[VW]);
  950. ManipulatorHandle projected_manip(
  951. LLVector3(projected_start.mV[VX], projected_start.mV[VY], projected_start.mV[VZ]), 
  952. LLVector3(projected_end.mV[VX], projected_end.mV[VY], projected_end.mV[VZ]), 
  953. MANIPULATOR_IDS[i / 2],
  954. 20.f); // 20 pixels for planar manipulators
  955. projected_manipulators.push_back(projected_manip);
  956. }
  958. if (planar_manip_xy_visible)
  959. {
  960. S32 i = num_arrow_manips + 4;
  961. LLVector4 projected_start = mManipulatorVertices[i] * transform;
  962. projected_start = projected_start * (1.f / projected_start.mV[VW]);
  964. LLVector4 projected_end = mManipulatorVertices[i + 1] * transform;
  965. projected_end = projected_end * (1.f / projected_end.mV[VW]);
  967. ManipulatorHandle projected_manip(
  968. LLVector3(projected_start.mV[VX], projected_start.mV[VY], projected_start.mV[VZ]), 
  969. LLVector3(projected_end.mV[VX], projected_end.mV[VY], projected_end.mV[VZ]), 
  970. MANIPULATOR_IDS[i / 2],
  971. 20.f); // 20 pixels for planar manipulators
  972. projected_manipulators.push_back(projected_manip);
  973. }
  975. LLVector2 manip_start_2d;
  976. LLVector2 manip_end_2d;
  977. LLVector2 manip_dir;
  978. LLRect world_view_rect = gViewerWindow->getWorldViewRectScaled();
  979. F32 half_width = (F32)world_view_rect.getWidth() / 2.f;
  980. F32 half_height = (F32)world_view_rect.getHeight() / 2.f;
  981. LLVector2 mousePos((F32)x - half_width, (F32)y - half_height);
  982. LLVector2 mouse_delta;
  984. // Keep order consistent with insertion via stable_sort
  985. std::stable_sort( projected_manipulators.begin(),
  986. projected_manipulators.end(),
  987. ClosestToCamera() );
  989. std::vector<ManipulatorHandle>::iterator it = projected_manipulators.begin();
  990. for ( ; it != projected_manipulators.end(); ++it)
  991. {
  992. ManipulatorHandle& manipulator = *it;
  993. {
  994. manip_start_2d.setVec(manipulator.mStartPosition.mV[VX] * half_width, manipulator.mStartPosition.mV[VY] * half_height);
  995. manip_end_2d.setVec(manipulator.mEndPosition.mV[VX] * half_width, manipulator.mEndPosition.mV[VY] * half_height);
  996. manip_dir = manip_end_2d - manip_start_2d;
  998. mouse_delta = mousePos - manip_start_2d;
  1000. F32 manip_length = manip_dir.normVec();
  1002. F32 mouse_pos_manip = mouse_delta * manip_dir;
  1003. F32 mouse_dist_manip_squared = mouse_delta.magVecSquared() - (mouse_pos_manip * mouse_pos_manip);
  1005. if (mouse_pos_manip > 0.f &&
  1006. mouse_pos_manip < manip_length &&
  1007. mouse_dist_manip_squared < manipulator.mHotSpotRadius * manipulator.mHotSpotRadius)
  1008. {
  1009. mHighlightedPart = manipulator.mManipID;
  1010. break;
  1011. }
  1012. }
  1013. }
  1014. }
  1016. F32 LLManipTranslate::getMinGridScale()
  1017. {
  1018. F32 scale;
  1019. switch (mManipPart)
  1020. {
  1021. case LL_NO_PART:
  1022. default:
  1023. scale = 1.f;
  1024. break;
  1025. case LL_X_ARROW:
  1026. scale = mGridScale.mV[VX];
  1027. break;
  1028. case LL_Y_ARROW:
  1029. scale = mGridScale.mV[VY];
  1030. break;
  1031. case LL_Z_ARROW:
  1032. scale = mGridScale.mV[VZ];
  1033. break;
  1034. case LL_YZ_PLANE:
  1035. scale = llmin(mGridScale.mV[VY], mGridScale.mV[VZ]);
  1036. break;
  1037. case LL_XZ_PLANE:
  1038. scale = llmin(mGridScale.mV[VX], mGridScale.mV[VZ]);
  1039. break;
  1040. case LL_XY_PLANE:
  1041. scale = llmin(mGridScale.mV[VX], mGridScale.mV[VY]);
  1042. break;
  1043. }
  1045. return scale;
  1046. }
  1049. BOOL LLManipTranslate::handleMouseUp(S32 x, S32 y, MASK mask)
  1050. {
  1051. // first, perform normal processing in case this was a quick-click
  1052. handleHover(x, y, mask);
  1054. if(hasMouseCapture())
  1055. {
  1056. // make sure arrow colors go back to normal
  1057. mManipPart = LL_NO_PART;
  1058. LLSelectMgr::getInstance()->enableSilhouette(TRUE);
  1060. // Might have missed last update due to UPDATE_DELAY timing.
  1061. LLSelectMgr::getInstance()->sendMultipleUpdate( UPD_POSITION );
  1063. mInSnapRegime = FALSE;
  1064. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK);
  1065. //gAgent.setObjectTracking(gSavedSettings.getBOOL("TrackFocusObject"));
  1066. }
  1068. return LLManip::handleMouseUp(x, y, mask);
  1069. }
  1072. void LLManipTranslate::render()
  1073. {
  1074. glMatrixMode(GL_MODELVIEW);
  1075. gGL.pushMatrix();
  1076. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1077. {
  1078. F32 zoom = gAgent.mHUDCurZoom;
  1079. glScalef(zoom, zoom, zoom);
  1080. }
  1081. {
  1082. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  1083. renderGuidelines();
  1084. }
  1085. {
  1086. renderTranslationHandles();
  1087. renderSnapGuides();
  1088. }
  1089. gGL.popMatrix();
  1091. renderText();
  1092. }
  1094. void LLManipTranslate::renderSnapGuides()
  1095. {
  1096. if (!gSavedSettings.getBOOL("SnapEnabled"))
  1097. {
  1098. return;
  1099. }
  1101. F32 max_subdivisions = sGridMaxSubdivisionLevel;//(F32)gSavedSettings.getS32("GridSubdivision");
  1102. F32 line_alpha = gSavedSettings.getF32("GridOpacity");
  1104. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1105. LLGLDepthTest gls_depth(GL_TRUE);
  1106. LLGLDisable gls_cull(GL_CULL_FACE);
  1107. LLVector3 translate_axis;
  1109. if (mManipPart == LL_NO_PART)
  1110. {
  1111. return;
  1112. }
  1114. LLSelectNode *first_node = mObjectSelection->getFirstMoveableNode(TRUE);
  1115. if (!first_node)
  1116. {
  1117. return;
  1118. }
  1120. updateGridSettings();
  1122. F32 smallest_grid_unit_scale = getMinGridScale() / max_subdivisions;
  1123. LLVector3 grid_origin;
  1124. LLVector3 grid_scale;
  1125. LLQuaternion grid_rotation;
  1127. LLSelectMgr::getInstance()->getGrid(grid_origin, grid_rotation, grid_scale);
  1128. LLVector3 saved_selection_center = getSavedPivotPoint(); //LLSelectMgr::getInstance()->getSavedBBoxOfSelection().getCenterAgent();
  1129. LLVector3 selection_center = getPivotPoint();
  1131. LLViewerObject *first_object = first_node->getObject();
  1133. //pick appropriate projection plane for snap rulers according to relative camera position
  1134. if (mManipPart >= LL_X_ARROW && mManipPart <= LL_Z_ARROW)
  1135. {
  1136. LLVector3 normal;
  1137. LLColor4 inner_color;
  1138. LLManip::EManipPart temp_manip = mManipPart;
  1139. switch (mManipPart)
  1140. {
  1141. case LL_X_ARROW:
  1142. normal.setVec(1,0,0);
  1143. inner_color.setVec(0,1,1,line_alpha);
  1144. mManipPart = LL_YZ_PLANE;
  1145. break;
  1146. case LL_Y_ARROW:
  1147. normal.setVec(0,1,0);
  1148. inner_color.setVec(1,0,1,line_alpha);
  1149. mManipPart = LL_XZ_PLANE;
  1150. break;
  1151. case LL_Z_ARROW:
  1152. normal.setVec(0,0,1);
  1153. inner_color.setVec(1,1,0,line_alpha);
  1154. mManipPart = LL_XY_PLANE;
  1155. break;
  1156. default:
  1157. break;
  1158. }
  1160. highlightIntersection(normal, selection_center, grid_rotation, inner_color);
  1161. mManipPart = temp_manip;
  1162. getManipAxis(first_object, mManipPart, translate_axis);
  1164. LLVector3 at_axis_abs;
  1165. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1166. {
  1167. at_axis_abs = LLVector3::x_axis * ~grid_rotation;
  1168. }
  1169. else
  1170. {
  1171. at_axis_abs = saved_selection_center - LLViewerCamera::getInstance()->getOrigin();
  1172. at_axis_abs.normVec();
  1174. at_axis_abs = at_axis_abs * ~grid_rotation;
  1175. }
  1176. at_axis_abs.abs();
  1178. if (at_axis_abs.mV[VX] > at_axis_abs.mV[VY] && at_axis_abs.mV[VX] > at_axis_abs.mV[VZ])
  1179. {
  1180. if (mManipPart == LL_Y_ARROW)
  1181. {
  1182. mSnapOffsetAxis = LLVector3::z_axis;
  1183. }
  1184. else if (mManipPart == LL_Z_ARROW)
  1185. {
  1186. mSnapOffsetAxis = LLVector3::y_axis;
  1187. }
  1188. else if (at_axis_abs.mV[VY] > at_axis_abs.mV[VZ])
  1189. {
  1190. mSnapOffsetAxis = LLVector3::z_axis;
  1191. }
  1192. else
  1193. {
  1194. mSnapOffsetAxis = LLVector3::y_axis;
  1195. }
  1196. }
  1197. else if (at_axis_abs.mV[VY] > at_axis_abs.mV[VZ])
  1198. {
  1199. if (mManipPart == LL_X_ARROW)
  1200. {
  1201. mSnapOffsetAxis = LLVector3::z_axis;
  1202. }
  1203. else if (mManipPart == LL_Z_ARROW)
  1204. {
  1205. mSnapOffsetAxis = LLVector3::x_axis;
  1206. }
  1207. else if (at_axis_abs.mV[VX] > at_axis_abs.mV[VZ])
  1208. {
  1209. mSnapOffsetAxis = LLVector3::z_axis;
  1210. }
  1211. else
  1212. {
  1213. mSnapOffsetAxis = LLVector3::x_axis;
  1214. }
  1215. }
  1216. else
  1217. {
  1218. if (mManipPart == LL_X_ARROW)
  1219. {
  1220. mSnapOffsetAxis = LLVector3::y_axis;
  1221. }
  1222. else if (mManipPart == LL_Y_ARROW)
  1223. {
  1224. mSnapOffsetAxis = LLVector3::x_axis;
  1225. }
  1226. else if (at_axis_abs.mV[VX] > at_axis_abs.mV[VY])
  1227. {
  1228. mSnapOffsetAxis = LLVector3::y_axis;
  1229. }
  1230. else
  1231. {
  1232. mSnapOffsetAxis = LLVector3::x_axis;
  1233. }
  1234. }
  1236. mSnapOffsetAxis = mSnapOffsetAxis * grid_rotation;
  1238. F32 guide_size_meters;
  1240. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1241. {
  1242. guide_size_meters = 1.f / gAgent.mHUDCurZoom;
  1243. mSnapOffsetMeters = mArrowLengthMeters * 1.5f;
  1244. }
  1245. else
  1246. {
  1247. LLVector3 cam_to_selection = getPivotPoint() - LLViewerCamera::getInstance()->getOrigin();
  1248. F32 current_range = cam_to_selection.normVec();
  1249. guide_size_meters = SNAP_GUIDE_SCREEN_SIZE * gViewerWindow->getWorldViewHeightRaw() * current_range / LLViewerCamera::getInstance()->getPixelMeterRatio();
  1251. F32 fraction_of_fov = mAxisArrowLength / (F32) LLViewerCamera::getInstance()->getViewHeightInPixels();
  1252. F32 apparent_angle = fraction_of_fov * LLViewerCamera::getInstance()->getView();  // radians
  1253. F32 offset_at_camera = tan(apparent_angle) * 1.5f;
  1254. F32 range = dist_vec(gAgent.getPosAgentFromGlobal(first_node->mSavedPositionGlobal), LLViewerCamera::getInstance()->getOrigin());
  1255. mSnapOffsetMeters = range * offset_at_camera;
  1256. }
  1258. LLVector3 tick_start;
  1259. LLVector3 tick_end;
  1261. // how far away from grid origin is the selection along the axis of translation?
  1262. F32 dist_grid_axis = (selection_center - mGridOrigin) * translate_axis;
  1263. // find distance to nearest smallest grid unit
  1264. F32 offset_nearest_grid_unit = fmodf(dist_grid_axis, smallest_grid_unit_scale);
  1265. // how many smallest grid units are we away from largest grid scale?
  1266. S32 sub_div_offset = llround(fmod(dist_grid_axis - offset_nearest_grid_unit, getMinGridScale() / sGridMinSubdivisionLevel) / smallest_grid_unit_scale);
  1267. S32 num_ticks_per_side = llmax(1, llfloor(0.5f * guide_size_meters / smallest_grid_unit_scale));
  1269. LLGLDepthTest gls_depth(GL_FALSE);
  1271. for (S32 pass = 0; pass < 3; pass++)
  1272. {
  1273. LLColor4 line_color = setupSnapGuideRenderPass(pass);
  1275. gGL.begin(LLRender::LINES);
  1276. {
  1277. LLVector3 line_start = selection_center + (mSnapOffsetMeters * mSnapOffsetAxis) + (translate_axis * (guide_size_meters * 0.5f + offset_nearest_grid_unit));
  1278. LLVector3 line_end = selection_center + (mSnapOffsetMeters * mSnapOffsetAxis) - (translate_axis * (guide_size_meters * 0.5f + offset_nearest_grid_unit));
  1279. LLVector3 line_mid = (line_start + line_end) * 0.5f;
  1281. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW] * 0.2f);
  1282. gGL.vertex3fv(line_start.mV);
  1283. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW]);
  1284. gGL.vertex3fv(line_mid.mV);
  1285. gGL.vertex3fv(line_mid.mV);
  1286. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW] * 0.2f);
  1287. gGL.vertex3fv(line_end.mV);
  1289. line_start.setVec(selection_center + (mSnapOffsetAxis * -mSnapOffsetMeters) + (translate_axis * guide_size_meters * 0.5f));
  1290. line_end.setVec(selection_center + (mSnapOffsetAxis * -mSnapOffsetMeters) - (translate_axis * guide_size_meters * 0.5f));
  1291. line_mid = (line_start + line_end) * 0.5f;
  1293. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW] * 0.2f);
  1294. gGL.vertex3fv(line_start.mV);
  1295. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW]);
  1296. gGL.vertex3fv(line_mid.mV);
  1297. gGL.vertex3fv(line_mid.mV);
  1298. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW] * 0.2f);
  1299. gGL.vertex3fv(line_end.mV);
  1301. for (S32 i = -num_ticks_per_side; i <= num_ticks_per_side; i++)
  1302. {
  1303. tick_start = selection_center + (translate_axis * (smallest_grid_unit_scale * (F32)i - offset_nearest_grid_unit));
  1305. F32 cur_subdivisions = llclamp(getSubdivisionLevel(tick_start, translate_axis, getMinGridScale()), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  1307. if (fmodf((F32)(i + sub_div_offset), (max_subdivisions / cur_subdivisions)) != 0.f)
  1308. {
  1309. continue;
  1310. }
  1312. // add in off-axis offset
  1313. tick_start += (mSnapOffsetAxis * mSnapOffsetMeters);
  1315. BOOL is_sub_tick = FALSE;
  1316. F32 tick_scale = 1.f;
  1317. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1318. {
  1319. if (fmodf((F32)(i + sub_div_offset), division_level) == 0.f)
  1320. {
  1321. break;
  1322. }
  1323. tick_scale *= 0.7f;
  1324. is_sub_tick = TRUE;
  1325. }
  1327. //  S32 num_ticks_to_fade = is_sub_tick ? num_ticks_per_side / 2 : num_ticks_per_side;
  1328. //  F32 alpha = line_alpha * (1.f - (0.8f *  ((F32)llabs(i) / (F32)num_ticks_to_fade)));
  1330. tick_end = tick_start + (mSnapOffsetAxis * mSnapOffsetMeters * tick_scale);
  1332. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW]);
  1333. gGL.vertex3fv(tick_start.mV);
  1334. gGL.vertex3fv(tick_end.mV);
  1336. tick_start = selection_center + (mSnapOffsetAxis * -mSnapOffsetMeters) +
  1337. (translate_axis * (getMinGridScale() / (F32)(max_subdivisions) * (F32)i - offset_nearest_grid_unit));
  1338. tick_end = tick_start - (mSnapOffsetAxis * mSnapOffsetMeters * tick_scale);
  1340. gGL.vertex3fv(tick_start.mV);
  1341. gGL.vertex3fv(tick_end.mV);
  1342. }
  1343. }
  1344. gGL.end();
  1346. if (mInSnapRegime)
  1347. {
  1348. LLVector3 line_start = selection_center - mSnapOffsetAxis * mSnapOffsetMeters;
  1349. LLVector3 line_end = selection_center + mSnapOffsetAxis * mSnapOffsetMeters;
  1351. gGL.begin(LLRender::LINES);
  1352. {
  1353. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW]);
  1355. gGL.vertex3fv(line_start.mV);
  1356. gGL.vertex3fv(line_end.mV);
  1357. }
  1358. gGL.end();
  1360. // draw snap guide arrow
  1361. gGL.begin(LLRender::TRIANGLES);
  1362. {
  1363. gGL.color4f(line_color.mV[VX], line_color.mV[VY], line_color.mV[VZ], line_color.mV[VW]);
  1365. LLVector3 arrow_dir;
  1366. LLVector3 arrow_span = translate_axis;
  1368. arrow_dir = -mSnapOffsetAxis;
  1369. gGL.vertex3fv((line_start + arrow_dir * mConeSize * SNAP_ARROW_SCALE).mV);
  1370. gGL.vertex3fv((line_start + arrow_span * mConeSize * SNAP_ARROW_SCALE).mV);
  1371. gGL.vertex3fv((line_start - arrow_span * mConeSize * SNAP_ARROW_SCALE).mV);
  1373. arrow_dir = mSnapOffsetAxis;
  1374. gGL.vertex3fv((line_end + arrow_dir * mConeSize * SNAP_ARROW_SCALE).mV);
  1375. gGL.vertex3fv((line_end + arrow_span * mConeSize * SNAP_ARROW_SCALE).mV);
  1376. gGL.vertex3fv((line_end - arrow_span * mConeSize * SNAP_ARROW_SCALE).mV);
  1377. }
  1378. gGL.end();
  1379. }
  1380. }
  1382. sub_div_offset = llround(fmod(dist_grid_axis - offset_nearest_grid_unit, getMinGridScale() * 32.f) / smallest_grid_unit_scale);
  1384. LLVector2 screen_translate_axis(llabs(translate_axis * LLViewerCamera::getInstance()->getLeftAxis()), llabs(translate_axis * LLViewerCamera::getInstance()->getUpAxis()));
  1385. screen_translate_axis.normVec();
  1387. S32 tick_label_spacing = llround(screen_translate_axis * sTickLabelSpacing);
  1388.         
  1389. // render tickmark values
  1390. for (S32 i = -num_ticks_per_side; i <= num_ticks_per_side; i++)
  1391. {
  1392. LLVector3 tick_pos = selection_center + (translate_axis * ((smallest_grid_unit_scale * (F32)i) - offset_nearest_grid_unit));
  1393. F32 alpha = line_alpha * (1.f - (0.5f *  ((F32)llabs(i) / (F32)num_ticks_per_side)));
  1395. F32 tick_scale = 1.f;
  1396. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1397. {
  1398. if (fmodf((F32)(i + sub_div_offset), division_level) == 0.f)
  1399. {
  1400. break;
  1401. }
  1402. tick_scale *= 0.7f;
  1403. }
  1405. if (fmodf((F32)(i + sub_div_offset), (max_subdivisions / llmin(sGridMaxSubdivisionLevel, getSubdivisionLevel(tick_pos, translate_axis, getMinGridScale(), tick_label_spacing)))) == 0.f)
  1406. {
  1407. F32 snap_offset_meters;
  1409. if (mSnapOffsetAxis * LLViewerCamera::getInstance()->getUpAxis() > 0.f)
  1410. {
  1411. snap_offset_meters = mSnapOffsetMeters;
  1412. }
  1413. else
  1414. {
  1415. snap_offset_meters = -mSnapOffsetMeters;
  1416. }
  1417. LLVector3 text_origin = selection_center + 
  1418. (translate_axis * ((smallest_grid_unit_scale * (F32)i) - offset_nearest_grid_unit)) + 
  1419. (mSnapOffsetAxis * snap_offset_meters * (1.f + tick_scale));
  1421. LLVector3 tick_offset = (tick_pos - mGridOrigin) * ~mGridRotation;
  1422. F32 offset_val = 0.5f * tick_offset.mV[ARROW_TO_AXIS[mManipPart]] / getMinGridScale();
  1423. EGridMode grid_mode = LLSelectMgr::getInstance()->getGridMode();
  1424. F32 text_highlight = 0.8f;
  1425. if(i - llround(offset_nearest_grid_unit / smallest_grid_unit_scale) == 0 && mInSnapRegime)
  1426. {
  1427. text_highlight = 1.f;
  1428. }
  1430. if (grid_mode == GRID_MODE_WORLD)
  1431. {
  1432. // rescale units to meters from multiple of grid scale
  1433. offset_val *= 2.f * grid_scale[ARROW_TO_AXIS[mManipPart]];
  1434. renderTickValue(text_origin, offset_val, std::string("m"), LLColor4(text_highlight, text_highlight, text_highlight, alpha));
  1435. }
  1436. else
  1437. {
  1438. renderTickValue(text_origin, offset_val, std::string("x"), LLColor4(text_highlight, text_highlight, text_highlight, alpha));
  1439. }
  1440. }
  1441. }
  1442. if (mObjectSelection->getSelectType() != SELECT_TYPE_HUD)
  1443. {
  1444. // render helpful text
  1445. if (mHelpTextTimer.getElapsedTimeF32() < sHelpTextVisibleTime + sHelpTextFadeTime && sNumTimesHelpTextShown < sMaxTimesShowHelpText)
  1446. {
  1447. F32 snap_offset_meters_up;
  1448. if (mSnapOffsetAxis * LLViewerCamera::getInstance()->getUpAxis() > 0.f)
  1449. {
  1450. snap_offset_meters_up = mSnapOffsetMeters;
  1451. }
  1452. else
  1453. {
  1454. snap_offset_meters_up = -mSnapOffsetMeters;
  1455. }
  1457. LLVector3 selection_center_start = getSavedPivotPoint();//LLSelectMgr::getInstance()->getSavedBBoxOfSelection().getCenterAgent();
  1459. LLVector3 help_text_pos = selection_center_start + (snap_offset_meters_up * 3.f * mSnapOffsetAxis);
  1460. const LLFontGL* big_fontp = LLFontGL::getFontSansSerif();
  1462. std::string help_text = "Move mouse cursor over ruler";
  1463. LLColor4 help_text_color = LLColor4::white;
  1464. help_text_color.mV[VALPHA] = clamp_rescale(mHelpTextTimer.getElapsedTimeF32(), sHelpTextVisibleTime, sHelpTextVisibleTime + sHelpTextFadeTime, line_alpha, 0.f);
  1465. hud_render_utf8text(help_text, help_text_pos, *big_fontp, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, -0.5f * big_fontp->getWidthF32(help_text), 3.f, help_text_color, mObjectSelection->getSelectType() == SELECT_TYPE_HUD);
  1466. help_text = "to snap to grid";
  1467. help_text_pos -= LLViewerCamera::getInstance()->getUpAxis() * mSnapOffsetMeters * 0.2f;
  1468. hud_render_utf8text(help_text, help_text_pos, *big_fontp, LLFontGL::NORMAL, LLFontGL::NO_SHADOW, -0.5f * big_fontp->getWidthF32(help_text), 3.f, help_text_color, mObjectSelection->getSelectType() == SELECT_TYPE_HUD);
  1469. }
  1470. }
  1471. }
  1472. else
  1473. {
  1474. // render gridlines for planar snapping
  1476. F32 u = 0, v = 0;
  1477.         LLColor4 inner_color;
  1478. LLVector3 normal;
  1479. LLVector3 grid_center = selection_center - grid_origin;
  1480. F32 usc = 1;
  1481. F32 vsc = 1;
  1483. grid_center *= ~grid_rotation;
  1485. switch (mManipPart)
  1486. {
  1487. case LL_YZ_PLANE:
  1488. u = grid_center.mV[VY];
  1489. v = grid_center.mV[VZ];
  1490. usc = grid_scale.mV[VY];
  1491. vsc = grid_scale.mV[VZ];
  1492. inner_color.setVec(0,1,1,line_alpha);
  1493. normal.setVec(1,0,0);
  1494. break;
  1495. case LL_XZ_PLANE:
  1496. u = grid_center.mV[VX];
  1497. v = grid_center.mV[VZ];
  1498. usc = grid_scale.mV[VX];
  1499. vsc = grid_scale.mV[VZ];
  1500. inner_color.setVec(1,0,1,line_alpha);
  1501. normal.setVec(0,1,0);
  1502. break;
  1503. case LL_XY_PLANE:
  1504. u = grid_center.mV[VX];
  1505. v = grid_center.mV[VY];
  1506. usc = grid_scale.mV[VX];
  1507. vsc = grid_scale.mV[VY];
  1508. inner_color.setVec(1,1,0,line_alpha);
  1509. normal.setVec(0,0,1);
  1510. break;
  1511. default:
  1512. break;
  1513. }
  1515. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1516. highlightIntersection(normal, selection_center, grid_rotation, inner_color);
  1518. gGL.pushMatrix();
  1520. F32 x,y,z,angle_radians;
  1521. grid_rotation.getAngleAxis(&angle_radians, &x, &y, &z);
  1522. gGL.translatef(selection_center.mV[VX], selection_center.mV[VY], selection_center.mV[VZ]);
  1523. glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
  1525. F32 sz = mGridSizeMeters;
  1526. F32 tiles = sz;
  1527. glMatrixMode(GL_TEXTURE);
  1528. gGL.pushMatrix();
  1529. usc = 1.0f/usc;
  1530. vsc = 1.0f/vsc;
  1532. while (usc > vsc*4.0f)
  1533. {
  1534. usc *= 0.5f;
  1535. }
  1536. while (vsc > usc * 4.0f)
  1537. {
  1538. vsc *= 0.5f;
  1539. }
  1541. glScalef(usc, vsc, 1.0f);
  1542. gGL.translatef(u, v, 0);
  1544. float a = line_alpha;
  1546. LLColor4 col = LLUIColorTable::instance().getColor("SilhouetteChildColor");
  1547. {
  1548. //draw grid behind objects
  1549. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  1551. {
  1552. LLGLDisable stencil(GL_STENCIL_TEST);
  1553. {
  1554. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_GREATER);
  1555. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, getGridTexName());
  1556. gGL.flush();
  1557. gGL.blendFunc(LLRender::BF_ZERO, LLRender::BF_ONE_MINUS_SOURCE_ALPHA);
  1558. renderGrid(u,v,tiles,0.9f, 0.9f, 0.9f,a*0.15f);
  1559. gGL.flush();
  1560. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  1561. }
  1563. {
  1564. LLGLDisable alpha_test(GL_ALPHA_TEST);
  1565. //draw black overlay
  1566. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1567. renderGrid(u,v,tiles,0.0f, 0.0f, 0.0f,a*0.16f);
  1569. //draw grid top
  1570. gGL.getTexUnit(0)->bindManual(LLTexUnit::TT_TEXTURE, getGridTexName());
  1571. renderGrid(u,v,tiles,1,1,1,a);
  1573. gGL.popMatrix();
  1574. glMatrixMode(GL_MODELVIEW);
  1575. gGL.popMatrix();
  1576. }
  1578. {
  1579. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  1580. renderGuidelines();
  1581. }
  1583. {
  1584. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, GL_GREATER);
  1585. LLGLEnable stipple(GL_LINE_STIPPLE);
  1586. gGL.flush();
  1587. glLineStipple(1, 0x3333);
  1589. switch (mManipPart)
  1590. {
  1591.   case LL_YZ_PLANE:
  1592. renderGuidelines(FALSE, TRUE, TRUE);
  1593. break;
  1594.   case LL_XZ_PLANE:
  1595. renderGuidelines(TRUE, FALSE, TRUE);
  1596. break;
  1597.   case LL_XY_PLANE:
  1598. renderGuidelines(TRUE, TRUE, FALSE);
  1599. break;
  1600.   default:
  1601. break;
  1602. }
  1603. gGL.flush();
  1604. }
  1605. }
  1606. }
  1607. }
  1608. }
  1610. void LLManipTranslate::renderGrid(F32 x, F32 y, F32 size, F32 r, F32 g, F32 b, F32 a)
  1611. {
  1612. F32 d = size*0.5f;
  1614. for (F32 xx = -size-d; xx < size+d; xx += d)
  1615. {
  1616. gGL.begin(LLRender::TRIANGLE_STRIP);
  1617. for (F32 yy = -size-d; yy < size+d; yy += d)
  1618. {
  1619. float dx, dy, da;
  1621. dx = xx; dy = yy;
  1622. da = sqrtf(llmax(0.0f, 1.0f-sqrtf(dx*dx+dy*dy)/size))*a;
  1623. gGL.texCoord2f(dx, dy);
  1624. renderGridVert(dx,dy,r,g,b,da);
  1626. dx = xx+d; dy = yy;
  1627. da = sqrtf(llmax(0.0f, 1.0f-sqrtf(dx*dx+dy*dy)/size))*a;
  1628. gGL.texCoord2f(dx, dy);
  1629. renderGridVert(dx,dy,r,g,b,da);
  1631. dx = xx; dy = yy+d;
  1632. da = sqrtf(llmax(0.0f, 1.0f-sqrtf(dx*dx+dy*dy)/size))*a;
  1633. gGL.texCoord2f(dx, dy);
  1634. renderGridVert(dx,dy,r,g,b,da);
  1636. dx = xx+d; dy = yy+d;
  1637. da = sqrtf(llmax(0.0f, 1.0f-sqrtf(dx*dx+dy*dy)/size))*a;
  1638. gGL.texCoord2f(dx, dy);
  1639. renderGridVert(dx,dy,r,g,b,da);
  1640. }
  1641. gGL.end();
  1642. }
  1645. }
  1647. void LLManipTranslate::highlightIntersection(LLVector3 normal, 
  1648.  LLVector3 selection_center, 
  1649.  LLQuaternion grid_rotation, 
  1650.  LLColor4 inner_color)
  1651. {
  1652. if (!gSavedSettings.getBOOL("GridCrossSections"))
  1653. {
  1654. return;
  1655. }
  1657. U32 types[] = { LLRenderPass::PASS_SIMPLE, LLRenderPass::PASS_ALPHA, LLRenderPass::PASS_FULLBRIGHT, LLRenderPass::PASS_SHINY };
  1658. U32 num_types = LL_ARRAY_SIZE(types);
  1660. GLuint stencil_mask = 0xFFFFFFFF;
  1661. //stencil in volumes
  1662. gGL.flush();
  1663. {
  1664. glStencilMask(stencil_mask);
  1665. glClearStencil(1);
  1666. glClear(GL_STENCIL_BUFFER_BIT);
  1667. LLGLEnable cull_face(GL_CULL_FACE);
  1668. LLGLEnable stencil(GL_STENCIL_TEST);
  1669. LLGLDepthTest depth (GL_TRUE, GL_FALSE, GL_ALWAYS);
  1670. glStencilFunc(GL_ALWAYS, 0, stencil_mask);
  1671. gGL.setColorMask(false, false);
  1672. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1673. glColor4f(1,1,1,1);
  1675. //setup clip plane
  1676. normal = normal * grid_rotation;
  1677. if (normal * (LLViewerCamera::getInstance()->getOrigin()-selection_center) < 0)
  1678. {
  1679. normal = -normal;
  1680. }
  1681. F32 d = -(selection_center * normal);
  1682. F64 plane[] = { normal.mV[0], normal.mV[1], normal.mV[2], d };
  1683. LLGLEnable clip(GL_CLIP_PLANE0);
  1684. glClipPlane(GL_CLIP_PLANE0, plane);
  1686. BOOL particles = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES);
  1687. BOOL clouds = gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_CLOUDS);
  1689. if (particles)
  1690. {
  1691. LLPipeline::toggleRenderType(LLPipeline::RENDER_TYPE_PARTICLES);
  1692. }
  1693. if (clouds)
  1694. {
  1695. LLPipeline::toggleRenderType(LLPipeline::RENDER_TYPE_CLOUDS);
  1696. }
  1698. //stencil in volumes
  1699. glStencilOp(GL_INCR, GL_INCR, GL_INCR);
  1700. glCullFace(GL_FRONT);
  1701. for (U32 i = 0; i < num_types; i++)
  1702. {
  1703. gPipeline.renderObjects(types[i], LLVertexBuffer::MAP_VERTEX, FALSE);
  1704. }
  1706. glStencilOp(GL_DECR, GL_DECR, GL_DECR);
  1707. glCullFace(GL_BACK);
  1708. for (U32 i = 0; i < num_types; i++)
  1709. {
  1710. gPipeline.renderObjects(types[i], LLVertexBuffer::MAP_VERTEX, FALSE);
  1711. }
  1713. if (particles)
  1714. {
  1715. LLPipeline::toggleRenderType(LLPipeline::RENDER_TYPE_PARTICLES);
  1716. }
  1717. if (clouds)
  1718. {
  1719. LLPipeline::toggleRenderType(LLPipeline::RENDER_TYPE_CLOUDS);
  1720. }
  1722. gGL.setColorMask(true, false);
  1723. }
  1724. gGL.color4f(1,1,1,1);
  1726. gGL.pushMatrix();
  1728. F32 x,y,z,angle_radians;
  1729. grid_rotation.getAngleAxis(&angle_radians, &x, &y, &z);
  1730. gGL.translatef(selection_center.mV[VX], selection_center.mV[VY], selection_center.mV[VZ]);
  1731. glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
  1733. F32 sz = mGridSizeMeters;
  1734. F32 tiles = sz;
  1736. //draw volume/plane intersections
  1737. {
  1738. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1739. LLGLDepthTest depth(GL_FALSE);
  1740. LLGLEnable stencil(GL_STENCIL_TEST);
  1741. glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  1742. glStencilFunc(GL_EQUAL, 0, stencil_mask);
  1743. renderGrid(0,0,tiles,inner_color.mV[0], inner_color.mV[1], inner_color.mV[2], 0.25f);
  1744. }
  1746. glStencilFunc(GL_ALWAYS, 255, 0xFFFFFFFF);
  1747. glStencilMask(0xFFFFFFFF);
  1748. glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
  1750. gGL.popMatrix();
  1751. }
  1753. void LLManipTranslate::renderText()
  1754. {
  1755. if (mObjectSelection->getRootObjectCount() && !mObjectSelection->isAttachment())
  1756. {
  1757. LLVector3 pos = getPivotPoint();
  1758. renderXYZ(pos);
  1759. }
  1760. else
  1761. {
  1762. const BOOL children_ok = TRUE;
  1763. LLViewerObject* objectp = mObjectSelection->getFirstRootObject(children_ok);
  1764. if (objectp)
  1765. {
  1766. renderXYZ(objectp->getPositionEdit());
  1767. }
  1768. }
  1769. }
  1771. void LLManipTranslate::renderTranslationHandles()
  1772. {
  1773. LLVector3 grid_origin;
  1774. LLVector3 grid_scale;
  1775. LLQuaternion grid_rotation;
  1776. LLGLDepthTest gls_depth(GL_FALSE);
  1778. LLSelectMgr::getInstance()->getGrid(grid_origin, grid_rotation, grid_scale);
  1779. LLVector3 at_axis;
  1780. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1781. {
  1782. at_axis = LLVector3::x_axis * ~grid_rotation;
  1783. }
  1784. else
  1785. {
  1786. at_axis = LLViewerCamera::getInstance()->getAtAxis() * ~grid_rotation;
  1787. }
  1789. if (at_axis.mV[VX] > 0.f)
  1790. {
  1791. mPlaneManipPositions.mV[VX] = 1.f;
  1792. }
  1793. else
  1794. {
  1795. mPlaneManipPositions.mV[VX] = -1.f;
  1796. }
  1798. if (at_axis.mV[VY] > 0.f)
  1799. {
  1800. mPlaneManipPositions.mV[VY] = 1.f;
  1801. }
  1802. else
  1803. {
  1804. mPlaneManipPositions.mV[VY] = -1.f;
  1805. }
  1807. if (at_axis.mV[VZ] > 0.f)
  1808. {
  1809. mPlaneManipPositions.mV[VZ] = 1.f;
  1810. }
  1811. else
  1812. {
  1813. mPlaneManipPositions.mV[VZ] = -1.f;
  1814. }
  1816. LLViewerObject *first_object = mObjectSelection->getFirstMoveableObject(TRUE);
  1817. if (!first_object) return;
  1819. LLVector3 selection_center = getPivotPoint();
  1821. // Drag handles 
  1822. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1823. {
  1824. mArrowLengthMeters = mAxisArrowLength / gViewerWindow->getWorldViewHeightRaw();
  1825. mArrowLengthMeters /= gAgent.mHUDCurZoom;
  1826. }
  1827. else
  1828. {
  1829. LLVector3 camera_pos_agent = gAgent.getCameraPositionAgent();
  1830. F32 range = dist_vec(camera_pos_agent, selection_center);
  1831. F32 range_from_agent = dist_vec(gAgent.getPositionAgent(), selection_center);
  1833. // Don't draw handles if you're too far away
  1834. if (gSavedSettings.getBOOL("LimitSelectDistance"))
  1835. {
  1836. if (range_from_agent > gSavedSettings.getF32("MaxSelectDistance"))
  1837. {
  1838. return;
  1839. }
  1840. }
  1842. if (range > 0.001f)
  1843. {
  1844. // range != zero
  1845. F32 fraction_of_fov = mAxisArrowLength / (F32) LLViewerCamera::getInstance()->getViewHeightInPixels();
  1846. F32 apparent_angle = fraction_of_fov * LLViewerCamera::getInstance()->getView();  // radians
  1847. mArrowLengthMeters = range * tan(apparent_angle);
  1848. }
  1849. else
  1850. {
  1851. // range == zero
  1852. mArrowLengthMeters = 1.0f;
  1853. }
  1854. }
  1856. mPlaneManipOffsetMeters = mArrowLengthMeters * 1.8f;
  1857. mGridSizeMeters = gSavedSettings.getF32("GridDrawSize");
  1858. mConeSize = mArrowLengthMeters / 4.f;
  1860. glMatrixMode(GL_MODELVIEW);
  1861. gGL.pushMatrix();
  1862. {
  1863. gGL.translatef(selection_center.mV[VX], selection_center.mV[VY], selection_center.mV[VZ]);
  1865. F32 angle_radians, x, y, z;
  1866. grid_rotation.getAngleAxis(&angle_radians, &x, &y, &z);
  1868. glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
  1870. LLQuaternion invRotation = grid_rotation;
  1871. invRotation.conjQuat();
  1873. LLVector3 relative_camera_dir;
  1875. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1876. {
  1877. relative_camera_dir = LLVector3::x_axis * invRotation;
  1878. }
  1879. else
  1880. {
  1881. relative_camera_dir = (selection_center - LLViewerCamera::getInstance()->getOrigin()) * invRotation;
  1882. }
  1883. relative_camera_dir.normVec();
  1885. {
  1886. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  1887. LLGLDisable cull_face(GL_CULL_FACE);
  1889. LLColor4 color1;
  1890. LLColor4 color2;
  1892. // update manipulator sizes
  1893. for (S32 index = 0; index < 3; index++)
  1894. {
  1895. if (index == mManipPart - LL_X_ARROW || index == mHighlightedPart - LL_X_ARROW)
  1896. {
  1897. mArrowScales.mV[index] = lerp(mArrowScales.mV[index], SELECTED_ARROW_SCALE, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1898. mPlaneScales.mV[index] = lerp(mPlaneScales.mV[index], 1.f, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1899. }
  1900. else if (index == mManipPart - LL_YZ_PLANE || index == mHighlightedPart - LL_YZ_PLANE)
  1901. {
  1902. mArrowScales.mV[index] = lerp(mArrowScales.mV[index], 1.f, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1903. mPlaneScales.mV[index] = lerp(mPlaneScales.mV[index], SELECTED_ARROW_SCALE, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1904. }
  1905. else
  1906. {
  1907. mArrowScales.mV[index] = lerp(mArrowScales.mV[index], 1.f, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1908. mPlaneScales.mV[index] = lerp(mPlaneScales.mV[index], 1.f, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE ));
  1909. }
  1910. }
  1912. if ((mManipPart == LL_NO_PART || mManipPart == LL_YZ_PLANE) && llabs(relative_camera_dir.mV[VX]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  1913. {
  1914. // render YZ plane manipulator
  1915. gGL.pushMatrix();
  1916. glScalef(mPlaneManipPositions.mV[VX], mPlaneManipPositions.mV[VY], mPlaneManipPositions.mV[VZ]);
  1917. gGL.translatef(0.f, mPlaneManipOffsetMeters, mPlaneManipOffsetMeters);
  1918. glScalef(mPlaneScales.mV[VX], mPlaneScales.mV[VX], mPlaneScales.mV[VX]);
  1919. if (mHighlightedPart == LL_YZ_PLANE)
  1920. {
  1921. color1.setVec(0.f, 1.f, 0.f, 1.f);
  1922. color2.setVec(0.f, 0.f, 1.f, 1.f);
  1923. }
  1924. else
  1925. {
  1926. color1.setVec(0.f, 1.f, 0.f, 0.6f);
  1927. color2.setVec(0.f, 0.f, 1.f, 0.6f);
  1928. }
  1929. gGL.begin(LLRender::TRIANGLES);
  1930. {
  1931. gGL.color4fv(color1.mV);
  1932. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f));
  1933. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f));
  1934. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1936. gGL.color4fv(color2.mV);
  1937. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1938. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f), mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1939. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f));
  1940. }
  1941. gGL.end();
  1943. LLUI::setLineWidth(3.0f);
  1944. gGL.begin(LLRender::LINES);
  1945. {
  1946. gGL.color4f(0.f, 0.f, 0.f, 0.3f);
  1947. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  1948. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  1949. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  1950. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.1f,   mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.1f);
  1951. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  1952. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.1f,   mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.4f);
  1954. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  1955. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  1956. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  1957. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.1f,  mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.1f);
  1958. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  1959. gGL.vertex3f(0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.4f,  mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.1f);
  1960. }
  1961. gGL.end();
  1962. LLUI::setLineWidth(1.0f);
  1963. gGL.popMatrix();
  1964. }
  1966. if ((mManipPart == LL_NO_PART || mManipPart == LL_XZ_PLANE) && llabs(relative_camera_dir.mV[VY]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  1967. {
  1968. // render XZ plane manipulator
  1969. gGL.pushMatrix();
  1970. glScalef(mPlaneManipPositions.mV[VX], mPlaneManipPositions.mV[VY], mPlaneManipPositions.mV[VZ]);
  1971. gGL.translatef(mPlaneManipOffsetMeters, 0.f, mPlaneManipOffsetMeters);
  1972. glScalef(mPlaneScales.mV[VY], mPlaneScales.mV[VY], mPlaneScales.mV[VY]);
  1973. if (mHighlightedPart == LL_XZ_PLANE)
  1974. {
  1975. color1.setVec(0.f, 0.f, 1.f, 1.f);
  1976. color2.setVec(1.f, 0.f, 0.f, 1.f);
  1977. }
  1978. else
  1979. {
  1980. color1.setVec(0.f, 0.f, 1.f, 0.6f);
  1981. color2.setVec(1.f, 0.f, 0.f, 0.6f);
  1982. }
  1984. gGL.begin(LLRender::TRIANGLES);
  1985. {
  1986. gGL.color4fv(color1.mV);
  1987. gGL.vertex3f(mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), 0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1988. gGL.vertex3f(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f), 0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1989. gGL.vertex3f(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), 0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f));
  1991. gGL.color4fv(color2.mV);
  1992. gGL.vertex3f(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), 0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f));
  1993. gGL.vertex3f(mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), 0.f, mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f));
  1994. gGL.vertex3f(mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f), 0.f, mPlaneManipOffsetMeters * (PLANE_TICK_SIZE * 0.25f));
  1995. }
  1996. gGL.end();
  1998. LLUI::setLineWidth(3.0f);
  1999. gGL.begin(LLRender::LINES);
  2000. {
  2001. gGL.color4f(0.f, 0.f, 0.f, 0.3f);
  2002. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  2003. gGL.vertex3f(mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  2004. gGL.vertex3f(mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  2005. gGL.vertex3f(mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.1f,   0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.1f);
  2006. gGL.vertex3f(mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.25f,  0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  2007. gGL.vertex3f(mPlaneManipOffsetMeters * PLANE_TICK_SIZE  * 0.1f,   0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.4f);
  2009. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  0.f, mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f);
  2010. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  2011. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  2012. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.1f,   0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.1f);
  2013. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.25f,  0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.25f);
  2014. gGL.vertex3f(mPlaneManipOffsetMeters * -PLANE_TICK_SIZE * 0.4f,   0.f, mPlaneManipOffsetMeters * PLANE_TICK_SIZE * 0.1f);
  2015. }
  2016. gGL.end();
  2017. LLUI::setLineWidth(1.0f);
  2019. gGL.popMatrix();
  2020. }
  2022. if ((mManipPart == LL_NO_PART || mManipPart == LL_XY_PLANE) && llabs(relative_camera_dir.mV[VZ]) > MIN_PLANE_MANIP_DOT_PRODUCT)
  2023. {
  2024. // render XY plane manipulator
  2025. gGL.pushMatrix();
  2026. glScalef(mPlaneManipPositions.mV[VX], mPlaneManipPositions.mV[VY], mPlaneManipPositions.mV[VZ]);
  2028. /*     Y
  2029.     ^
  2030.     v1
  2031.     |   
  2032.     |<- v0
  2033.     |  /|  
  2034.     v2__v__v3 > X
  2035. */
  2036. LLVector3 v0,v1,v2,v3;
  2037. #if 0
  2038. // This should theoretically work but looks off; could be tuned later -SJB
  2039. gGL.translatef(-mPlaneManipOffsetMeters, -mPlaneManipOffsetMeters, 0.f);
  2040. v0 = LLVector3(mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), 0.f);
  2041. v1 = LLVector3(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.75f), 0.f);
  2042. v2 = LLVector3(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), 0.f);
  2043. v3 = LLVector3(mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.75f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), 0.f);
  2044. #else
  2045. gGL.translatef(mPlaneManipOffsetMeters, mPlaneManipOffsetMeters, 0.f);
  2046. v0 = LLVector3(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.25f), 0.f);
  2047. v1 = LLVector3(mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f), 0.f);
  2048. v2 = LLVector3(mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), 0.f);
  2049. v3 = LLVector3(mPlaneManipOffsetMeters * (-PLANE_TICK_SIZE * 0.75f), mPlaneManipOffsetMeters * ( PLANE_TICK_SIZE * 0.25f), 0.f);
  2050. #endif
  2051. glScalef(mPlaneScales.mV[VZ], mPlaneScales.mV[VZ], mPlaneScales.mV[VZ]);
  2052. if (mHighlightedPart == LL_XY_PLANE)
  2053. {
  2054. color1.setVec(1.f, 0.f, 0.f, 1.f);
  2055. color2.setVec(0.f, 1.f, 0.f, 1.f);
  2056. }
  2057. else
  2058. {
  2059. color1.setVec(0.8f, 0.f, 0.f, 0.6f);
  2060. color2.setVec(0.f, 0.8f, 0.f, 0.6f);
  2061. }
  2063. gGL.begin(LLRender::TRIANGLES);
  2064. {
  2065. gGL.color4fv(color1.mV);
  2066. gGL.vertex3fv(v0.mV);
  2067. gGL.vertex3fv(v1.mV);
  2068. gGL.vertex3fv(v2.mV);
  2070. gGL.color4fv(color2.mV);
  2071. gGL.vertex3fv(v2.mV);
  2072. gGL.vertex3fv(v3.mV);
  2073. gGL.vertex3fv(v0.mV);
  2074. }
  2075. gGL.end();
  2077. LLUI::setLineWidth(3.0f);
  2078. gGL.begin(LLRender::LINES);
  2079. {
  2080. gGL.color4f(0.f, 0.f, 0.f, 0.3f);
  2081. LLVector3 v12 = (v1 + v2) * .5f;
  2082. gGL.vertex3fv(v0.mV);
  2083. gGL.vertex3fv(v12.mV);
  2084. gGL.vertex3fv(v12.mV);
  2085. gGL.vertex3fv((v12 + (v0-v12)*.3f + (v2-v12)*.3f).mV);
  2086. gGL.vertex3fv(v12.mV);
  2087. gGL.vertex3fv((v12 + (v0-v12)*.3f + (v1-v12)*.3f).mV);
  2089. LLVector3 v23 = (v2 + v3) * .5f;
  2090. gGL.vertex3fv(v0.mV);
  2091. gGL.vertex3fv(v23.mV);
  2092. gGL.vertex3fv(v23.mV);
  2093. gGL.vertex3fv((v23 + (v0-v23)*.3f + (v3-v23)*.3f).mV);
  2094. gGL.vertex3fv(v23.mV);
  2095. gGL.vertex3fv((v23 + (v0-v23)*.3f + (v2-v23)*.3f).mV);
  2096. }
  2097. gGL.end();
  2098. LLUI::setLineWidth(1.0f);
  2100. gGL.popMatrix();
  2101. }
  2102. }
  2103. {
  2104. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  2106. // Since we draw handles with depth testing off, we need to draw them in the 
  2107. // proper depth order.
  2109. // Copied from LLDrawable::updateGeometry
  2110. LLVector3 pos_agent     = first_object->getPositionAgent();
  2111. LLVector3 camera_agent = gAgent.getCameraPositionAgent();
  2112. LLVector3 headPos = pos_agent - camera_agent;
  2114. LLVector3 orientWRTHead    = headPos * invRotation;
  2116. // Find nearest vertex
  2117. U32 nearest = (orientWRTHead.mV[0] < 0.0f ? 1 : 0) + 
  2118. (orientWRTHead.mV[1] < 0.0f ? 2 : 0) + 
  2119. (orientWRTHead.mV[2] < 0.0f ? 4 : 0);
  2121. // opposite faces on Linden cubes:
  2122. // 0 & 5
  2123. // 1 & 3
  2124. // 2 & 4
  2126. // Table of order to draw faces, based on nearest vertex
  2127. static U32 face_list[8][NUM_AXES*2] = { 
  2128. { 2,0,1, 4,5,3 }, // v6  F201 F453
  2129. { 2,0,3, 4,5,1 }, // v7  F203 F451
  2130. { 4,0,1, 2,5,3 }, // v5  F401 F253
  2131. { 4,0,3, 2,5,1 }, // v4  F403 F251
  2132. { 2,5,1, 4,0,3 }, // v2  F251 F403
  2133. { 2,5,3, 4,0,1 }, // v3  F253 F401
  2134. { 4,5,1, 2,0,3 }, // v1  F451 F203
  2135. { 4,5,3, 2,0,1 }, // v0  F453 F201
  2136. };
  2137. static const EManipPart which_arrow[6] = {
  2138. LL_Z_ARROW,
  2139. LL_X_ARROW,
  2140. LL_Y_ARROW,
  2141. LL_X_ARROW,
  2142. LL_Y_ARROW,
  2143. LL_Z_ARROW};
  2145. // draw arrows for deeper faces first, closer faces last
  2146. LLVector3 camera_axis;
  2147. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  2148. {
  2149. camera_axis = LLVector3::x_axis;
  2150. }
  2151. else
  2152. {
  2153. camera_axis.setVec(gAgent.getCameraPositionAgent() - first_object->getPositionAgent());
  2154. }
  2156. for (U32 i = 0; i < NUM_AXES*2; i++)
  2157. {
  2158. U32 face = face_list[nearest][i];
  2160. LLVector3 arrow_axis;
  2161. getManipAxis(first_object, which_arrow[face], arrow_axis);
  2163. renderArrow(which_arrow[face],
  2164. mManipPart,
  2165. (face >= 3) ? -mConeSize : mConeSize,
  2166. (face >= 3) ? -mArrowLengthMeters : mArrowLengthMeters,
  2167. mConeSize,
  2168. FALSE);
  2169. }
  2170. }
  2171. }
  2172. gGL.popMatrix();
  2173. }
  2176. void LLManipTranslate::renderArrow(S32 which_arrow, S32 selected_arrow, F32 box_size, F32 arrow_size, F32 handle_size, BOOL reverse_direction)
  2177. {
  2178. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  2179. LLGLEnable gls_blend(GL_BLEND);
  2180. LLGLEnable gls_color_material(GL_COLOR_MATERIAL);
  2182. for (S32 pass = 1; pass <= 2; pass++)
  2183. {
  2184. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE, pass == 1 ? GL_LEQUAL : GL_GREATER);
  2185. gGL.pushMatrix();
  2187. S32 index = 0;
  2189. index = ARROW_TO_AXIS[which_arrow];
  2191. // assign a color for this arrow
  2192. LLColor4 color;  // black
  2193. if (which_arrow == selected_arrow || which_arrow == mHighlightedPart)
  2194. {
  2195. color.mV[index] = (pass == 1) ? 1.f : 0.5f;
  2196. }
  2197. else if (selected_arrow != LL_NO_PART)
  2198. {
  2199. color.mV[VALPHA] = 0.f;
  2200. }
  2201. else 
  2202. {
  2203. color.mV[index] = pass == 1 ? .8f : .35f ; // red, green, or blue
  2204. color.mV[VALPHA] = 0.6f;
  2205. }
  2206. gGL.color4fv( color.mV );
  2208. LLVector3 vec;
  2210. {
  2211. LLUI::setLineWidth(2.0f);
  2212. gGL.begin(LLRender::LINES);
  2213. vec.mV[index] = box_size;
  2214. gGL.vertex3f(vec.mV[0], vec.mV[1], vec.mV[2]);
  2216. vec.mV[index] = arrow_size;
  2217. gGL.vertex3f(vec.mV[0], vec.mV[1], vec.mV[2]);
  2218. gGL.end();
  2219. LLUI::setLineWidth(1.0f);
  2220. }
  2222. gGL.translatef(vec.mV[0], vec.mV[1], vec.mV[2]);
  2223. glScalef(handle_size, handle_size, handle_size);
  2225. F32 rot = 0.0f;
  2226. LLVector3 axis;
  2228. switch(which_arrow)
  2229. {
  2230. case LL_X_ARROW:
  2231. rot = reverse_direction ? -90.0f : 90.0f;
  2232. axis.mV[1] = 1.0f;
  2233. break;
  2234. case LL_Y_ARROW:
  2235. rot = reverse_direction ? 90.0f : -90.0f;
  2236. axis.mV[0] = 1.0f;
  2237. break;
  2238. case LL_Z_ARROW:
  2239. rot = reverse_direction ? 180.0f : 0.0f;
  2240. axis.mV[0] = 1.0f;
  2241. break;
  2242. default:
  2243. llerrs << "renderArrow called with bad arrow " << which_arrow << llendl;
  2244. break;
  2245. }
  2247. glColor4fv(color.mV);
  2248. glRotatef(rot, axis.mV[0], axis.mV[1], axis.mV[2]);
  2249. glScalef(mArrowScales.mV[index], mArrowScales.mV[index], mArrowScales.mV[index] * 1.5f);
  2251. gCone.render(CONE_LOD_HIGHEST);
  2253. gGL.popMatrix();
  2254. }
  2255. }
  2257. void LLManipTranslate::renderGridVert(F32 x_trans, F32 y_trans, F32 r, F32 g, F32 b, F32 alpha)
  2258. {
  2259. gGL.color4f(r, g, b, alpha);
  2260. switch (mManipPart)
  2261. {
  2262. case LL_YZ_PLANE:
  2263. gGL.vertex3f(0, x_trans, y_trans);
  2264. break;
  2265. case LL_XZ_PLANE:
  2266. gGL.vertex3f(x_trans, 0, y_trans);
  2267. break;
  2268. case LL_XY_PLANE:
  2269. gGL.vertex3f(x_trans, y_trans, 0);
  2270. break;
  2271. default:
  2272. gGL.vertex3f(0,0,0);
  2273. break;
  2274. }
  2276. }
  2278. // virtual
  2279. BOOL LLManipTranslate::canAffectSelection()
  2280. {
  2281. BOOL can_move = mObjectSelection->getObjectCount() != 0;
  2282. if (can_move)
  2283. {
  2284. struct f : public LLSelectedObjectFunctor
  2285. {
  2286. virtual bool apply(LLViewerObject* objectp)
  2287. {
  2288. return objectp->permMove() && (objectp->permModify() || !gSavedSettings.getBOOL("EditLinkedParts"));
  2289. }
  2290. } func;
  2291. can_move = mObjectSelection->applyToObjects(&func);
  2292. }
  2293. return can_move;
  2294. }