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

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

游戏引擎

开发平台：

C++ Builder

llmanipscale.cpp：源码内容
  1. /** 
  2.  * @file llmanipscale.cpp
  3.  * @brief LLManipScale 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 "llmanipscale.h"
  37. // library includes
  38. #include "llmath.h"
  39. #include "v3math.h"
  40. #include "llquaternion.h"
  41. #include "llgl.h"
  42. #include "llrender.h"
  43. #include "v4color.h"
  44. #include "llprimitive.h"
  46. // viewer includes
  47. #include "llagent.h"
  48. #include "llbbox.h"
  49. #include "llbox.h"
  50. #include "llviewercontrol.h"
  51. #include "llcriticaldamp.h"
  52. #include "lldrawable.h"
  53. #include "llfloatertools.h"
  54. #include "llglheaders.h"
  55. #include "llselectmgr.h"
  56. #include "llstatusbar.h"
  57. #include "llui.h"
  58. #include "llviewercamera.h"
  59. #include "llviewerobject.h"
  60. #include "llviewerwindow.h"
  61. #include "llhudrender.h"
  62. #include "llworld.h"
  63. #include "v2math.h"
  64. #include "llvoavatar.h"
  67. const F32 MAX_MANIP_SELECT_DISTANCE_SQUARED = 11.f * 11.f;
  68. const F32 SNAP_GUIDE_SCREEN_OFFSET = 0.05f;
  69. const F32 SNAP_GUIDE_SCREEN_LENGTH = 0.7f;
  70. const F32 SELECTED_MANIPULATOR_SCALE = 1.2f;
  71. const F32 MANIPULATOR_SCALE_HALF_LIFE = 0.07f;
  72. const S32 NUM_MANIPULATORS = 14;
  74. const LLManip::EManipPart MANIPULATOR_IDS[NUM_MANIPULATORS] = 
  75. {
  76. LLManip::LL_CORNER_NNN,
  77. LLManip::LL_CORNER_NNP,
  78. LLManip::LL_CORNER_NPN,
  79. LLManip::LL_CORNER_NPP,
  80. LLManip::LL_CORNER_PNN,
  81. LLManip::LL_CORNER_PNP,
  82. LLManip::LL_CORNER_PPN,
  83. LLManip::LL_CORNER_PPP,
  84. LLManip::LL_FACE_POSZ,
  85. LLManip::LL_FACE_POSX,
  86. LLManip::LL_FACE_POSY,
  87. LLManip::LL_FACE_NEGX,
  88. LLManip::LL_FACE_NEGY,
  89. LLManip::LL_FACE_NEGZ
  90. };
  94. // static
  95. void LLManipScale::setUniform(BOOL b)
  96. {
  97. gSavedSettings.setBOOL("ScaleUniform", b);
  98. }
  100. // static
  101. void LLManipScale::setShowAxes(BOOL b)
  102. {
  103. gSavedSettings.setBOOL("ScaleShowAxes", b);
  104. }
  106. // static
  107. void LLManipScale::setStretchTextures(BOOL b)
  108. {
  109. gSavedSettings.setBOOL("ScaleStretchTextures", b);
  110. }
  112. // static
  113. BOOL LLManipScale::getUniform()
  114. {
  115. return gSavedSettings.getBOOL("ScaleUniform");
  116. }
  118. // static
  119. BOOL LLManipScale::getShowAxes()
  120. {
  121. return gSavedSettings.getBOOL("ScaleShowAxes");
  122. }
  124. // static
  125. BOOL LLManipScale::getStretchTextures()
  126. {
  127. return gSavedSettings.getBOOL("ScaleStretchTextures");
  128. }
  130. inline void LLManipScale::conditionalHighlight( U32 part, const LLColor4* highlight, const LLColor4* normal )
  131. {
  132. LLColor4 default_highlight( 1.f, 1.f, 1.f, 1.f );
  133. LLColor4 default_normal( 0.7f, 0.7f, 0.7f, 0.6f );
  134. LLColor4 invisible(0.f, 0.f, 0.f, 0.f);
  135. F32 manipulator_scale = 1.f;
  137. for (S32 i = 0; i < NUM_MANIPULATORS; i++)
  138. {
  139. if((U32)MANIPULATOR_IDS[i] == part)
  140. {
  141. manipulator_scale = mManipulatorScales[i];
  142. break;
  143. }
  144. }
  146. mScaledBoxHandleSize = mBoxHandleSize * manipulator_scale;
  147. if (mManipPart != (S32)LL_NO_PART && mManipPart != (S32)part)
  148. {
  149. gGL.color4fv( invisible.mV );
  150. }
  151. else if( mHighlightedPart == (S32)part )
  152. {
  153. gGL.color4fv( highlight ? highlight->mV : default_highlight.mV );
  154. }
  155. else
  156. {
  157. gGL.color4fv( normal ? normal->mV : default_normal.mV  );
  158. }
  159. }
  161. void LLManipScale::handleSelect()
  162. {
  163. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  164. updateSnapGuides(bbox);
  165. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK);
  166. gFloaterTools->setStatusText("scale");
  167. LLManip::handleSelect();
  168. }
  170. LLManipScale::LLManipScale( LLToolComposite* composite )
  171. : 
  172. LLManip( std::string("Scale"), composite ),
  173. mBoxHandleSize( 1.f ),
  174. mScaledBoxHandleSize( 1.f ),
  175. mLastMouseX( -1 ),
  176. mLastMouseY( -1 ),
  177. mSendUpdateOnMouseUp( FALSE ),
  178. mLastUpdateFlags( 0 ),
  179. mScaleSnapUnit1(1.f),
  180. mScaleSnapUnit2(1.f),
  181. mSnapRegimeOffset(0.f),
  182. mSnapGuideLength(0.f),
  183. mInSnapRegime(FALSE),
  184. mScaleSnapValue(0.f)
  185. { 
  186. mManipulatorScales = new F32[NUM_MANIPULATORS];
  187. for (S32 i = 0; i < NUM_MANIPULATORS; i++)
  188. {
  189. mManipulatorScales[i] = 1.f;
  190. }
  191. }
  193. LLManipScale::~LLManipScale()
  194. {
  195. for_each(mProjectedManipulators.begin(), mProjectedManipulators.end(), DeletePointer());
  196. delete[] mManipulatorScales;
  197. }
  199. void LLManipScale::render()
  200. {
  201. LLGLSUIDefault gls_ui;
  202. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  203. LLGLDepthTest gls_depth(GL_TRUE);
  204. LLGLEnable gl_blend(GL_BLEND);
  205. LLGLEnable gls_alpha_test(GL_ALPHA_TEST);
  207. if( canAffectSelection() )
  208. {
  209. glMatrixMode(GL_MODELVIEW);
  210. glPushMatrix();
  211. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  212. {
  213. F32 zoom = gAgent.mHUDCurZoom;
  214. glScalef(zoom, zoom, zoom);
  215. }
  217. ////////////////////////////////////////////////////////////////////////
  218. // Calculate size of drag handles 
  220. const F32 BOX_HANDLE_BASE_SIZE = 50.0f;   // box size in pixels = BOX_HANDLE_BASE_SIZE * BOX_HANDLE_BASE_FACTOR
  221. const F32 BOX_HANDLE_BASE_FACTOR = 0.2f;
  223. LLVector3 center_agent = gAgent.getPosAgentFromGlobal(LLSelectMgr::getInstance()->getSelectionCenterGlobal());
  225. F32 range;
  226. F32 range_from_agent;
  227. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  228. {
  229. mBoxHandleSize = BOX_HANDLE_BASE_SIZE * BOX_HANDLE_BASE_FACTOR / (F32) LLViewerCamera::getInstance()->getViewHeightInPixels();
  230. mBoxHandleSize /= gAgent.mHUDCurZoom;
  231. }
  232. else
  233. {
  234. range = dist_vec(gAgent.getCameraPositionAgent(), center_agent);
  235. range_from_agent = dist_vec(gAgent.getPositionAgent(), center_agent);
  237. // Don't draw manip if object too far away
  238. if (gSavedSettings.getBOOL("LimitSelectDistance"))
  239. {
  240. F32 max_select_distance = gSavedSettings.getF32("MaxSelectDistance");
  241. if (range_from_agent > max_select_distance)
  242. {
  243. return;
  244. }
  245. }
  247. if (range > 0.001f)
  248. {
  249. // range != zero
  250. F32 fraction_of_fov = BOX_HANDLE_BASE_SIZE / (F32) LLViewerCamera::getInstance()->getViewHeightInPixels();
  251. F32 apparent_angle = fraction_of_fov * LLViewerCamera::getInstance()->getView();  // radians
  252. mBoxHandleSize = range * tan(apparent_angle) * BOX_HANDLE_BASE_FACTOR;
  253. }
  254. else
  255. {
  256. // range == zero
  257. mBoxHandleSize = BOX_HANDLE_BASE_FACTOR;
  258. }
  259. }
  261. ////////////////////////////////////////////////////////////////////////
  262. // Draw bounding box
  264. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  265. LLVector3 pos_agent = bbox.getPositionAgent();
  266. LLQuaternion rot = bbox.getRotation();
  268. glMatrixMode(GL_MODELVIEW);
  269. glPushMatrix();
  270. {
  271. glTranslatef(pos_agent.mV[VX], pos_agent.mV[VY], pos_agent.mV[VZ]);
  273. F32 angle_radians, x, y, z;
  274. rot.getAngleAxis(&angle_radians, &x, &y, &z);
  275. glRotatef(angle_radians * RAD_TO_DEG, x, y, z);
  278. {
  279. LLGLEnable poly_offset(GL_POLYGON_OFFSET_FILL);
  280. glPolygonOffset( -2.f, -2.f);
  282. // JC - Band-aid until edge stretch working similar to side stretch
  283. // in non-uniform.
  284. // renderEdges( bbox );
  286. renderCorners( bbox );
  287. renderFaces( bbox );
  289. if (mManipPart != LL_NO_PART)
  290. {
  291. renderGuidelinesPart( bbox );
  292. }
  294. glPolygonOffset( 0.f, 0.f);
  295. }
  296. }
  297. glPopMatrix();
  299. if (mManipPart != LL_NO_PART)
  300. {
  301. renderSnapGuides(bbox);
  302. }
  303. glPopMatrix();
  305. renderXYZ(bbox.getExtentLocal());
  306. }
  307. }
  309. BOOL LLManipScale::handleMouseDown(S32 x, S32 y, MASK mask)
  310. {
  311. BOOL handled = FALSE;
  313. if(mHighlightedPart != LL_NO_PART)
  314. {
  315. handled = handleMouseDownOnPart( x, y, mask );
  316. }
  318. return handled;
  319. }
  321. // Assumes that one of the arrows on an object was hit.
  322. BOOL LLManipScale::handleMouseDownOnPart( S32 x, S32 y, MASK mask )
  323. {
  324. BOOL can_scale = canAffectSelection();
  325. if (!can_scale)
  326. {
  327. return FALSE;
  328. }
  330. highlightManipulators(x, y);
  331. S32 hit_part = mHighlightedPart;
  333. LLSelectMgr::getInstance()->enableSilhouette(FALSE);
  334. mManipPart = (EManipPart)hit_part;
  336. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  337. LLVector3 box_center_agent = bbox.getCenterAgent();
  338. LLVector3 box_corner_agent = bbox.localToAgent( unitVectorToLocalBBoxExtent( partToUnitVector( mManipPart ), bbox ) );
  340. updateSnapGuides(bbox);
  342. mDragStartPointGlobal = gAgent.getPosGlobalFromAgent(box_corner_agent);
  343. mDragStartCenterGlobal = gAgent.getPosGlobalFromAgent(box_center_agent);
  344. LLVector3 far_corner_agent = bbox.localToAgent( unitVectorToLocalBBoxExtent( -1.f * partToUnitVector( mManipPart ), bbox ) );
  345. mDragFarHitGlobal = gAgent.getPosGlobalFromAgent(far_corner_agent);
  346. mDragPointGlobal = mDragStartPointGlobal;
  348. // we just started a drag, so save initial object positions, orientations, and scales
  349. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_SCALE);
  350. // Route future Mouse messages here preemptively.  (Release on mouse up.)
  351. setMouseCapture( TRUE );
  353. mHelpTextTimer.reset();
  354. sNumTimesHelpTextShown++;
  355. return TRUE;
  356. }
  359. BOOL LLManipScale::handleMouseUp(S32 x, S32 y, MASK mask)
  360. {
  361. // first, perform normal processing in case this was a quick-click
  362. handleHover(x, y, mask);
  364. if( hasMouseCapture() )
  365. {
  366. if( (LL_FACE_MIN <= (S32)mManipPart) 
  367. && ((S32)mManipPart <= LL_FACE_MAX) )
  368. {
  369. sendUpdates(TRUE,TRUE,FALSE);
  370. }
  371. else
  372. if( (LL_CORNER_MIN <= (S32)mManipPart) 
  373. && ((S32)mManipPart <= LL_CORNER_MAX) )
  374. {
  375. sendUpdates(TRUE,TRUE,TRUE);
  376. }
  378. //send texture update
  379. LLSelectMgr::getInstance()->adjustTexturesByScale(TRUE, getStretchTextures());
  381. LLSelectMgr::getInstance()->enableSilhouette(TRUE);
  382. mManipPart = LL_NO_PART;
  384. // Might have missed last update due to UPDATE_DELAY timing
  385. LLSelectMgr::getInstance()->sendMultipleUpdate( mLastUpdateFlags );
  387. //gAgent.setObjectTracking(gSavedSettings.getBOOL("TrackFocusObject"));
  388. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_PICK);
  389. }
  390. return LLManip::handleMouseUp(x, y, mask);
  391. }
  394. BOOL LLManipScale::handleHover(S32 x, S32 y, MASK mask)
  395. {
  396. if( hasMouseCapture() )
  397. {
  398. if( mObjectSelection->isEmpty() )
  399. {
  400. // Somehow the object got deselected while we were dragging it.
  401. setMouseCapture( FALSE );
  402. }
  403. else
  404. {
  405. drag( x, y );
  406. }
  407. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipScale (active)" << llendl;
  408. }
  409. else
  410. {
  411. mInSnapRegime = FALSE;
  412. // not dragging...
  413. highlightManipulators(x, y);
  414. }
  416. // Patch up textures, if possible.
  417. LLSelectMgr::getInstance()->adjustTexturesByScale(FALSE, getStretchTextures());
  419. gViewerWindow->setCursor(UI_CURSOR_TOOLSCALE);
  420. return TRUE;
  421. }
  423. void LLManipScale::highlightManipulators(S32 x, S32 y)
  424. {
  425. mHighlightedPart = LL_NO_PART;
  427. // If we have something selected, try to hit its manipulator handles.
  428. // Don't do this with nothing selected, as it kills the framerate.
  429. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  431. if( canAffectSelection() )
  432. {
  433. LLMatrix4 transform;
  434. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  435. {
  436. LLVector4 translation(bbox.getPositionAgent());
  437. transform.initRotTrans(bbox.getRotation(), translation);
  438. LLMatrix4 cfr(OGL_TO_CFR_ROTATION);
  439. transform *= cfr;
  440. LLMatrix4 window_scale;
  441. F32 zoom_level = 2.f * gAgent.mHUDCurZoom;
  442. window_scale.initAll(LLVector3(zoom_level / LLViewerCamera::getInstance()->getAspect(), zoom_level, 0.f),
  443. LLQuaternion::DEFAULT,
  444. LLVector3::zero);
  445. transform *= window_scale;
  446. }
  447. else
  448. {
  449. LLMatrix4 projMatrix = LLViewerCamera::getInstance()->getProjection();
  450. LLMatrix4 modelView = LLViewerCamera::getInstance()->getModelview();
  451. transform.initAll(LLVector3(1.f, 1.f, 1.f), bbox.getRotation(), bbox.getPositionAgent());
  453. transform *= modelView;
  454. transform *= projMatrix;
  455. }
  457. LLVector3 min = bbox.getMinLocal();
  458. LLVector3 max = bbox.getMaxLocal();
  459. LLVector3 ctr = bbox.getCenterLocal();
  461. S32 numManips = 0;
  462. // corners
  463. mManipulatorVertices[numManips++] = LLVector4(min.mV[VX], min.mV[VY], min.mV[VZ], 1.f);
  464. mManipulatorVertices[numManips++] = LLVector4(min.mV[VX], min.mV[VY], max.mV[VZ], 1.f);
  465. mManipulatorVertices[numManips++] = LLVector4(min.mV[VX], max.mV[VY], min.mV[VZ], 1.f);
  466. mManipulatorVertices[numManips++] = LLVector4(min.mV[VX], max.mV[VY], max.mV[VZ], 1.f);
  467. mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], min.mV[VY], min.mV[VZ], 1.f);
  468. mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], min.mV[VY], max.mV[VZ], 1.f);
  469. mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], max.mV[VY], min.mV[VZ], 1.f);
  470. mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], max.mV[VY], max.mV[VZ], 1.f);
  472. // 1-D highlights are applicable iff one object is selected
  473. if( mObjectSelection->getObjectCount() == 1 )
  474. {
  475. // face centers
  476. mManipulatorVertices[numManips++] = LLVector4(ctr.mV[VX], ctr.mV[VY], max.mV[VZ], 1.f);
  477. mManipulatorVertices[numManips++] = LLVector4(max.mV[VX], ctr.mV[VY], ctr.mV[VZ], 1.f);
  478. mManipulatorVertices[numManips++] = LLVector4(ctr.mV[VX], max.mV[VY], ctr.mV[VZ], 1.f);
  479. mManipulatorVertices[numManips++] = LLVector4(min.mV[VX], ctr.mV[VY], ctr.mV[VZ], 1.f);
  480. mManipulatorVertices[numManips++] = LLVector4(ctr.mV[VX], min.mV[VY], ctr.mV[VZ], 1.f);
  481. mManipulatorVertices[numManips++] = LLVector4(ctr.mV[VX], ctr.mV[VY], min.mV[VZ], 1.f);
  482. }
  484. for_each(mProjectedManipulators.begin(), mProjectedManipulators.end(), DeletePointer());
  485. mProjectedManipulators.clear();
  487. for (S32 i = 0; i < numManips; i++)
  488. {
  489. LLVector4 projectedVertex = mManipulatorVertices[i] * transform;
  490. projectedVertex = projectedVertex * (1.f / projectedVertex.mV[VW]);
  492. ManipulatorHandle* projManipulator = new ManipulatorHandle(LLVector3(projectedVertex.mV[VX], projectedVertex.mV[VY], 
  493. projectedVertex.mV[VZ]), MANIPULATOR_IDS[i], (i < 7) ? SCALE_MANIP_CORNER : SCALE_MANIP_FACE);
  494. mProjectedManipulators.insert(projManipulator);
  495. }
  497. LLRect world_view_rect = gViewerWindow->getWorldViewRectScaled();
  498. F32 half_width = (F32)world_view_rect.getWidth() / 2.f;
  499. F32 half_height = (F32)world_view_rect.getHeight() / 2.f;
  500. LLVector2 manip2d;
  501. LLVector2 mousePos((F32)x - half_width, (F32)y - half_height);
  502. LLVector2 delta;
  504. mHighlightedPart = LL_NO_PART;
  506. for (minpulator_list_t::iterator iter = mProjectedManipulators.begin();
  507.  iter != mProjectedManipulators.end(); ++iter)
  508. {
  509. ManipulatorHandle* manipulator = *iter;
  510. {
  511. manip2d.setVec(manipulator->mPosition.mV[VX] * half_width, manipulator->mPosition.mV[VY] * half_height);
  513. delta = manip2d - mousePos;
  514. if (delta.magVecSquared() < MAX_MANIP_SELECT_DISTANCE_SQUARED)
  515. {
  516. mHighlightedPart = manipulator->mManipID;
  518. //llinfos << "Tried: " << mHighlightedPart << llendl;
  519. break;
  520. }
  521. }
  522. }
  523. }
  525. for (S32 i = 0; i < NUM_MANIPULATORS; i++)
  526. {
  527. if (mHighlightedPart == MANIPULATOR_IDS[i])
  528. {
  529. mManipulatorScales[i] = lerp(mManipulatorScales[i], SELECTED_MANIPULATOR_SCALE, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE));
  530. }
  531. else
  532. {
  533. mManipulatorScales[i] = lerp(mManipulatorScales[i], 1.f, LLCriticalDamp::getInterpolant(MANIPULATOR_SCALE_HALF_LIFE));
  534. }
  535. }
  537. lldebugst(LLERR_USER_INPUT) << "hover handled by LLManipScale (inactive)" << llendl;
  538. }
  541. void LLManipScale::renderFaces( const LLBBox& bbox )
  542. {
  543. // Don't bother to render the drag handles for 1-D scaling if 
  544. // more than one object is selected or if it is an attachment
  545. if ( mObjectSelection->getObjectCount() > 1 )
  546. {
  547. return;
  548. }
  550.     // This is a flattened representation of the box as render here
  551.     //                                       .
  552.     //              (+++)        (++-)      /|t
  553.     //                +------------+         | (texture coordinates)
  554.     //                |            |         |
  555.     //                |     1      |        (*) --->s
  556.     //                |    +X      |   
  557. //                |            |
  558.     // (+++)     (+-+)|            |(+--)     (++-)        (+++)
  559.     //   +------------+------------+------------+------------+
  560.     //   |0          3|3          7|7          4|4          0|
  561.     //   |     0      |     4      |     5      |     2      |
  562.     //   |    +Z      |    -Y      |    -Z      |    +Y      |
  563.     //   |           |            |            |            |
  564.     //   |1          2|2          6|6          5|5          1|
  565.     //   +------------+------------+------------+------------+
  566.     // (-++)     (--+)|            |(---)     (-+-)        (-++)
  567.     //                |     3      |
  568.     //                |    -X      |
  569.     //                |            |
  570.     //                |            |
  571.     //                +------------+
  572.     //              (-++)        (-+-)
  574. LLColor4 highlight_color( 1.f, 1.f, 1.f, 0.5f);
  575. LLColor4 normal_color( 1.f, 1.f, 1.f, 0.3f);
  577. LLColor4 x_highlight_color( 1.f, 0.2f, 0.2f, 1.0f);
  578. LLColor4 x_normal_color( 0.6f, 0.f, 0.f, 0.4f);
  580. LLColor4 y_highlight_color( 0.2f, 1.f, 0.2f, 1.0f);
  581. LLColor4 y_normal_color( 0.f, 0.6f, 0.f, 0.4f);
  583. LLColor4 z_highlight_color( 0.2f, 0.2f, 1.f, 1.0f);
  584. LLColor4 z_normal_color( 0.f, 0.f, 0.6f, 0.4f);
  586. LLColor4 default_normal_color( 0.7f, 0.7f, 0.7f, 0.15f );
  588. const LLVector3& min = bbox.getMinLocal();
  589. const LLVector3& max = bbox.getMaxLocal();
  590. LLVector3 ctr = bbox.getCenterLocal();
  592. if (mManipPart == LL_NO_PART)
  593. {
  594. gGL.color4fv( default_normal_color.mV );
  595. LLGLDepthTest gls_depth(GL_FALSE);
  596. gGL.begin(LLRender::QUADS); 
  597. {
  598. // Face 0
  599. gGL.vertex3f(min.mV[VX], max.mV[VY], max.mV[VZ]);
  600. gGL.vertex3f(min.mV[VX], min.mV[VY], max.mV[VZ]);
  601. gGL.vertex3f(max.mV[VX], min.mV[VY], max.mV[VZ]);
  602. gGL.vertex3f(max.mV[VX], max.mV[VY], max.mV[VZ]);
  604. // Face 1
  605. gGL.vertex3f(max.mV[VX], min.mV[VY], max.mV[VZ]);
  606. gGL.vertex3f(max.mV[VX], min.mV[VY], min.mV[VZ]);
  607. gGL.vertex3f(max.mV[VX], max.mV[VY], min.mV[VZ]);
  608. gGL.vertex3f(max.mV[VX], max.mV[VY], max.mV[VZ]);
  610. // Face 2
  611. gGL.vertex3f(min.mV[VX], max.mV[VY], min.mV[VZ]);
  612. gGL.vertex3f(min.mV[VX], max.mV[VY], max.mV[VZ]);
  613. gGL.vertex3f(max.mV[VX], max.mV[VY], max.mV[VZ]);
  614. gGL.vertex3f(max.mV[VX], max.mV[VY], min.mV[VZ]);
  616. // Face 3
  617. gGL.vertex3f(min.mV[VX], max.mV[VY], max.mV[VZ]);
  618. gGL.vertex3f(min.mV[VX], max.mV[VY], min.mV[VZ]);
  619. gGL.vertex3f(min.mV[VX], min.mV[VY], min.mV[VZ]);
  620. gGL.vertex3f(min.mV[VX], min.mV[VY], max.mV[VZ]);
  622. // Face 4
  623. gGL.vertex3f(min.mV[VX], min.mV[VY], max.mV[VZ]);
  624. gGL.vertex3f(min.mV[VX], min.mV[VY], min.mV[VZ]);
  625. gGL.vertex3f(max.mV[VX], min.mV[VY], min.mV[VZ]);
  626. gGL.vertex3f(max.mV[VX], min.mV[VY], max.mV[VZ]);
  628. // Face 5
  629. gGL.vertex3f(min.mV[VX], min.mV[VY], min.mV[VZ]);
  630. gGL.vertex3f(min.mV[VX], max.mV[VY], min.mV[VZ]);
  631. gGL.vertex3f(max.mV[VX], max.mV[VY], min.mV[VZ]);
  632. gGL.vertex3f(max.mV[VX], min.mV[VY], min.mV[VZ]);
  633. }
  634. gGL.end();
  635. }
  637. // Find nearest vertex
  638. LLVector3 orientWRTHead = bbox.agentToLocalBasis( bbox.getCenterAgent() - gAgent.getCameraPositionAgent() );
  639. U32 nearest = 
  640. (orientWRTHead.mV[0] < 0.0f ? 1 : 0) + 
  641. (orientWRTHead.mV[1] < 0.0f ? 2 : 0) + 
  642. (orientWRTHead.mV[2] < 0.0f ? 4 : 0);
  644. // opposite faces on Linden cubes:
  645. // 0 & 5
  646. // 1 & 3
  647. // 2 & 4
  649. // Table of order to draw faces, based on nearest vertex
  650. static U32 face_list[8][6] = { 
  651. { 2,0,1, 4,5,3 }, // v6  F201 F453
  652. { 2,0,3, 4,5,1 }, // v7  F203 F451
  653. { 4,0,1, 2,5,3 }, // v5  F401 F253
  654. { 4,0,3, 2,5,1 }, // v4  F403 F251
  655. { 2,5,1, 4,0,3 }, // v2  F251 F403
  656. { 2,5,3, 4,0,1 }, // v3  F253 F401
  657. { 4,5,1, 2,0,3 }, // v1  F451 F203
  658. { 4,5,3, 2,0,1 }  // v0  F453 F201
  659. };
  661. {
  662. LLGLDepthTest gls_depth(GL_FALSE);
  664. for (S32 i = 0; i < 6; i++)
  665. {
  666. U32 face = face_list[nearest][i];
  667. switch( face )
  668. {
  669.   case 0:
  670. conditionalHighlight( LL_FACE_POSZ, &z_highlight_color, &z_normal_color );
  671. renderAxisHandle( ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], max.mV[VZ] ) );
  672. break;
  674.   case 1:
  675. conditionalHighlight( LL_FACE_POSX, &x_highlight_color, &x_normal_color );
  676. renderAxisHandle( ctr, LLVector3( max.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
  677. break;
  679.   case 2:
  680. conditionalHighlight( LL_FACE_POSY, &y_highlight_color, &y_normal_color );
  681. renderAxisHandle( ctr, LLVector3( ctr.mV[VX], max.mV[VY], ctr.mV[VZ] ) );
  682. break;
  684.   case 3:
  685. conditionalHighlight( LL_FACE_NEGX, &x_highlight_color, &x_normal_color );
  686. renderAxisHandle( ctr, LLVector3( min.mV[VX], ctr.mV[VY], ctr.mV[VZ] ) );
  687. break;
  689.   case 4:
  690. conditionalHighlight( LL_FACE_NEGY, &y_highlight_color, &y_normal_color );
  691. renderAxisHandle( ctr, LLVector3( ctr.mV[VX], min.mV[VY], ctr.mV[VZ] ) );
  692. break;
  694.   case 5:
  695. conditionalHighlight( LL_FACE_NEGZ, &z_highlight_color, &z_normal_color );
  696. renderAxisHandle( ctr, LLVector3( ctr.mV[VX], ctr.mV[VY], min.mV[VZ] ) );
  697. break;
  698. }
  699. }
  700. }
  701. }
  703. void LLManipScale::renderEdges( const LLBBox& bbox )
  704. {
  705. LLVector3 extent = bbox.getExtentLocal();
  706. F32 edge_width = mBoxHandleSize * .6f;
  708. for( U32 part = LL_EDGE_MIN; part <= LL_EDGE_MAX; part++ )
  709. {
  710. LLVector3 direction = edgeToUnitVector( part );
  711. LLVector3 center_to_edge = unitVectorToLocalBBoxExtent( direction, bbox );
  713. glPushMatrix();
  714. {
  715. glTranslatef( center_to_edge.mV[0], center_to_edge.mV[1], center_to_edge.mV[2] );
  716. conditionalHighlight( part );
  717. glScalef( 
  718. direction.mV[0] ? edge_width : extent.mV[VX],
  719. direction.mV[1] ? edge_width : extent.mV[VY],
  720. direction.mV[2] ? edge_width : extent.mV[VZ] );
  721. gBox.render();
  722. }
  723. glPopMatrix();
  724. }
  725. }
  728. void LLManipScale::renderCorners( const LLBBox& bbox )
  729. {
  730. U32 part = LL_CORNER_NNN;
  732. F32 x_offset = bbox.getMinLocal().mV[VX];
  733. for( S32 i=0; i < 2; i++ )
  734. {
  735. F32 y_offset = bbox.getMinLocal().mV[VY];
  736. for( S32 j=0; j < 2; j++ )
  737. {
  738. F32 z_offset = bbox.getMinLocal().mV[VZ];
  739. for( S32 k=0; k < 2; k++ )
  740. {
  741. conditionalHighlight( part );
  742. renderBoxHandle( x_offset, y_offset, z_offset );
  743. part++;
  745. z_offset = bbox.getMaxLocal().mV[VZ];
  747. }
  748. y_offset = bbox.getMaxLocal().mV[VY];
  749. }
  750. x_offset = bbox.getMaxLocal().mV[VX];
  751.   }
  752. }
  755. void LLManipScale::renderBoxHandle( F32 x, F32 y, F32 z )
  756. {
  757. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  758. LLGLDepthTest gls_depth(GL_FALSE);
  760. glPushMatrix();
  761. {
  762. glTranslatef( x, y, z );
  763. glScalef( mScaledBoxHandleSize, mScaledBoxHandleSize, mScaledBoxHandleSize );
  764. gBox.render();
  765. }
  766. glPopMatrix();
  767. }
  770. void LLManipScale::renderAxisHandle( const LLVector3& start, const LLVector3& end )
  771. {
  772. if( getShowAxes() )
  773. {
  774. // Draws a single "jacks" style handle: a long, retangular box from start to end.
  775. LLVector3 offset_start = end - start;
  776. offset_start.normVec();
  777. offset_start = start + mBoxHandleSize * offset_start;
  779. LLVector3 delta = end - offset_start;
  780. LLVector3 pos = offset_start + 0.5f * delta;
  782. glPushMatrix();
  783. {
  784. glTranslatef( pos.mV[VX], pos.mV[VY], pos.mV[VZ] );
  785. glScalef( 
  786. mBoxHandleSize + llabs(delta.mV[VX]),
  787. mBoxHandleSize + llabs(delta.mV[VY]),
  788. mBoxHandleSize + llabs(delta.mV[VZ]));
  789. gBox.render();
  790. }
  791. glPopMatrix();
  792. }
  793. else
  794. {
  795. renderBoxHandle( end.mV[VX], end.mV[VY], end.mV[VZ] );
  796. }
  797. }
  800. void LLManipScale::drag( S32 x, S32 y )
  801. {
  802. if( (LL_FACE_MIN <= (S32)mManipPart) 
  803. && ((S32)mManipPart <= LL_FACE_MAX) )
  804. {
  805. dragFace( x, y );
  806. }
  807. else
  808. if( (LL_CORNER_MIN <= (S32)mManipPart) 
  809. && ((S32)mManipPart <= LL_CORNER_MAX) )
  810. {
  811. dragCorner( x, y );
  812. }
  814. // store changes to override updates
  815. for (LLObjectSelection::iterator iter = LLSelectMgr::getInstance()->getSelection()->begin();
  816.  iter != LLSelectMgr::getInstance()->getSelection()->end(); iter++)
  817. {
  818. LLSelectNode* selectNode = *iter;
  819. LLViewerObject*cur = selectNode->getObject();
  820. if( cur->permModify() && cur->permMove() && !cur->isAvatar())
  821. {
  822. selectNode->mLastScale = cur->getScale();
  823. selectNode->mLastPositionLocal = cur->getPosition();
  824. }
  825. }
  827. LLSelectMgr::getInstance()->updateSelectionCenter();
  828.     gAgent.clearFocusObject();
  829. }
  831. // Scale around the 
  832. void LLManipScale::dragCorner( S32 x, S32 y )
  833. {
  834. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  836. // Suppress scale if mouse hasn't moved.
  837. if (x == mLastMouseX && y == mLastMouseY)
  838. {
  839. // sendUpdates(TRUE,TRUE,TRUE);
  840. return;
  841. }
  843. mLastMouseX = x;
  844. mLastMouseY = y;
  846. LLVector3d drag_start_point_global = mDragStartPointGlobal;
  847. LLVector3d drag_start_center_global = mDragStartCenterGlobal;
  848. LLVector3 drag_start_point_agent = gAgent.getPosAgentFromGlobal(drag_start_point_global);
  849. LLVector3 drag_start_center_agent = gAgent.getPosAgentFromGlobal(drag_start_center_global);
  851. LLVector3d drag_start_dir_d;
  852. drag_start_dir_d.setVec(drag_start_point_global - drag_start_center_global);
  853. LLVector3 drag_start_dir_f;
  854. drag_start_dir_f.setVec(drag_start_dir_d);
  856. F32 s = 0;
  857. F32 t = 0;
  859. nearestPointOnLineFromMouse(x, y, 
  860. drag_start_center_agent,
  861. drag_start_point_agent,
  862. s, t );
  864. F32 drag_start_dist = dist_vec(drag_start_point_agent, drag_start_center_agent);
  866. if( s <= 0 )  // we only care about intersections in front of the camera
  867. {
  868. return;
  869. }
  871. LLVector3d drag_point_global = drag_start_center_global + t * drag_start_dir_d;
  873. F32 scale_factor = t;
  875. BOOL uniform = LLManipScale::getUniform();
  877. if( !uniform )
  878. {
  879. scale_factor = 0.5f + (scale_factor * 0.5f);
  880. }
  882. // check for snapping
  883. LLVector3 drag_center_agent = gAgent.getPosAgentFromGlobal(drag_point_global);
  884. LLVector3 mouse_on_plane1;
  885. getMousePointOnPlaneAgent(mouse_on_plane1, x, y, drag_center_agent, mScalePlaneNormal1);
  886. LLVector3 mouse_on_plane2;
  887. getMousePointOnPlaneAgent(mouse_on_plane2, x, y, drag_center_agent, mScalePlaneNormal2);
  888. LLVector3 mouse_dir_1 = mouse_on_plane1 - mScaleCenter;
  889. LLVector3 mouse_dir_2 = mouse_on_plane2 - mScaleCenter;
  890. LLVector3 mouse_to_scale_line_1 = mouse_dir_1 - projected_vec(mouse_dir_1, mScaleDir);
  891. LLVector3 mouse_to_scale_line_2 = mouse_dir_2 - projected_vec(mouse_dir_2, mScaleDir);
  892. LLVector3 mouse_to_scale_line_dir_1 = mouse_to_scale_line_1;
  893. mouse_to_scale_line_dir_1.normVec();
  894. if (mouse_to_scale_line_dir_1 * mSnapGuideDir1 < 0.f)
  895. {
  896. // need to keep sign of mouse offset wrt to snap guide direction
  897. mouse_to_scale_line_dir_1 *= -1.f;
  898. }
  899. LLVector3 mouse_to_scale_line_dir_2 = mouse_to_scale_line_2;
  900. mouse_to_scale_line_dir_2.normVec();
  901. if (mouse_to_scale_line_dir_2 * mSnapGuideDir2 < 0.f)
  902. {
  903. // need to keep sign of mouse offset wrt to snap guide direction
  904. mouse_to_scale_line_dir_2 *= -1.f;
  905. }
  907. F32 snap_dir_dot_mouse_offset1 = mSnapGuideDir1 * mouse_to_scale_line_dir_1;
  908. F32 snap_dir_dot_mouse_offset2 = mSnapGuideDir2 * mouse_to_scale_line_dir_2;
  910. F32 dist_from_scale_line_1 = mouse_to_scale_line_1 * mouse_to_scale_line_dir_1; 
  911. F32 dist_from_scale_line_2 = mouse_to_scale_line_2 * mouse_to_scale_line_dir_2;
  913. F32 max_scale = partToMaxScale(mManipPart, bbox);
  914. F32 min_scale = partToMinScale(mManipPart, bbox);
  916. BOOL snap_enabled = gSavedSettings.getBOOL("SnapEnabled");
  917. if (snap_enabled && dist_from_scale_line_1 > mSnapRegimeOffset * snap_dir_dot_mouse_offset1)
  918. {
  919. mInSnapRegime = TRUE;
  920. LLVector3 projected_drag_pos = mouse_on_plane1 - (dist_from_scale_line_1 / snap_dir_dot_mouse_offset1) * mSnapGuideDir1;
  921. F32 drag_dist = (projected_drag_pos - mScaleCenter) * mScaleDir;
  923. F32 cur_subdivisions = llclamp(getSubdivisionLevel(projected_drag_pos, mScaleDir, mScaleSnapUnit1), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  924. F32 snap_dist = mScaleSnapUnit1 / (2.f * cur_subdivisions);
  925. F32 relative_snap_dist = fmodf(drag_dist + snap_dist, mScaleSnapUnit1 / cur_subdivisions);
  927. mScaleSnapValue = llclamp((drag_dist - (relative_snap_dist - snap_dist)), min_scale, max_scale);
  929. scale_factor = mScaleSnapValue / drag_start_dist;
  930. if( !uniform )
  931. {
  932. scale_factor *= 0.5f;
  933. }
  934. }
  935. else if (snap_enabled && dist_from_scale_line_2 > mSnapRegimeOffset * snap_dir_dot_mouse_offset2)
  936. {
  937. mInSnapRegime = TRUE;
  938. LLVector3 projected_drag_pos = mouse_on_plane2 - (dist_from_scale_line_2 / snap_dir_dot_mouse_offset2) * mSnapGuideDir2;
  939. F32 drag_dist = (projected_drag_pos - mScaleCenter) * mScaleDir;
  941. F32 cur_subdivisions = llclamp(getSubdivisionLevel(projected_drag_pos, mScaleDir, mScaleSnapUnit2), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  942. F32 snap_dist = mScaleSnapUnit2 / (2.f * cur_subdivisions);
  943. F32 relative_snap_dist = fmodf(drag_dist + snap_dist, mScaleSnapUnit2 / cur_subdivisions);
  945. mScaleSnapValue = llclamp((drag_dist - (relative_snap_dist - snap_dist)), min_scale, max_scale);
  947. scale_factor = mScaleSnapValue / drag_start_dist;
  948. if( !uniform )
  949. {
  950. scale_factor *= 0.5f;
  951. }
  952. }
  953. else 
  954. {
  955. mInSnapRegime = FALSE;
  956. }
  958. F32 max_scale_factor = DEFAULT_MAX_PRIM_SCALE / MIN_PRIM_SCALE;
  959. F32 min_scale_factor = MIN_PRIM_SCALE / DEFAULT_MAX_PRIM_SCALE;
  961. // find max and min scale factors that will make biggest object hit max absolute scale and smallest object hit min absolute scale
  962. for (LLObjectSelection::iterator iter = mObjectSelection->begin();
  963.  iter != mObjectSelection->end(); iter++)
  964. {
  965. LLSelectNode* selectNode = *iter;
  966. LLViewerObject* cur = selectNode->getObject();
  967. if(  cur->permModify() && cur->permMove() && !cur->isAvatar() )
  968. {
  969. const LLVector3& scale = selectNode->mSavedScale;
  971. F32 cur_max_scale_factor = llmin( DEFAULT_MAX_PRIM_SCALE / scale.mV[VX], DEFAULT_MAX_PRIM_SCALE / scale.mV[VY], DEFAULT_MAX_PRIM_SCALE / scale.mV[VZ] );
  972. max_scale_factor = llmin( max_scale_factor, cur_max_scale_factor );
  974. F32 cur_min_scale_factor = llmax( MIN_PRIM_SCALE / scale.mV[VX], MIN_PRIM_SCALE / scale.mV[VY], MIN_PRIM_SCALE / scale.mV[VZ] );
  975. min_scale_factor = llmax( min_scale_factor, cur_min_scale_factor );
  976. }
  977. }
  979. scale_factor = llclamp( scale_factor, min_scale_factor, max_scale_factor );
  981. LLVector3d drag_global = uniform ? mDragStartCenterGlobal : mDragFarHitGlobal;
  983. // do the root objects i.e. (TRUE == cur->isRootEdit())
  984. for (LLObjectSelection::iterator iter = mObjectSelection->begin();
  985.  iter != mObjectSelection->end(); iter++)
  986. {
  987. LLSelectNode* selectNode = *iter;
  988. LLViewerObject* cur = selectNode->getObject();
  989. if( cur->permModify() && cur->permMove() && !cur->isAvatar() && cur->isRootEdit() )
  990. {
  991. const LLVector3& scale = selectNode->mSavedScale;
  992. cur->setScale( scale_factor * scale );
  994. LLVector3 delta_pos;
  995. LLVector3 original_pos = cur->getPositionEdit();
  996. LLVector3d new_pos_global = drag_global + (selectNode->mSavedPositionGlobal - drag_global) * scale_factor;
  997. if (!cur->isAttachment())
  998. {
  999. new_pos_global = LLWorld::getInstance()->clipToVisibleRegions(selectNode->mSavedPositionGlobal, new_pos_global);
  1000. }
  1001. cur->setPositionAbsoluteGlobal( new_pos_global );
  1002. rebuild(cur);
  1004. delta_pos = cur->getPositionEdit() - original_pos;
  1006. if (selectNode->mIndividualSelection)
  1007. {
  1008. // counter-translate child objects if we are moving the root as an individual
  1009. LLViewerObject::const_child_list_t& child_list = cur->getChildren();
  1010. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1011.  iter != child_list.end(); iter++)
  1012. {
  1013. LLViewerObject* childp = *iter;
  1015. if (cur->isAttachment())
  1016. {
  1017. LLVector3 child_pos = childp->getPosition() - (delta_pos * ~cur->getRotationEdit());
  1018. childp->setPosition(child_pos);
  1019. }
  1020. else
  1021. {
  1022. LLVector3d child_pos_delta(delta_pos);
  1023. // RN: this updates drawable position instantly
  1024. childp->setPositionAbsoluteGlobal(childp->getPositionGlobal() - child_pos_delta);
  1025. }
  1026. rebuild(childp);
  1027. }
  1028. }
  1029. }
  1030. }
  1031. // do the child objects i.e. (FALSE == cur->isRootEdit())
  1032. for (LLObjectSelection::iterator iter = mObjectSelection->begin();
  1033.  iter != mObjectSelection->end(); iter++)
  1034. {
  1035. LLSelectNode* selectNode = *iter;
  1036. LLViewerObject*cur = selectNode->getObject();
  1037. if( cur->permModify() && cur->permMove() && !cur->isAvatar() && !cur->isRootEdit() )
  1038. {
  1039. const LLVector3& scale = selectNode->mSavedScale;
  1040. cur->setScale( scale_factor * scale, FALSE );
  1042. if (!selectNode->mIndividualSelection)
  1043. {
  1044. cur->setPosition(selectNode->mSavedPositionLocal * scale_factor);
  1045. }
  1047. rebuild(cur);
  1048. }
  1049. }
  1053. mDragPointGlobal = drag_point_global;
  1054. }
  1057. void LLManipScale::dragFace( S32 x, S32 y )
  1058. {
  1059. // Suppress scale if mouse hasn't moved.
  1060. if (x == mLastMouseX && y == mLastMouseY)
  1061. {
  1062. // sendUpdates(TRUE,TRUE,FALSE);
  1063. return;
  1064. }
  1066. mLastMouseX = x;
  1067. mLastMouseY = y;
  1069. LLVector3d drag_start_point_global = mDragStartPointGlobal;
  1070. LLVector3d drag_start_center_global = mDragStartCenterGlobal;
  1071. LLVector3 drag_start_point_agent = gAgent.getPosAgentFromGlobal(drag_start_point_global);
  1072. LLVector3 drag_start_center_agent = gAgent.getPosAgentFromGlobal(drag_start_center_global);
  1074. LLVector3d drag_start_dir_d;
  1075. drag_start_dir_d.setVec(drag_start_point_global - drag_start_center_global);
  1076. LLVector3 drag_start_dir_f;
  1077. drag_start_dir_f.setVec(drag_start_dir_d);
  1079. LLBBox bbox = LLSelectMgr::getInstance()->getBBoxOfSelection();
  1081. F32 s = 0;
  1082. F32 t = 0;
  1084. nearestPointOnLineFromMouse(x,
  1085. y,
  1086. drag_start_center_agent,
  1087. drag_start_point_agent,
  1088. s, t );
  1090. if( s <= 0 )  // we only care about intersections in front of the camera
  1091. {
  1092. return;
  1093. }
  1095. LLVector3d drag_point_global = drag_start_center_global + t * drag_start_dir_d;
  1096. LLVector3 part_dir_local = partToUnitVector( mManipPart );
  1098. // check for snapping
  1099. LLVector3 mouse_on_plane;
  1100. getMousePointOnPlaneAgent(mouse_on_plane, x, y, mScaleCenter, mScalePlaneNormal1 );
  1102. LLVector3 mouse_on_scale_line = mScaleCenter + projected_vec(mouse_on_plane - mScaleCenter, mScaleDir);
  1103. LLVector3 drag_delta(mouse_on_scale_line - drag_start_point_agent);
  1104. F32 max_drag_dist = partToMaxScale(mManipPart, bbox);
  1105. F32 min_drag_dist = partToMinScale(mManipPart, bbox);
  1107. BOOL uniform = LLManipScale::getUniform();
  1108. if( uniform )
  1109. {
  1110. drag_delta *= 2.f;
  1111. }
  1113. LLVector3 scale_center_to_mouse = mouse_on_plane - mScaleCenter;
  1114. F32 dist_from_scale_line = dist_vec(scale_center_to_mouse, (mouse_on_scale_line - mScaleCenter));
  1115. F32 dist_along_scale_line = scale_center_to_mouse * mScaleDir;
  1117. BOOL snap_enabled = gSavedSettings.getBOOL("SnapEnabled");
  1119. if (snap_enabled && dist_from_scale_line > mSnapRegimeOffset)
  1120. {
  1121. mInSnapRegime = TRUE;
  1123.   if (dist_along_scale_line > max_drag_dist)
  1124. {
  1125. mScaleSnapValue = max_drag_dist;
  1127. LLVector3 clamp_point = mScaleCenter + max_drag_dist * mScaleDir;
  1128. drag_delta.setVec(clamp_point - drag_start_point_agent);
  1129. }
  1130. else if (dist_along_scale_line < min_drag_dist)
  1131. {
  1132. mScaleSnapValue = min_drag_dist;
  1134. LLVector3 clamp_point = mScaleCenter + min_drag_dist * mScaleDir;
  1135. drag_delta.setVec(clamp_point - drag_start_point_agent);
  1136. }
  1137. else
  1138. {
  1139. F32 drag_dist = scale_center_to_mouse * mScaleDir;
  1140. F32 cur_subdivisions = llclamp(getSubdivisionLevel(mScaleCenter + mScaleDir * drag_dist, mScaleDir, mScaleSnapUnit1), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  1141. F32 snap_dist = mScaleSnapUnit1 / (2.f * cur_subdivisions);
  1142. F32 relative_snap_dist = fmodf(drag_dist + snap_dist, mScaleSnapUnit1 / cur_subdivisions);
  1143. relative_snap_dist -= snap_dist;
  1145. //make sure that values that the scale is "snapped to"
  1146. //do not exceed/go under the applicable max/mins
  1147. //this causes the box to shift displacements ever so slightly
  1148. //although the "snap value" should go down to 0
  1149. //see Jira 1027
  1150. relative_snap_dist = llclamp(relative_snap_dist,
  1151.  drag_dist - max_drag_dist,
  1152.  drag_dist - min_drag_dist);
  1154. mScaleSnapValue = drag_dist - relative_snap_dist;
  1156. if (llabs(relative_snap_dist) < snap_dist)
  1157. {
  1158. LLVector3 drag_correction = relative_snap_dist * mScaleDir;
  1159. if (uniform)
  1160. {
  1161. drag_correction *= 2.f;
  1162. }
  1164. drag_delta -= drag_correction;
  1165. }
  1166. }
  1167. }
  1168. else 
  1169. {
  1170. mInSnapRegime = FALSE;
  1171. }
  1173. BOOL send_scale_update = FALSE;
  1174. BOOL send_position_update = FALSE;
  1176. LLVector3 dir_agent;
  1177. if( part_dir_local.mV[VX] )
  1178. {
  1179. dir_agent = bbox.localToAgentBasis( LLVector3::x_axis );
  1180. }
  1181. else if( part_dir_local.mV[VY] )
  1182. {
  1183. dir_agent = bbox.localToAgentBasis( LLVector3::y_axis );
  1184. }
  1185. else if( part_dir_local.mV[VZ] )
  1186. {
  1187. dir_agent = bbox.localToAgentBasis( LLVector3::z_axis );
  1188. }
  1189. stretchFace( 
  1190. projected_vec(drag_start_dir_f, dir_agent) + drag_start_center_agent,
  1191. projected_vec(drag_delta, dir_agent));
  1192. send_position_update = TRUE;
  1193. send_scale_update = TRUE;
  1195. mDragPointGlobal = drag_point_global;
  1196. }
  1198. void LLManipScale::sendUpdates( BOOL send_position_update, BOOL send_scale_update, BOOL corner )
  1199. {
  1200. // Throttle updates to 10 per second.
  1201. static LLTimer update_timer;
  1202. F32 elapsed_time = update_timer.getElapsedTimeF32();
  1203. const F32 UPDATE_DELAY = 0.1f; //  min time between transmitted updates
  1205. if( send_scale_update || send_position_update )
  1206. {
  1207. U32 update_flags = UPD_NONE;
  1208. if (send_position_update) update_flags |= UPD_POSITION;
  1209. if (send_scale_update) update_flags |= UPD_SCALE;
  1211. //  BOOL send_type = SEND_INDIVIDUALS;
  1212. if (corner)
  1213. {
  1214. update_flags |= UPD_UNIFORM;
  1215. }
  1216. // keep this up to date for sendonmouseup
  1217. mLastUpdateFlags = update_flags;
  1219. // enforce minimum update delay and don't stream updates on sub-object selections
  1220. if( elapsed_time > UPDATE_DELAY && !gSavedSettings.getBOOL("EditLinkedParts") )
  1221. {
  1222. LLSelectMgr::getInstance()->sendMultipleUpdate( update_flags );
  1223. update_timer.reset();
  1224. mSendUpdateOnMouseUp = FALSE;
  1225. }
  1226. else
  1227. {
  1228. mSendUpdateOnMouseUp = TRUE;
  1229. }
  1230. dialog_refresh_all();
  1231. }
  1232. }
  1234. // Rescales in a single dimension.  Either uniform (standard) or one-sided (scale plus translation)
  1235. // depending on mUniform.  Handles multiple selection and objects that are not aligned to the bounding box.
  1236. void LLManipScale::stretchFace( const LLVector3& drag_start_agent, const LLVector3& drag_delta_agent )
  1237. {
  1238. LLVector3 drag_start_center_agent = gAgent.getPosAgentFromGlobal(mDragStartCenterGlobal);
  1240. for (LLObjectSelection::iterator iter = mObjectSelection->begin();
  1241.  iter != mObjectSelection->end(); iter++)
  1242. {
  1243. LLSelectNode* selectNode = *iter;
  1244. LLViewerObject*cur = selectNode->getObject();
  1245. if( cur->permModify() && cur->permMove() && !cur->isAvatar() )
  1246. {
  1247. LLBBox cur_bbox = cur->getBoundingBoxAgent();
  1248. LLVector3 start_local = cur_bbox.agentToLocal( drag_start_agent );
  1249. LLVector3 end_local = cur_bbox.agentToLocal( drag_start_agent + drag_delta_agent);
  1250. LLVector3 start_center_local = cur_bbox.agentToLocal( drag_start_center_agent );
  1251. LLVector3 axis = nearestAxis( start_local - start_center_local );
  1252. S32 axis_index = axis.mV[0] ? 0 : (axis.mV[1] ? 1 : 2 );
  1254. LLVector3 delta_local = end_local - start_local;
  1255. F32 delta_local_mag = delta_local.magVec();
  1256. LLVector3 dir_local;
  1257. if (delta_local_mag == 0.f)
  1258. {
  1259. dir_local = axis;
  1260. }
  1261. else
  1262. {
  1263. dir_local = delta_local / delta_local_mag; // normalized delta_local
  1264. }
  1266. F32 denom = axis * dir_local;
  1267. F32 desired_delta_size = is_approx_zero(denom) ? 0.f : (delta_local_mag / denom);  // in meters
  1268. F32 desired_scale = llclamp(selectNode->mSavedScale.mV[axis_index] + desired_delta_size, MIN_PRIM_SCALE, DEFAULT_MAX_PRIM_SCALE);
  1269. // propagate scale constraint back to position offset
  1270. desired_delta_size = desired_scale - selectNode->mSavedScale.mV[axis_index]; // propagate constraint back to position
  1272. LLVector3 scale = cur->getScale();
  1273. scale.mV[axis_index] = desired_scale;
  1274. cur->setScale(scale, FALSE);
  1275. rebuild(cur);
  1276. LLVector3 delta_pos;
  1277. if( !getUniform() )
  1278. {
  1279. LLVector3 delta_pos_local = axis * (0.5f * desired_delta_size);
  1280. LLVector3d delta_pos_global;
  1281. delta_pos_global.setVec(cur_bbox.localToAgent( delta_pos_local ) - cur_bbox.getCenterAgent());
  1282. LLVector3 cur_pos = cur->getPositionEdit();
  1284. if (cur->isRootEdit() && !cur->isAttachment())
  1285. {
  1286. LLVector3d new_pos_global = LLWorld::getInstance()->clipToVisibleRegions(selectNode->mSavedPositionGlobal, selectNode->mSavedPositionGlobal + delta_pos_global);
  1287. cur->setPositionGlobal( new_pos_global );
  1288. }
  1289. else
  1290. {
  1291. LLXform* parent_xform = cur->mDrawable->getXform()->getParent();
  1292. LLVector3 new_pos_local;
  1293. // this works in attachment point space using world space delta
  1294. if (parent_xform)
  1295. {
  1296. new_pos_local = selectNode->mSavedPositionLocal + (LLVector3(delta_pos_global) * ~parent_xform->getWorldRotation());
  1297. }
  1298. else
  1299. {
  1300. new_pos_local = selectNode->mSavedPositionLocal + LLVector3(delta_pos_global);
  1301. }
  1302. cur->setPosition(new_pos_local);
  1303. }
  1304. delta_pos = cur->getPositionEdit() - cur_pos;
  1305. }
  1306. if (cur->isRootEdit() && selectNode->mIndividualSelection)
  1307. {
  1308. // counter-translate child objects if we are moving the root as an individual
  1309. LLViewerObject::const_child_list_t& child_list = cur->getChildren();
  1310. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1311.  iter != child_list.end(); iter++)
  1312. {
  1313. LLViewerObject* childp = *iter;
  1314. if (!getUniform())
  1315. {
  1316. LLVector3 child_pos = childp->getPosition() - (delta_pos * ~cur->getRotationEdit());
  1317. childp->setPosition(child_pos);
  1318. rebuild(childp);
  1319. }
  1320. }
  1321. }
  1322. }
  1323. }
  1324. }
  1327. void LLManipScale::renderGuidelinesPart( const LLBBox& bbox )
  1328. {
  1329. LLVector3 guideline_start = bbox.getCenterLocal();
  1331. LLVector3 guideline_end = unitVectorToLocalBBoxExtent( partToUnitVector( mManipPart ), bbox );
  1333. if (!getUniform())
  1334. {
  1335. guideline_start = unitVectorToLocalBBoxExtent( -partToUnitVector( mManipPart ), bbox );
  1336. }
  1338. guideline_end -= guideline_start;
  1339. guideline_end.normVec();
  1340. guideline_end *= LLWorld::getInstance()->getRegionWidthInMeters();
  1341. guideline_end += guideline_start;
  1343. {
  1344. LLGLDepthTest gls_depth(GL_TRUE);
  1345. gl_stippled_line_3d( guideline_start, guideline_end, LLColor4(1.f, 1.f, 1.f, 0.5f) );
  1346. }
  1347. {
  1348. LLGLDepthTest gls_depth(GL_FALSE);
  1349. gl_stippled_line_3d( guideline_start, guideline_end, LLColor4(1.f, 1.f, 1.f, 0.25f) );
  1350. }
  1351. }
  1353. void LLManipScale::updateSnapGuides(const LLBBox& bbox)
  1354. {
  1355. LLVector3 grid_origin;
  1356. LLVector3 grid_scale;
  1357. LLQuaternion grid_rotation;
  1358. LLSelectMgr::getInstance()->getGrid(grid_origin, grid_rotation, grid_scale);
  1360. LLVector3 box_corner_agent = bbox.localToAgent(unitVectorToLocalBBoxExtent( partToUnitVector( mManipPart ), bbox ));
  1361. mScaleCenter = getUniform() ? bbox.getCenterAgent() : bbox.localToAgent(unitVectorToLocalBBoxExtent( -1.f * partToUnitVector( mManipPart ), bbox ));
  1362. mScaleDir = box_corner_agent - mScaleCenter;
  1363. mScaleDir.normVec();
  1365. if(mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1366. {
  1367. mSnapRegimeOffset = SNAP_GUIDE_SCREEN_OFFSET / gAgent.mHUDCurZoom;
  1369. }
  1370. else
  1371. {
  1372. F32 object_distance = dist_vec(mScaleCenter, LLViewerCamera::getInstance()->getOrigin());
  1373. mSnapRegimeOffset = (SNAP_GUIDE_SCREEN_OFFSET * gViewerWindow->getWorldViewWidthRaw() * object_distance) / LLViewerCamera::getInstance()->getPixelMeterRatio();
  1374. }
  1375. LLVector3 cam_at_axis;
  1376. F32 snap_guide_length;
  1377. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1378. {
  1379. cam_at_axis.setVec(1.f, 0.f, 0.f);
  1380. snap_guide_length = SNAP_GUIDE_SCREEN_LENGTH / gAgent.mHUDCurZoom;
  1381. }
  1382. else
  1383. {
  1384. cam_at_axis = LLViewerCamera::getInstance()->getAtAxis();
  1385. F32 manipulator_distance = dist_vec(box_corner_agent, LLViewerCamera::getInstance()->getOrigin());
  1386. snap_guide_length = (SNAP_GUIDE_SCREEN_LENGTH * gViewerWindow->getWorldViewWidthRaw() * manipulator_distance) / LLViewerCamera::getInstance()->getPixelMeterRatio();
  1387. }
  1389. mSnapGuideLength = snap_guide_length / llmax(0.1f, (llmin(mSnapGuideDir1 * cam_at_axis, mSnapGuideDir2 * cam_at_axis)));
  1391. LLVector3 off_axis_dir = mScaleDir % cam_at_axis;
  1392. off_axis_dir.normVec();
  1394. if( (LL_FACE_MIN <= (S32)mManipPart) && ((S32)mManipPart <= LL_FACE_MAX) )
  1395. {
  1396. LLVector3 object_scale = bbox.getMaxLocal();
  1397. object_scale.scaleVec(off_axis_dir * ~bbox.getRotation());
  1398. object_scale.abs();
  1399. if (object_scale.mV[VX] > object_scale.mV[VY] && object_scale.mV[VX] > object_scale.mV[VZ])
  1400. {
  1401. mSnapGuideDir1 = LLVector3::x_axis * bbox.getRotation();
  1402. }
  1403. else if (object_scale.mV[VY] > object_scale.mV[VZ])
  1404. {
  1405. mSnapGuideDir1 = LLVector3::y_axis * bbox.getRotation();
  1406. }
  1407. else
  1408. {
  1409. mSnapGuideDir1 = LLVector3::z_axis * bbox.getRotation();
  1410. }
  1412. LLVector3 scale_snap = grid_scale;
  1413. mScaleSnapUnit1 = scale_snap.scaleVec(partToUnitVector( mManipPart )).magVec();
  1414. mScaleSnapUnit2 = mScaleSnapUnit1;
  1415. mSnapGuideDir1 *= mSnapGuideDir1 * LLViewerCamera::getInstance()->getUpAxis() > 0.f ? 1.f : -1.f;
  1416. mSnapGuideDir2 = mSnapGuideDir1 * -1.f;
  1417. mSnapDir1 = mScaleDir;
  1418. mSnapDir2 = mScaleDir;
  1419. }
  1420. else if( (LL_CORNER_MIN <= (S32)mManipPart) && ((S32)mManipPart <= LL_CORNER_MAX) )
  1421. {
  1422. LLVector3 local_scale_dir = partToUnitVector( mManipPart );
  1423. LLVector3 local_camera_dir;
  1424. if (mObjectSelection->getSelectType() == SELECT_TYPE_HUD)
  1425. {
  1426. local_camera_dir = LLVector3(-1.f, 0.f, 0.f) * ~bbox.getRotation();
  1427. }
  1428. else
  1429. {
  1430. local_camera_dir = (LLViewerCamera::getInstance()->getOrigin() - bbox.getCenterAgent()) * ~bbox.getRotation();
  1431. local_camera_dir.normVec();
  1432. }
  1433. local_scale_dir -= projected_vec(local_scale_dir, local_camera_dir);
  1434. local_scale_dir.normVec();
  1435. LLVector3 x_axis_proj_camera = LLVector3::x_axis - projected_vec(LLVector3::x_axis, local_camera_dir);
  1436. x_axis_proj_camera.normVec();
  1437. LLVector3 y_axis_proj_camera = LLVector3::y_axis - projected_vec(LLVector3::y_axis, local_camera_dir);
  1438. y_axis_proj_camera.normVec();
  1439. LLVector3 z_axis_proj_camera = LLVector3::z_axis - projected_vec(LLVector3::z_axis, local_camera_dir);
  1440. z_axis_proj_camera.normVec();
  1441. F32 x_axis_proj = llabs(local_scale_dir * x_axis_proj_camera);
  1442. F32 y_axis_proj = llabs(local_scale_dir * y_axis_proj_camera);
  1443. F32 z_axis_proj = llabs(local_scale_dir * z_axis_proj_camera);
  1445. if (x_axis_proj > y_axis_proj && x_axis_proj > z_axis_proj)
  1446. {
  1447. mSnapGuideDir1 = LLVector3::y_axis;
  1448. mScaleSnapUnit2 = grid_scale.mV[VY];
  1449. mSnapGuideDir2 = LLVector3::z_axis;
  1450. mScaleSnapUnit1 = grid_scale.mV[VZ];
  1451. }
  1452. else if (y_axis_proj > z_axis_proj)
  1453. {
  1454. mSnapGuideDir1 = LLVector3::x_axis;
  1455. mScaleSnapUnit2 = grid_scale.mV[VX];
  1456. mSnapGuideDir2 = LLVector3::z_axis;
  1457. mScaleSnapUnit1 = grid_scale.mV[VZ];
  1458. }
  1459. else
  1460. {
  1461. mSnapGuideDir1 = LLVector3::x_axis;
  1462. mScaleSnapUnit2 = grid_scale.mV[VX];
  1463. mSnapGuideDir2 = LLVector3::y_axis;
  1464. mScaleSnapUnit1 = grid_scale.mV[VY];
  1465. }
  1467. LLVector3 snap_guide_flip(1.f, 1.f, 1.f);
  1468. switch (mManipPart)
  1469. {
  1470. case LL_CORNER_NNN:
  1471. break;
  1472. case LL_CORNER_NNP:
  1473. snap_guide_flip.setVec(1.f, 1.f, -1.f);
  1474. break;
  1475. case LL_CORNER_NPN:
  1476. snap_guide_flip.setVec(1.f, -1.f, 1.f);
  1477. break;
  1478. case LL_CORNER_NPP:
  1479. snap_guide_flip.setVec(1.f, -1.f, -1.f);
  1480. break;
  1481. case LL_CORNER_PNN:
  1482. snap_guide_flip.setVec(-1.f, 1.f, 1.f);
  1483. break;
  1484. case LL_CORNER_PNP:
  1485. snap_guide_flip.setVec(-1.f, 1.f, -1.f);
  1486. break;
  1487. case LL_CORNER_PPN:
  1488. snap_guide_flip.setVec(-1.f, -1.f, 1.f);
  1489. break;
  1490. case LL_CORNER_PPP:
  1491. snap_guide_flip.setVec(-1.f, -1.f, -1.f);
  1492. break;
  1493. default:
  1494. break;
  1495. }
  1496. mSnapGuideDir1.scaleVec(snap_guide_flip);
  1497. mSnapGuideDir2.scaleVec(snap_guide_flip);
  1498. mSnapGuideDir1.rotVec(bbox.getRotation());
  1499. mSnapGuideDir2.rotVec(bbox.getRotation());
  1500. mSnapDir1 = -1.f * mSnapGuideDir2;
  1501. mSnapDir2 = -1.f * mSnapGuideDir1;
  1502. }
  1504. mScalePlaneNormal1 = mSnapGuideDir1 % mScaleDir;
  1505. mScalePlaneNormal1.normVec();
  1507. mScalePlaneNormal2 = mSnapGuideDir2 % mScaleDir;
  1508. mScalePlaneNormal2.normVec();
  1510. mScaleSnapUnit1 = mScaleSnapUnit1 / (mSnapDir1 * mScaleDir);
  1511. mScaleSnapUnit2 = mScaleSnapUnit2 / (mSnapDir2 * mScaleDir);
  1512. }
  1514. void LLManipScale::renderSnapGuides(const LLBBox& bbox)
  1515. {
  1516. if (!gSavedSettings.getBOOL("SnapEnabled"))
  1517. {
  1518. return;
  1519. }
  1521. F32 max_subdivisions = sGridMaxSubdivisionLevel;
  1522. F32 grid_alpha = gSavedSettings.getF32("GridOpacity");
  1524. F32 max_point_on_scale_line = partToMaxScale(mManipPart, bbox);
  1525. LLVector3 drag_point = gAgent.getPosAgentFromGlobal(mDragPointGlobal);
  1527. updateGridSettings();
  1529. S32 pass;
  1530. for (pass = 0; pass < 3; pass++)
  1531. {
  1532. LLColor4 tick_color = setupSnapGuideRenderPass(pass);
  1534. gGL.begin(LLRender::LINES);
  1535. LLVector3 line_mid = mScaleCenter + (mScaleSnapValue * mScaleDir) + (mSnapGuideDir1 * mSnapRegimeOffset);
  1536. LLVector3 line_start = line_mid - (mScaleDir * (llmin(mScaleSnapValue, mSnapGuideLength * 0.5f)));
  1537. LLVector3 line_end = line_mid + (mScaleDir * llmin(max_point_on_scale_line - mScaleSnapValue, mSnapGuideLength * 0.5f));
  1539. gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * 0.1f);
  1540. gGL.vertex3fv(line_start.mV);
  1541. gGL.color4fv(tick_color.mV);
  1542. gGL.vertex3fv(line_mid.mV);
  1543. gGL.vertex3fv(line_mid.mV);
  1544. gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * 0.1f);
  1545. gGL.vertex3fv(line_end.mV);
  1547. line_mid = mScaleCenter + (mScaleSnapValue * mScaleDir) + (mSnapGuideDir2 * mSnapRegimeOffset);
  1548. line_start = line_mid - (mScaleDir * (llmin(mScaleSnapValue, mSnapGuideLength * 0.5f)));
  1549. line_end = line_mid + (mScaleDir * llmin(max_point_on_scale_line - mScaleSnapValue, mSnapGuideLength * 0.5f));
  1550. gGL.vertex3fv(line_start.mV);
  1551. gGL.color4fv(tick_color.mV);
  1552. gGL.vertex3fv(line_mid.mV);
  1553. gGL.vertex3fv(line_mid.mV);
  1554. gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * 0.1f);
  1555. gGL.vertex3fv(line_end.mV);
  1556. gGL.end();
  1557. }
  1559. {
  1560. LLGLDepthTest gls_depth(GL_FALSE);
  1562. F32 dist_grid_axis = (drag_point - mScaleCenter) * mScaleDir;
  1563. // find distance to nearest smallest grid unit
  1564. F32 grid_offset1 = fmodf(dist_grid_axis, mScaleSnapUnit1 / max_subdivisions);
  1565. F32 grid_offset2 = fmodf(dist_grid_axis, mScaleSnapUnit2 / max_subdivisions);
  1567. // how many smallest grid units are we away from largest grid scale?
  1568. S32 sub_div_offset_1 = llround(fmod(dist_grid_axis - grid_offset1, mScaleSnapUnit1 / sGridMinSubdivisionLevel) / (mScaleSnapUnit1 / max_subdivisions));
  1569. S32 sub_div_offset_2 = llround(fmod(dist_grid_axis - grid_offset2, mScaleSnapUnit2 / sGridMinSubdivisionLevel) / (mScaleSnapUnit2 / max_subdivisions));
  1571. S32 num_ticks_per_side1 = llmax(1, lltrunc(0.5f * mSnapGuideLength / (mScaleSnapUnit1 / max_subdivisions)));
  1572. S32 num_ticks_per_side2 = llmax(1, lltrunc(0.5f * mSnapGuideLength / (mScaleSnapUnit2 / max_subdivisions)));
  1573. F32 dist_scale_units_1 = dist_grid_axis / (mScaleSnapUnit1 / max_subdivisions);
  1574. F32 dist_scale_units_2 = dist_grid_axis / (mScaleSnapUnit2 / max_subdivisions);
  1575. S32 ticks_from_scale_center_1 = lltrunc(dist_scale_units_1);
  1576. S32 ticks_from_scale_center_2 = lltrunc(dist_scale_units_2);
  1577. S32 max_ticks1 = llceil(max_point_on_scale_line / (mScaleSnapUnit1 / max_subdivisions) - dist_scale_units_1);
  1578. S32 max_ticks2 = llceil(max_point_on_scale_line / (mScaleSnapUnit2 / max_subdivisions) - dist_scale_units_2);
  1579. S32 start_tick = 0;
  1580. S32 stop_tick = 0;
  1582. if (mInSnapRegime)
  1583. {
  1584. // draw snap guide line
  1585. gGL.begin(LLRender::LINES);
  1586. LLVector3 snap_line_center = mScaleCenter + (mScaleSnapValue * mScaleDir);
  1588. LLVector3 snap_line_start = snap_line_center + (mSnapGuideDir1 * mSnapRegimeOffset);
  1589. LLVector3 snap_line_end = snap_line_center + (mSnapGuideDir2 * mSnapRegimeOffset);
  1591. gGL.color4f(1.f, 1.f, 1.f, grid_alpha);
  1592. gGL.vertex3fv(snap_line_start.mV);
  1593. gGL.vertex3fv(snap_line_center.mV);
  1594. gGL.vertex3fv(snap_line_center.mV);
  1595. gGL.vertex3fv(snap_line_end.mV);
  1596. gGL.end();
  1598. // draw snap guide arrow
  1599. gGL.begin(LLRender::TRIANGLES);
  1600. {
  1601. //gGLSNoCullFaces.set();
  1602. gGL.color4f(1.f, 1.f, 1.f, grid_alpha);
  1604. LLVector3 arrow_dir;
  1605. LLVector3 arrow_span = mScaleDir;
  1607. arrow_dir = snap_line_start - snap_line_center;
  1608. arrow_dir.normVec();
  1609. gGL.vertex3fv((snap_line_start + arrow_dir * mBoxHandleSize).mV);
  1610. gGL.vertex3fv((snap_line_start + arrow_span * mBoxHandleSize).mV);
  1611. gGL.vertex3fv((snap_line_start - arrow_span * mBoxHandleSize).mV);
  1613. arrow_dir = snap_line_end - snap_line_center;
  1614. arrow_dir.normVec();
  1615. gGL.vertex3fv((snap_line_end + arrow_dir * mBoxHandleSize).mV);
  1616. gGL.vertex3fv((snap_line_end + arrow_span * mBoxHandleSize).mV);
  1617. gGL.vertex3fv((snap_line_end - arrow_span * mBoxHandleSize).mV);
  1618. }
  1619. gGL.end();
  1620. }
  1622. LLVector2 screen_translate_axis(llabs(mScaleDir * LLViewerCamera::getInstance()->getLeftAxis()), llabs(mScaleDir * LLViewerCamera::getInstance()->getUpAxis()));
  1623. screen_translate_axis.normVec();
  1625. S32 tick_label_spacing = llround(screen_translate_axis * sTickLabelSpacing);
  1627. for (pass = 0; pass < 3; pass++)
  1628. {
  1629. LLColor4 tick_color = setupSnapGuideRenderPass(pass);
  1631. start_tick = -(llmin(ticks_from_scale_center_1, num_ticks_per_side1));
  1632. stop_tick = llmin(max_ticks1, num_ticks_per_side1);
  1634. gGL.begin(LLRender::LINES);
  1635. // draw first row of ticks
  1636. for (S32 i = start_tick; i <= stop_tick; i++)
  1637. {
  1638. F32 alpha = (1.f - (1.f *  ((F32)llabs(i) / (F32)num_ticks_per_side1)));
  1639. LLVector3 tick_pos = drag_point + (mScaleDir * (mScaleSnapUnit1 / max_subdivisions * (F32)i - grid_offset1));
  1641. F32 cur_subdivisions = llclamp(getSubdivisionLevel(tick_pos, mScaleDir, mScaleSnapUnit1), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  1643. if (fmodf((F32)(i + sub_div_offset_1), (max_subdivisions / cur_subdivisions)) != 0.f)
  1644. {
  1645. continue;
  1646. }
  1648. F32 tick_scale = 1.f;
  1649. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1650. {
  1651. if (fmodf((F32)(i + sub_div_offset_1), division_level) == 0.f)
  1652. {
  1653. break;
  1654. }
  1655. tick_scale *= 0.7f;
  1656. }
  1658. gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * alpha);
  1659. LLVector3 tick_start = tick_pos + (mSnapGuideDir1 * mSnapRegimeOffset);
  1660. LLVector3 tick_end = tick_start + (mSnapGuideDir1 * mSnapRegimeOffset * tick_scale);
  1661. gGL.vertex3fv(tick_start.mV);
  1662. gGL.vertex3fv(tick_end.mV);
  1663. }
  1665. // draw opposite row of ticks
  1666. start_tick = -(llmin(ticks_from_scale_center_2, num_ticks_per_side2));
  1667. stop_tick = llmin(max_ticks2, num_ticks_per_side2);
  1669. for (S32 i = start_tick; i <= stop_tick; i++)
  1670. {
  1671. F32 alpha = (1.f - (1.f *  ((F32)llabs(i) / (F32)num_ticks_per_side2)));
  1672. LLVector3 tick_pos = drag_point + (mScaleDir * (mScaleSnapUnit2 / max_subdivisions * (F32)i - grid_offset2));
  1674. F32 cur_subdivisions = llclamp(getSubdivisionLevel(tick_pos, mScaleDir, mScaleSnapUnit2), sGridMinSubdivisionLevel, sGridMaxSubdivisionLevel);
  1676. if (fmodf((F32)(i + sub_div_offset_2), (max_subdivisions / cur_subdivisions)) != 0.f)
  1677. {
  1678. continue;
  1679. }
  1681. F32 tick_scale = 1.f;
  1682. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1683. {
  1684. if (fmodf((F32)(i + sub_div_offset_2), division_level) == 0.f)
  1685. {
  1686. break;
  1687. }
  1688. tick_scale *= 0.7f;
  1689. }
  1691. gGL.color4f(tick_color.mV[VRED], tick_color.mV[VGREEN], tick_color.mV[VBLUE], tick_color.mV[VALPHA] * alpha);
  1692. LLVector3 tick_start = tick_pos + (mSnapGuideDir2 * mSnapRegimeOffset);
  1693. LLVector3 tick_end = tick_start + (mSnapGuideDir2 * mSnapRegimeOffset * tick_scale);
  1694. gGL.vertex3fv(tick_start.mV);
  1695. gGL.vertex3fv(tick_end.mV);
  1696. }
  1697. gGL.end();
  1698. }
  1700. // render tick labels
  1701. start_tick = -(llmin(ticks_from_scale_center_1, num_ticks_per_side1));
  1702. stop_tick = llmin(max_ticks1, num_ticks_per_side1);
  1704. F32 grid_resolution = mObjectSelection->getSelectType() == SELECT_TYPE_HUD ? 0.25f : llmax(gSavedSettings.getF32("GridResolution"), 0.001f);
  1705. S32 label_sub_div_offset_1 = llround(fmod(dist_grid_axis - grid_offset1, mScaleSnapUnit1  * 32.f) / (mScaleSnapUnit1 / max_subdivisions));
  1706. S32 label_sub_div_offset_2 = llround(fmod(dist_grid_axis - grid_offset2, mScaleSnapUnit2  * 32.f) / (mScaleSnapUnit2 / max_subdivisions));
  1708. for (S32 i = start_tick; i <= stop_tick; i++)
  1709. {
  1710. F32 tick_scale = 1.f;
  1711. F32 alpha = grid_alpha * (1.f - (0.5f *  ((F32)llabs(i) / (F32)num_ticks_per_side1)));
  1712. LLVector3 tick_pos = drag_point + (mScaleDir * (mScaleSnapUnit1 / max_subdivisions * (F32)i - grid_offset1));
  1714. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1715. {
  1716. if (fmodf((F32)(i + label_sub_div_offset_1), division_level) == 0.f)
  1717. {
  1718. break;
  1719. }
  1720. tick_scale *= 0.7f;
  1721. }
  1723. if (fmodf((F32)(i + label_sub_div_offset_1), (max_subdivisions / llmin(sGridMaxSubdivisionLevel, getSubdivisionLevel(tick_pos, mScaleDir, mScaleSnapUnit1, tick_label_spacing)))) == 0.f)
  1724. {
  1725. LLVector3 text_origin = tick_pos + 
  1726. (mSnapGuideDir1 * mSnapRegimeOffset * (1.f + tick_scale));
  1728. EGridMode grid_mode = LLSelectMgr::getInstance()->getGridMode();
  1729. F32 tick_val;
  1730. if (grid_mode == GRID_MODE_WORLD)
  1731. {
  1732. tick_val = (tick_pos - mScaleCenter) * mScaleDir / (mScaleSnapUnit1 / grid_resolution);
  1733. }
  1734. else
  1735. {
  1736. tick_val = (tick_pos - mScaleCenter) * mScaleDir / (mScaleSnapUnit1 * 2.f);
  1737. }
  1739. if (getUniform())
  1740. {
  1741. tick_val *= 2.f;
  1742. }
  1744. F32 text_highlight = 0.8f;
  1746. if (is_approx_equal(tick_val, mScaleSnapValue) && mInSnapRegime)
  1747. {
  1748. text_highlight = 1.f;
  1749. }
  1751. renderTickValue(text_origin, tick_val, grid_mode == GRID_MODE_WORLD ? std::string("m") : std::string("x"), LLColor4(text_highlight, text_highlight, text_highlight, alpha));
  1752. }
  1753. }
  1755. // label ticks on opposite side
  1756. if (mScaleSnapUnit2 != mScaleSnapUnit1)
  1757. {
  1758. start_tick = -(llmin(ticks_from_scale_center_2, num_ticks_per_side2));
  1759. stop_tick = llmin(max_ticks2, num_ticks_per_side2);
  1760. for (S32 i = start_tick; i <= stop_tick; i++)
  1761. {
  1762. F32 tick_scale = 1.f;
  1763. F32 alpha = grid_alpha * (1.f - (0.5f *  ((F32)llabs(i) / (F32)num_ticks_per_side2)));
  1764. LLVector3 tick_pos = drag_point + (mScaleDir * (mScaleSnapUnit2 / max_subdivisions * (F32)i - grid_offset2));
  1766. for (F32 division_level = max_subdivisions; division_level >= sGridMinSubdivisionLevel; division_level /= 2.f)
  1767. {
  1768. if (fmodf((F32)(i + label_sub_div_offset_2), division_level) == 0.f)
  1769. {
  1770. break;
  1771. }
  1772. tick_scale *= 0.7f;
  1773. }
  1775. if (fmodf((F32)(i + label_sub_div_offset_2), (max_subdivisions / llmin(max_subdivisions, getSubdivisionLevel(tick_pos, mScaleDir, mScaleSnapUnit2, tick_label_spacing)))) == 0.f)
  1776. {
  1777. LLVector3 text_origin = tick_pos + 
  1778. (mSnapGuideDir2 * mSnapRegimeOffset * (1.f + tick_scale));
  1780. EGridMode grid_mode = LLSelectMgr::getInstance()->getGridMode();
  1781. F32 tick_val;
  1782. if (grid_mode == GRID_MODE_WORLD)
  1783. {
  1784. tick_val = (tick_pos - mScaleCenter) * mScaleDir / (mScaleSnapUnit2 / grid_resolution);
  1785. }
  1786. else
  1787. {
  1788. tick_val = (tick_pos - mScaleCenter) * mScaleDir / (mScaleSnapUnit2 * 2.f);
  1789. }
  1791. if (getUniform())
  1792. {
  1793. tick_val *= 2.f;
  1794. }
  1796. F32 text_highlight = 0.8f;
  1798. if (is_approx_equal(tick_val, mScaleSnapValue) && mInSnapRegime)
  1799. {
  1800. text_highlight = 1.f;
  1801. }
  1803. renderTickValue(text_origin, tick_val, grid_mode == GRID_MODE_WORLD ? std::string("m") : std::string("x"), LLColor4(text_highlight, text_highlight, text_highlight, alpha));
  1804. }
  1805. }
  1806. }
  1809. // render help text
  1810. if (mObjectSelection->getSelectType() != SELECT_TYPE_HUD)
  1811. {
  1812. if (mHelpTextTimer.getElapsedTimeF32() < sHelpTextVisibleTime + sHelpTextFadeTime && sNumTimesHelpTextShown < sMaxTimesShowHelpText)
  1813. {
  1814. LLVector3 selection_center_start = LLSelectMgr::getInstance()->getSavedBBoxOfSelection().getCenterAgent();
  1816. LLVector3 offset_dir;
  1817. if (mSnapGuideDir1 * LLViewerCamera::getInstance()->getAtAxis() > mSnapGuideDir2 * LLViewerCamera::getInstance()->getAtAxis())
  1818. {
  1819. offset_dir = mSnapGuideDir2;
  1820. }
  1821. else
  1822. {
  1823. offset_dir = mSnapGuideDir1;
  1824. }
  1826. LLVector3 help_text_pos = selection_center_start + (mSnapRegimeOffset * 5.f * offset_dir);
  1827. const LLFontGL* big_fontp = LLFontGL::getFontSansSerif();
  1829. std::string help_text = "Move mouse cursor over ruler";
  1830. LLColor4 help_text_color = LLColor4::white;
  1831. help_text_color.mV[VALPHA] = clamp_rescale(mHelpTextTimer.getElapsedTimeF32(), sHelpTextVisibleTime, sHelpTextVisibleTime + sHelpTextFadeTime, grid_alpha, 0.f);
  1832. 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);
  1833. help_text = "to snap to grid";
  1834. help_text_pos -= LLViewerCamera::getInstance()->getUpAxis() * mSnapRegimeOffset * 0.4f;
  1835. 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);
  1836. }
  1837. }
  1838. }
  1839. }
  1841. // Returns unit vector in direction of part of an origin-centered cube
  1842. LLVector3 LLManipScale::partToUnitVector( S32 part ) const
  1843. {
  1844. if( (LL_FACE_MIN <= part) && (part <= LL_FACE_MAX) )
  1845. {
  1846. return faceToUnitVector( part );
  1847. }
  1848. else
  1849. if( (LL_CORNER_MIN <= part) && (part <= LL_CORNER_MAX) )
  1850. {
  1851. return cornerToUnitVector( part );
  1852. }
  1853. else
  1854. if( (LL_EDGE_MIN <= part) && (part <= LL_EDGE_MAX ) )
  1855. {
  1856. return edgeToUnitVector( part );
  1857. }
  1858. return LLVector3();
  1859. }
  1862. // Returns unit vector in direction of face of an origin-centered cube
  1863. LLVector3 LLManipScale::faceToUnitVector( S32 part ) const
  1864. {
  1865. llassert( (LL_FACE_MIN <= part) && (part <= LL_FACE_MAX) );
  1866. switch( part )
  1867. {
  1868. case LL_FACE_POSX:
  1869. return LLVector3(  1.f,  0.f,  0.f );
  1871. case LL_FACE_NEGX:
  1872. return LLVector3( -1.f,  0.f,  0.f );
  1874. case LL_FACE_POSY:
  1875. return LLVector3(  0.f,  1.f,  0.f );
  1877. case LL_FACE_NEGY:
  1878. return LLVector3(  0.f, -1.f,  0.f );
  1880. case LL_FACE_POSZ:
  1881. return LLVector3(  0.f,  0.f,  1.f );
  1883. case LL_FACE_NEGZ:
  1884. return LLVector3(  0.f,  0.f, -1.f );
  1885. }
  1886. return LLVector3();
  1887. }
  1890. // Returns unit vector in direction of corner of an origin-centered cube
  1891. LLVector3 LLManipScale::cornerToUnitVector( S32 part ) const
  1892. {
  1893. llassert( (LL_CORNER_MIN <= part) && (part <= LL_CORNER_MAX) );
  1894. LLVector3 vec;
  1895. switch(part)
  1896. {
  1897. case LL_CORNER_NNN:
  1898. vec.setVec(-F_SQRT3, -F_SQRT3, -F_SQRT3);
  1899. break;
  1900. case LL_CORNER_NNP:
  1901. vec.setVec(-F_SQRT3, -F_SQRT3, F_SQRT3);
  1902. break;
  1903. case LL_CORNER_NPN:
  1904. vec.setVec(-F_SQRT3, F_SQRT3, -F_SQRT3);
  1905. break;
  1906. case LL_CORNER_NPP:
  1907. vec.setVec(-F_SQRT3, F_SQRT3, F_SQRT3);
  1908. break;
  1909. case LL_CORNER_PNN:
  1910. vec.setVec(F_SQRT3, -F_SQRT3, -F_SQRT3);
  1911. break;
  1912. case LL_CORNER_PNP:
  1913. vec.setVec(F_SQRT3, -F_SQRT3, F_SQRT3);
  1914. break;
  1915. case LL_CORNER_PPN:
  1916. vec.setVec(F_SQRT3, F_SQRT3, -F_SQRT3);
  1917. break;
  1918. case LL_CORNER_PPP:
  1919. vec.setVec(F_SQRT3, F_SQRT3, F_SQRT3);
  1920. break;
  1921. default:
  1922. vec.clearVec();
  1923. }
  1925. return vec;
  1926. }
  1928. // Returns unit vector in direction of edge of an origin-centered cube
  1929. LLVector3 LLManipScale::edgeToUnitVector( S32 part ) const
  1930. {
  1931. llassert( (LL_EDGE_MIN <= part) && (part <= LL_EDGE_MAX) );
  1932. part -= LL_EDGE_MIN;
  1933. S32 rotation = part >> 2; // Edge between which faces: 0 => XY, 1 => YZ, 2 => ZX
  1934. LLVector3 v;
  1935. v.mV[rotation] = (part & 1) ? F_SQRT2 : -F_SQRT2;
  1936. v.mV[(rotation+1) % 3] = (part & 2) ? F_SQRT2 : -F_SQRT2;
  1937. // v.mV[(rotation+2) % 3] defaults to 0.
  1938. return v;
  1939. }
  1941. // Non-linear scale of origin-centered unit cube to non-origin-centered, non-symetrical bounding box
  1942. LLVector3 LLManipScale::unitVectorToLocalBBoxExtent( const LLVector3& v, const LLBBox& bbox ) const
  1943. {
  1944. const LLVector3& min = bbox.getMinLocal();
  1945. const LLVector3& max = bbox.getMaxLocal();
  1946. LLVector3 ctr = bbox.getCenterLocal();
  1948. return LLVector3(
  1949. v.mV[0] ? (v.mV[0]>0 ? max.mV[0] : min.mV[0] ) : ctr.mV[0], 
  1950. v.mV[1] ? (v.mV[1]>0 ? max.mV[1] : min.mV[1] ) : ctr.mV[1], 
  1951. v.mV[2] ? (v.mV[2]>0 ? max.mV[2] : min.mV[2] ) : ctr.mV[2] );
  1952. }
  1954. // returns max allowable scale along a given stretch axis
  1955. F32 LLManipScale::partToMaxScale( S32 part, const LLBBox &bbox ) const
  1956. {
  1957. F32 max_scale_factor = 0.f;
  1958. LLVector3 bbox_extents = unitVectorToLocalBBoxExtent( partToUnitVector( part ), bbox );
  1959. bbox_extents.abs();
  1960. F32 max_extent = 0.f;
  1961. for (U32 i = VX; i <= VZ; i++)
  1962. {
  1963. if (bbox_extents.mV[i] > max_extent)
  1964. {
  1965. max_extent = bbox_extents.mV[i];
  1966. }
  1967. }
  1968. max_scale_factor = bbox_extents.magVec() * DEFAULT_MAX_PRIM_SCALE / max_extent;
  1970. if (getUniform())
  1971. {
  1972. max_scale_factor *= 0.5f;
  1973. }
  1975. return max_scale_factor;
  1976. }
  1978. // returns min allowable scale along a given stretch axis
  1979. F32 LLManipScale::partToMinScale( S32 part, const LLBBox &bbox ) const
  1980. {
  1981. LLVector3 bbox_extents = unitVectorToLocalBBoxExtent( partToUnitVector( part ), bbox );
  1982. bbox_extents.abs();
  1983. F32 min_extent = DEFAULT_MAX_PRIM_SCALE;
  1984. for (U32 i = VX; i <= VZ; i++)
  1985. {
  1986. if (bbox_extents.mV[i] > 0.f && bbox_extents.mV[i] < min_extent)
  1987. {
  1988. min_extent = bbox_extents.mV[i];
  1989. }
  1990. }
  1991. F32 min_scale_factor = bbox_extents.magVec() * MIN_PRIM_SCALE / min_extent;
  1993. if (getUniform())
  1994. {
  1995. min_scale_factor *= 0.5f;
  1996. }
  1998. return min_scale_factor;
  1999. }
  2001. // Returns the axis aligned unit vector closest to v.
  2002. LLVector3 LLManipScale::nearestAxis( const LLVector3& v ) const
  2003. {
  2004. // Note: yes, this is a slow but easy implementation
  2005. // assumes v is normalized
  2007. F32 coords[][3] =
  2008. {
  2009. { 1.f, 0.f, 0.f },
  2010. { 0.f, 1.f, 0.f },
  2011. { 0.f, 0.f, 1.f },
  2012. {-1.f, 0.f, 0.f },
  2013. { 0.f,-1.f, 0.f },
  2014. { 0.f, 0.f,-1.f }
  2015. };
  2017. F32 cosine[6];
  2018. cosine[0] = v * LLVector3( coords[0] );
  2019. cosine[1] = v * LLVector3( coords[1] );
  2020. cosine[2] = v * LLVector3( coords[2] );
  2021. cosine[3] = -cosine[0];
  2022. cosine[4] = -cosine[1];
  2023. cosine[5] = -cosine[2];
  2025. F32 greatest_cos = cosine[0];
  2026. S32 greatest_index = 0;
  2027. for( S32 i=1; i<6; i++ )
  2028. {
  2029. if( greatest_cos < cosine[i] )
  2030. {
  2031. greatest_cos = cosine[i];
  2032. greatest_index = i;
  2033. }
  2034. }
  2036. return LLVector3( coords[greatest_index] );
  2037. }
  2039. // virtual
  2040. BOOL LLManipScale::canAffectSelection()
  2041. {
  2042. // An selection is scalable if you are allowed to both edit and move 
  2043. // everything in it, and it does not have any sitting agents
  2044. BOOL can_scale = mObjectSelection->getObjectCount() != 0;
  2045. if (can_scale)
  2046. {
  2047. struct f : public LLSelectedObjectFunctor
  2048. {
  2049. virtual bool apply(LLViewerObject* objectp)
  2050. {
  2051. return objectp->permModify() && objectp->permMove() && !objectp->isSeat();
  2052. }
  2053. } func;
  2054. can_scale = mObjectSelection->applyToObjects(&func);
  2055. }
  2056. return can_scale;
  2057. }