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

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

游戏引擎

开发平台：

C++ Builder

llpanelobject.cpp：源码内容
  1. /** 
  2.  * @file llpanelobject.cpp
  3.  * @brief Object editing (position, scale, etc.) in the tools floater
  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. // file include
  36. #include "llpanelobject.h"
  38. // linden library includes
  39. #include "lleconomy.h"
  40. #include "llerror.h"
  41. #include "llfontgl.h"
  42. #include "llmaterialtable.h"
  43. #include "llpermissionsflags.h"
  44. #include "llstring.h"
  45. #include "llvolume.h"
  46. #include "material_codes.h"
  47. #include "m3math.h"
  49. // project includes
  50. #include "llagent.h"
  51. #include "llbutton.h"
  52. #include "llcheckboxctrl.h"
  53. #include "llcolorswatch.h"
  54. #include "llcombobox.h"
  55. #include "llfocusmgr.h"
  56. #include "llmanipscale.h"
  57. #include "llpreviewscript.h"
  58. #include "llresmgr.h"
  59. #include "llselectmgr.h"
  60. #include "llspinctrl.h"
  61. #include "lltexturectrl.h"
  62. #include "lltextbox.h"
  63. #include "lltool.h"
  64. #include "lltoolcomp.h"
  65. #include "lltoolmgr.h"
  66. #include "lltrans.h"
  67. #include "llui.h"
  68. #include "llviewerobject.h"
  69. #include "llviewerregion.h"
  70. #include "llviewerwindow.h"
  71. #include "llvovolume.h"
  72. #include "llworld.h"
  73. #include "pipeline.h"
  74. #include "llviewercontrol.h"
  75. #include "lluictrlfactory.h"
  76. //#include "llfirstuse.h"
  78. #include "lldrawpool.h"
  80. //
  81. // Constants
  82. //
  83. enum {
  84. MI_BOX,
  85. MI_CYLINDER,
  86. MI_PRISM,
  87. MI_SPHERE,
  88. MI_TORUS,
  89. MI_TUBE,
  90. MI_RING,
  91. MI_SCULPT,
  92. MI_NONE,
  93. MI_VOLUME_COUNT
  94. };
  96. enum {
  97. MI_HOLE_SAME,
  98. MI_HOLE_CIRCLE,
  99. MI_HOLE_SQUARE,
  100. MI_HOLE_TRIANGLE,
  101. MI_HOLE_COUNT
  102. };
  104. //static const std::string LEGACY_FULLBRIGHT_DESC =LLTrans::getString("Fullbright");
  106. BOOL LLPanelObject::postBuild()
  107. {
  108. setMouseOpaque(FALSE);
  110. std::map<std::string, std::string> material_name_map;
  111. material_name_map["Stone"]= LLTrans::getString("Stone");
  112. material_name_map["Metal"]= LLTrans::getString("Metal");
  113. material_name_map["Glass"]= LLTrans::getString("Glass");
  114. material_name_map["Wood"]= LLTrans::getString("Wood");
  115. material_name_map["Flesh"]= LLTrans::getString("Flesh");
  116. material_name_map["Plastic"]= LLTrans::getString("Plastic");
  117. material_name_map["Rubber"]= LLTrans::getString("Rubber");
  118. material_name_map["Light"]= LLTrans::getString("Light");
  120. LLMaterialTable::basic.initTableTransNames(material_name_map);
  121. //--------------------------------------------------------
  122. // Top
  123. //--------------------------------------------------------
  125. // Lock checkbox
  126. mCheckLock = getChild<LLCheckBoxCtrl>("checkbox locked");
  127. childSetCommitCallback("checkbox locked",onCommitLock,this);
  129. // Physical checkbox
  130. mCheckPhysics = getChild<LLCheckBoxCtrl>("Physical Checkbox Ctrl");
  131. childSetCommitCallback("Physical Checkbox Ctrl",onCommitPhysics,this);
  133. // Temporary checkbox
  134. mCheckTemporary = getChild<LLCheckBoxCtrl>("Temporary Checkbox Ctrl");
  135. childSetCommitCallback("Temporary Checkbox Ctrl",onCommitTemporary,this);
  137. // Phantom checkbox
  138. mCheckPhantom = getChild<LLCheckBoxCtrl>("Phantom Checkbox Ctrl");
  139. childSetCommitCallback("Phantom Checkbox Ctrl",onCommitPhantom,this);
  141. // Position
  142. mLabelPosition = getChild<LLTextBox>("label position");
  143. mCtrlPosX = getChild<LLSpinCtrl>("Pos X");
  144. childSetCommitCallback("Pos X",onCommitPosition,this);
  145. mCtrlPosY = getChild<LLSpinCtrl>("Pos Y");
  146. childSetCommitCallback("Pos Y",onCommitPosition,this);
  147. mCtrlPosZ = getChild<LLSpinCtrl>("Pos Z");
  148. childSetCommitCallback("Pos Z",onCommitPosition,this);
  150. // Scale
  151. mLabelSize = getChild<LLTextBox>("label size");
  152. mCtrlScaleX = getChild<LLSpinCtrl>("Scale X");
  153. childSetCommitCallback("Scale X",onCommitScale,this);
  155. // Scale Y
  156. mCtrlScaleY = getChild<LLSpinCtrl>("Scale Y");
  157. childSetCommitCallback("Scale Y",onCommitScale,this);
  159. // Scale Z
  160. mCtrlScaleZ = getChild<LLSpinCtrl>("Scale Z");
  161. childSetCommitCallback("Scale Z",onCommitScale,this);
  163. // Rotation
  164. mLabelRotation = getChild<LLTextBox>("label rotation");
  165. mCtrlRotX = getChild<LLSpinCtrl>("Rot X");
  166. childSetCommitCallback("Rot X",onCommitRotation,this);
  167. mCtrlRotY = getChild<LLSpinCtrl>("Rot Y");
  168. childSetCommitCallback("Rot Y",onCommitRotation,this);
  169. mCtrlRotZ = getChild<LLSpinCtrl>("Rot Z");
  170. childSetCommitCallback("Rot Z",onCommitRotation,this);
  172. //--------------------------------------------------------
  174. // material type popup
  175. mLabelMaterial = getChild<LLTextBox>("label material");
  176. mComboMaterial = getChild<LLComboBox>("material");
  177. childSetCommitCallback("material",onCommitMaterial,this);
  178. mComboMaterial->removeall();
  180. for (LLMaterialTable::info_list_t::iterator iter = LLMaterialTable::basic.mMaterialInfoList.begin();
  181.  iter != LLMaterialTable::basic.mMaterialInfoList.end(); ++iter)
  182. {
  183. LLMaterialInfo* minfop = *iter;
  184. if (minfop->mMCode != LL_MCODE_LIGHT)
  185. {
  186. mComboMaterial->add(minfop->mName);  
  187. }
  188. }
  189. mComboMaterialItemCount = mComboMaterial->getItemCount();
  191. // Base Type
  192. mLabelBaseType = getChild<LLTextBox>("label basetype");
  193. mComboBaseType = getChild<LLComboBox>("comboBaseType");
  194. childSetCommitCallback("comboBaseType",onCommitParametric,this);
  196. // Cut
  197. mLabelCut = getChild<LLTextBox>("text cut");
  198. mSpinCutBegin = getChild<LLSpinCtrl>("cut begin");
  199. childSetCommitCallback("cut begin",onCommitParametric,this);
  200. mSpinCutBegin->setValidateBeforeCommit( precommitValidate );
  201. mSpinCutEnd = getChild<LLSpinCtrl>("cut end");
  202. childSetCommitCallback("cut end",onCommitParametric,this);
  203. mSpinCutEnd->setValidateBeforeCommit( &precommitValidate );
  205. // Hollow / Skew
  206. mLabelHollow = getChild<LLTextBox>("text hollow");
  207. mLabelSkew = getChild<LLTextBox>("text skew");
  208. mSpinHollow = getChild<LLSpinCtrl>("Scale 1");
  209. childSetCommitCallback("Scale 1",onCommitParametric,this);
  210. mSpinHollow->setValidateBeforeCommit( &precommitValidate );
  211. mSpinSkew = getChild<LLSpinCtrl>("Skew");
  212. childSetCommitCallback("Skew",onCommitParametric,this);
  213. mSpinSkew->setValidateBeforeCommit( &precommitValidate );
  214. mLabelHoleType = getChild<LLTextBox>("Hollow Shape");
  216. // Hole Type
  217. mComboHoleType = getChild<LLComboBox>("hole");
  218. childSetCommitCallback("hole",onCommitParametric,this);
  220. // Twist
  221. mLabelTwist = getChild<LLTextBox>("text twist");
  222. mSpinTwistBegin = getChild<LLSpinCtrl>("Twist Begin");
  223. childSetCommitCallback("Twist Begin",onCommitParametric,this);
  224. mSpinTwistBegin->setValidateBeforeCommit( precommitValidate );
  225. mSpinTwist = getChild<LLSpinCtrl>("Twist End");
  226. childSetCommitCallback("Twist End",onCommitParametric,this);
  227. mSpinTwist->setValidateBeforeCommit( &precommitValidate );
  229. // Scale
  230. mSpinScaleX = getChild<LLSpinCtrl>("Taper Scale X");
  231. childSetCommitCallback("Taper Scale X",onCommitParametric,this);
  232. mSpinScaleX->setValidateBeforeCommit( &precommitValidate );
  233. mSpinScaleY = getChild<LLSpinCtrl>("Taper Scale Y");
  234. childSetCommitCallback("Taper Scale Y",onCommitParametric,this);
  235. mSpinScaleY->setValidateBeforeCommit( &precommitValidate );
  237. // Shear
  238. mLabelShear = getChild<LLTextBox>("text topshear");
  239. mSpinShearX = getChild<LLSpinCtrl>("Shear X");
  240. childSetCommitCallback("Shear X",onCommitParametric,this);
  241. mSpinShearX->setValidateBeforeCommit( &precommitValidate );
  242. mSpinShearY = getChild<LLSpinCtrl>("Shear Y");
  243. childSetCommitCallback("Shear Y",onCommitParametric,this);
  244. mSpinShearY->setValidateBeforeCommit( &precommitValidate );
  246. // Path / Profile
  247. mCtrlPathBegin = getChild<LLSpinCtrl>("Path Limit Begin");
  248. childSetCommitCallback("Path Limit Begin",onCommitParametric,this);
  249. mCtrlPathBegin->setValidateBeforeCommit( &precommitValidate );
  250. mCtrlPathEnd = getChild<LLSpinCtrl>("Path Limit End");
  251. childSetCommitCallback("Path Limit End",onCommitParametric,this);
  252. mCtrlPathEnd->setValidateBeforeCommit( &precommitValidate );
  254. // Taper
  255. mLabelTaper = getChild<LLTextBox>("text taper2");
  256. mSpinTaperX = getChild<LLSpinCtrl>("Taper X");
  257. childSetCommitCallback("Taper X",onCommitParametric,this);
  258. mSpinTaperX->setValidateBeforeCommit( precommitValidate );
  259. mSpinTaperY = getChild<LLSpinCtrl>("Taper Y");
  260. childSetCommitCallback("Taper Y",onCommitParametric,this);
  261. mSpinTaperY->setValidateBeforeCommit( precommitValidate );
  263. // Radius Offset / Revolutions
  264. mLabelRadiusOffset = getChild<LLTextBox>("text radius delta");
  265. mLabelRevolutions = getChild<LLTextBox>("text revolutions");
  266. mSpinRadiusOffset = getChild<LLSpinCtrl>("Radius Offset");
  267. childSetCommitCallback("Radius Offset",onCommitParametric,this);
  268. mSpinRadiusOffset->setValidateBeforeCommit( &precommitValidate );
  269. mSpinRevolutions = getChild<LLSpinCtrl>("Revolutions");
  270. childSetCommitCallback("Revolutions",onCommitParametric,this);
  271. mSpinRevolutions->setValidateBeforeCommit( &precommitValidate );
  273. // Sculpt
  274. mCtrlSculptTexture = getChild<LLTextureCtrl>("sculpt texture control");
  275. if (mCtrlSculptTexture)
  276. {
  277. mCtrlSculptTexture->setDefaultImageAssetID(LLUUID(SCULPT_DEFAULT_TEXTURE));
  278. mCtrlSculptTexture->setCommitCallback( boost::bind(&LLPanelObject::onCommitSculpt, this, _2 ));
  279. mCtrlSculptTexture->setOnCancelCallback( boost::bind(&LLPanelObject::onCancelSculpt, this, _2 ));
  280. mCtrlSculptTexture->setOnSelectCallback( boost::bind(&LLPanelObject::onSelectSculpt, this, _2 ));
  281. mCtrlSculptTexture->setDropCallback( boost::bind(&LLPanelObject::onDropSculpt, this, _2 ));
  282. // Don't allow (no copy) or (no transfer) textures to be selected during immediate mode
  283. mCtrlSculptTexture->setImmediateFilterPermMask(PERM_COPY | PERM_TRANSFER);
  284. // Allow any texture to be used during non-immediate mode.
  285. mCtrlSculptTexture->setNonImmediateFilterPermMask(PERM_NONE);
  286. LLAggregatePermissions texture_perms;
  287. if (LLSelectMgr::getInstance()->selectGetAggregateTexturePermissions(texture_perms))
  288. {
  289. BOOL can_copy =
  290. texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_EMPTY ||
  291. texture_perms.getValue(PERM_COPY) == LLAggregatePermissions::AP_ALL;
  292. BOOL can_transfer =
  293. texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_EMPTY ||
  294. texture_perms.getValue(PERM_TRANSFER) == LLAggregatePermissions::AP_ALL;
  295. mCtrlSculptTexture->setCanApplyImmediately(can_copy && can_transfer);
  296. }
  297. else
  298. {
  299. mCtrlSculptTexture->setCanApplyImmediately(FALSE);
  300. }
  301. }
  303. mLabelSculptType = getChild<LLTextBox>("label sculpt type");
  304. mCtrlSculptType = getChild<LLComboBox>("sculpt type control");
  305. childSetCommitCallback("sculpt type control", onCommitSculptType, this);
  306. mCtrlSculptMirror = getChild<LLCheckBoxCtrl>("sculpt mirror control");
  307. childSetCommitCallback("sculpt mirror control", onCommitSculptType, this);
  308. mCtrlSculptInvert = getChild<LLCheckBoxCtrl>("sculpt invert control");
  309. childSetCommitCallback("sculpt invert control", onCommitSculptType, this);
  311. // Start with everyone disabled
  312. clearCtrls();
  314. return TRUE;
  315. }
  317. LLPanelObject::LLPanelObject()
  318. : LLPanel(),
  319. mComboMaterialItemCount(0),
  320. mIsPhysical(FALSE),
  321. mIsTemporary(FALSE),
  322. mIsPhantom(FALSE),
  323. mCastShadows(TRUE),
  324. mSelectedType(MI_BOX),
  325. mSculptTextureRevert(LLUUID::null),
  326. mSculptTypeRevert(0)
  327. {
  328. }
  331. LLPanelObject::~LLPanelObject()
  332. {
  333. // Children all cleaned up by default view destructor.
  334. }
  336. void LLPanelObject::getState( )
  337. {
  338. LLViewerObject* objectp = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
  339. LLViewerObject* root_objectp = objectp;
  340. if(!objectp)
  341. {
  342. objectp = LLSelectMgr::getInstance()->getSelection()->getFirstObject();
  343. // *FIX: shouldn't we just keep the child?
  344. if (objectp)
  345. {
  346. LLViewerObject* parentp = objectp->getRootEdit();
  348. if (parentp)
  349. {
  350. root_objectp = parentp;
  351. }
  352. else
  353. {
  354. root_objectp = objectp;
  355. }
  356. }
  357. }
  359. LLVOVolume *volobjp = NULL;
  360. if ( objectp && (objectp->getPCode() == LL_PCODE_VOLUME))
  361. {
  362. volobjp = (LLVOVolume *)objectp;
  363. }
  365. if( !objectp )
  366. {
  367. //forfeit focus
  368. if (gFocusMgr.childHasKeyboardFocus(this))
  369. {
  370. gFocusMgr.setKeyboardFocus(NULL);
  371. }
  373. // Disable all text input fields
  374. clearCtrls();
  375. return;
  376. }
  378. // can move or rotate only linked group with move permissions, or sub-object with move and modify perms
  379. BOOL enable_move = objectp->permMove() && !objectp->isAttachment() && (objectp->permModify() || !gSavedSettings.getBOOL("EditLinkedParts"));
  380. BOOL enable_scale = objectp->permMove() && objectp->permModify();
  381. BOOL enable_rotate = objectp->permMove() && ( (objectp->permModify() && !objectp->isAttachment()) || !gSavedSettings.getBOOL("EditLinkedParts"));
  383. S32 selected_count = LLSelectMgr::getInstance()->getSelection()->getObjectCount();
  384. BOOL single_volume = (LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME ))
  385.  && (selected_count == 1);
  387. if (LLSelectMgr::getInstance()->getSelection()->getRootObjectCount() > 1)
  388. {
  389. enable_move = FALSE;
  390. enable_scale = FALSE;
  391. enable_rotate = FALSE;
  392. }
  394. LLVector3 vec;
  395. if (enable_move)
  396. {
  397. vec = objectp->getPositionEdit();
  398. mCtrlPosX->set( vec.mV[VX] );
  399. mCtrlPosY->set( vec.mV[VY] );
  400. mCtrlPosZ->set( vec.mV[VZ] );
  401. }
  402. else
  403. {
  404. mCtrlPosX->clear();
  405. mCtrlPosY->clear();
  406. mCtrlPosZ->clear();
  407. }
  410. mLabelPosition->setEnabled( enable_move );
  411. mCtrlPosX->setEnabled(enable_move);
  412. mCtrlPosY->setEnabled(enable_move);
  413. mCtrlPosZ->setEnabled(enable_move);
  415. if (enable_scale)
  416. {
  417. vec = objectp->getScale();
  418. mCtrlScaleX->set( vec.mV[VX] );
  419. mCtrlScaleY->set( vec.mV[VY] );
  420. mCtrlScaleZ->set( vec.mV[VZ] );
  421. }
  422. else
  423. {
  424. mCtrlScaleX->clear();
  425. mCtrlScaleY->clear();
  426. mCtrlScaleZ->clear();
  427. }
  429. mLabelSize->setEnabled( enable_scale );
  430. mCtrlScaleX->setEnabled( enable_scale );
  431. mCtrlScaleY->setEnabled( enable_scale );
  432. mCtrlScaleZ->setEnabled( enable_scale );
  434. LLQuaternion object_rot = objectp->getRotationEdit();
  435. object_rot.getEulerAngles(&(mCurEulerDegrees.mV[VX]), &(mCurEulerDegrees.mV[VY]), &(mCurEulerDegrees.mV[VZ]));
  436. mCurEulerDegrees *= RAD_TO_DEG;
  437. mCurEulerDegrees.mV[VX] = fmod(llround(mCurEulerDegrees.mV[VX], OBJECT_ROTATION_PRECISION) + 360.f, 360.f);
  438. mCurEulerDegrees.mV[VY] = fmod(llround(mCurEulerDegrees.mV[VY], OBJECT_ROTATION_PRECISION) + 360.f, 360.f);
  439. mCurEulerDegrees.mV[VZ] = fmod(llround(mCurEulerDegrees.mV[VZ], OBJECT_ROTATION_PRECISION) + 360.f, 360.f);
  441. if (enable_rotate)
  442. {
  443. mCtrlRotX->set( mCurEulerDegrees.mV[VX] );
  444. mCtrlRotY->set( mCurEulerDegrees.mV[VY] );
  445. mCtrlRotZ->set( mCurEulerDegrees.mV[VZ] );
  446. }
  447. else
  448. {
  449. mCtrlRotX->clear();
  450. mCtrlRotY->clear();
  451. mCtrlRotZ->clear();
  452. }
  454. mLabelRotation->setEnabled( enable_rotate );
  455. mCtrlRotX->setEnabled( enable_rotate );
  456. mCtrlRotY->setEnabled( enable_rotate );
  457. mCtrlRotZ->setEnabled( enable_rotate );
  459. BOOL owners_identical;
  460. LLUUID owner_id;
  461. std::string owner_name;
  462. owners_identical = LLSelectMgr::getInstance()->selectGetOwner(owner_id, owner_name);
  464. // BUG? Check for all objects being editable?
  465. S32 roots_selected = LLSelectMgr::getInstance()->getSelection()->getRootObjectCount();
  466. BOOL editable = root_objectp->permModify();
  468. // Select Single Message
  469. childSetVisible("select_single", FALSE);
  470. childSetVisible("edit_object", FALSE);
  471. if (!editable || single_volume || selected_count <= 1)
  472. {
  473. childSetVisible("edit_object", TRUE);
  474. childSetEnabled("edit_object", TRUE);
  475. }
  476. else
  477. {
  478. childSetVisible("select_single", TRUE);
  479. childSetEnabled("select_single", TRUE);
  480. }
  481. // Lock checkbox - only modifiable if you own the object.
  482. BOOL self_owned = (gAgent.getID() == owner_id);
  483. mCheckLock->setEnabled( roots_selected > 0 && self_owned );
  485. // More lock and debit checkbox - get the values
  486. BOOL valid;
  487. U32 owner_mask_on;
  488. U32 owner_mask_off;
  489. valid = LLSelectMgr::getInstance()->selectGetPerm(PERM_OWNER, &owner_mask_on, &owner_mask_off);
  491. if(valid)
  492. {
  493. if(owner_mask_on & PERM_MOVE)
  494. {
  495. // owner can move, so not locked
  496. mCheckLock->set(FALSE);
  497. mCheckLock->setTentative(FALSE);
  498. }
  499. else if(owner_mask_off & PERM_MOVE)
  500. {
  501. // owner can't move, so locked
  502. mCheckLock->set(TRUE);
  503. mCheckLock->setTentative(FALSE);
  504. }
  505. else
  506. {
  507. // some locked, some not locked
  508. mCheckLock->set(FALSE);
  509. mCheckLock->setTentative(TRUE);
  510. }
  511. }
  513. BOOL is_flexible = volobjp && volobjp->isFlexible();
  515. // Physics checkbox
  516. mIsPhysical = root_objectp->usePhysics();
  517. mCheckPhysics->set( mIsPhysical );
  518. mCheckPhysics->setEnabled( roots_selected>0 
  519. && (editable || gAgent.isGodlike()) 
  520. && !is_flexible);
  522. mIsTemporary = root_objectp->flagTemporaryOnRez();
  523. mCheckTemporary->set( mIsTemporary );
  524. mCheckTemporary->setEnabled( roots_selected>0 && editable );
  526. mIsPhantom = root_objectp->flagPhantom();
  527. mCheckPhantom->set( mIsPhantom );
  528. mCheckPhantom->setEnabled( roots_selected>0 && editable && !is_flexible );
  530. #if 0 // 1.9.2
  531. mCastShadows = root_objectp->flagCastShadows();
  532. mCheckCastShadows->set( mCastShadows );
  533. mCheckCastShadows->setEnabled( roots_selected==1 && editable );
  534. #endif
  536. // Update material part
  537. // slightly inefficient - materials are unique per object, not per TE
  538. U8 material_code = 0;
  539. struct f : public LLSelectedTEGetFunctor<U8>
  540. {
  541. U8 get(LLViewerObject* object, S32 te)
  542. {
  543. return object->getMaterial();
  544. }
  545. } func;
  546. bool material_same = LLSelectMgr::getInstance()->getSelection()->getSelectedTEValue( &func, material_code );
  547. std::string LEGACY_FULLBRIGHT_DESC = LLTrans::getString("Fullbright");
  548. if (editable && single_volume && material_same)
  549. {
  550. mComboMaterial->setEnabled( TRUE );
  551. mLabelMaterial->setEnabled( TRUE );
  552. if (material_code == LL_MCODE_LIGHT)
  553. {
  554. if (mComboMaterial->getItemCount() == mComboMaterialItemCount)
  555. {
  556. mComboMaterial->add(LEGACY_FULLBRIGHT_DESC);
  557. }
  558. mComboMaterial->setSimple(LEGACY_FULLBRIGHT_DESC);
  559. }
  560. else
  561. {
  562. if (mComboMaterial->getItemCount() != mComboMaterialItemCount)
  563. {
  564. mComboMaterial->remove(LEGACY_FULLBRIGHT_DESC);
  565. }
  567. mComboMaterial->setSimple(std::string(LLMaterialTable::basic.getName(material_code)));
  568. }
  569. }
  570. else
  571. {
  572. mComboMaterial->setEnabled( FALSE );
  573. mLabelMaterial->setEnabled( FALSE );
  574. }
  575. //----------------------------------------------------------------------------
  577. S32 selected_item = MI_BOX;
  578. S32 selected_hole = MI_HOLE_SAME;
  579. BOOL enabled = FALSE;
  580. BOOL hole_enabled = FALSE;
  581. F32 scale_x=1.f, scale_y=1.f;
  583. if( !objectp || !objectp->getVolume() || !editable || !single_volume)
  584. {
  585. // Clear out all geometry fields.
  586. mComboBaseType->clear();
  587. mSpinHollow->clear();
  588. mSpinCutBegin->clear();
  589. mSpinCutEnd->clear();
  590. mCtrlPathBegin->clear();
  591. mCtrlPathEnd->clear();
  592. mSpinScaleX->clear();
  593. mSpinScaleY->clear();
  594. mSpinTwist->clear();
  595. mSpinTwistBegin->clear();
  596. mComboHoleType->clear();
  597. mSpinShearX->clear();
  598. mSpinShearY->clear();
  599. mSpinTaperX->clear();
  600. mSpinTaperY->clear();
  601. mSpinRadiusOffset->clear();
  602. mSpinRevolutions->clear();
  603. mSpinSkew->clear();
  605. mSelectedType = MI_NONE;
  606. }
  607. else
  608. {
  609. // Only allowed to change these parameters for objects
  610. // that you have permissions on AND are not attachments.
  611. enabled = root_objectp->permModify();
  613. const LLVolumeParams &volume_params = objectp->getVolume()->getParams();
  615. // Volume type
  616. U8 path = volume_params.getPathParams().getCurveType();
  617. U8 profile_and_hole = volume_params.getProfileParams().getCurveType();
  618. U8 profile = profile_and_hole & LL_PCODE_PROFILE_MASK;
  619. U8 hole = profile_and_hole & LL_PCODE_HOLE_MASK;
  621. // Scale goes first so we can differentiate between a sphere and a torus,
  622. // which have the same profile and path types.
  624. // Scale
  625. scale_x = volume_params.getRatioX();
  626. scale_y = volume_params.getRatioY();
  628. BOOL linear_path = (path == LL_PCODE_PATH_LINE) || (path == LL_PCODE_PATH_FLEXIBLE);
  629. if ( linear_path && profile == LL_PCODE_PROFILE_CIRCLE )
  630. {
  631. selected_item = MI_CYLINDER;
  632. }
  633. else if ( linear_path && profile == LL_PCODE_PROFILE_SQUARE )
  634. {
  635. selected_item = MI_BOX;
  636. }
  637. else if ( linear_path && profile == LL_PCODE_PROFILE_ISOTRI )
  638. {
  639. selected_item = MI_PRISM;
  640. }
  641. else if ( linear_path && profile == LL_PCODE_PROFILE_EQUALTRI )
  642. {
  643. selected_item = MI_PRISM;
  644. }
  645. else if ( linear_path && profile == LL_PCODE_PROFILE_RIGHTTRI )
  646. {
  647. selected_item = MI_PRISM;
  648. }
  649. else if (path == LL_PCODE_PATH_FLEXIBLE) // shouldn't happen
  650. {
  651. selected_item = MI_CYLINDER; // reasonable default
  652. }
  653. else if ( path == LL_PCODE_PATH_CIRCLE && profile == LL_PCODE_PROFILE_CIRCLE && scale_y > 0.75f)
  654. {
  655. selected_item = MI_SPHERE;
  656. }
  657. else if ( path == LL_PCODE_PATH_CIRCLE && profile == LL_PCODE_PROFILE_CIRCLE && scale_y <= 0.75f)
  658. {
  659. selected_item = MI_TORUS;
  660. }
  661. else if ( path == LL_PCODE_PATH_CIRCLE && profile == LL_PCODE_PROFILE_CIRCLE_HALF)
  662. {
  663. selected_item = MI_SPHERE;
  664. }
  665. else if ( path == LL_PCODE_PATH_CIRCLE2 && profile == LL_PCODE_PROFILE_CIRCLE )
  666. {
  667. // Spirals aren't supported.  Make it into a sphere.  JC
  668. selected_item = MI_SPHERE;
  669. }
  670. else if ( path == LL_PCODE_PATH_CIRCLE && profile == LL_PCODE_PROFILE_EQUALTRI )
  671. {
  672. selected_item = MI_RING;
  673. }
  674. else if ( path == LL_PCODE_PATH_CIRCLE && profile == LL_PCODE_PROFILE_SQUARE && scale_y <= 0.75f)
  675. {
  676. selected_item = MI_TUBE;
  677. }
  678. else
  679. {
  680. llinfos << "Unknown path " << (S32) path << " profile " << (S32) profile << " in getState" << llendl;
  681. selected_item = MI_BOX;
  682. }
  685. if (objectp->getParameterEntryInUse(LLNetworkData::PARAMS_SCULPT))
  686. {
  687. selected_item = MI_SCULPT;
  688. //LLFirstUse::useSculptedPrim();
  689. }
  692. mComboBaseType ->setCurrentByIndex( selected_item );
  693. mSelectedType = selected_item;
  695. // Grab S path
  696. F32 begin_s = volume_params.getBeginS();
  697. F32 end_s = volume_params.getEndS();
  699. // Compute cut and advanced cut from S and T
  700. F32 begin_t = volume_params.getBeginT();
  701. F32 end_t = volume_params.getEndT();
  703. // Hollowness
  704. F32 hollow = volume_params.getHollow();
  705. mSpinHollow->set( 100.f * hollow );
  707. // All hollow objects allow a shape to be selected.
  708. if (hollow > 0.f)
  709. {
  710. switch (hole)
  711. {
  712. case LL_PCODE_HOLE_CIRCLE:
  713. selected_hole = MI_HOLE_CIRCLE;
  714. break;
  715. case LL_PCODE_HOLE_SQUARE:
  716. selected_hole = MI_HOLE_SQUARE;
  717. break;
  718. case LL_PCODE_HOLE_TRIANGLE:
  719. selected_hole = MI_HOLE_TRIANGLE;
  720. break;
  721. case LL_PCODE_HOLE_SAME:
  722. default:
  723. selected_hole = MI_HOLE_SAME;
  724. break;
  725. }
  726. mComboHoleType->setCurrentByIndex( selected_hole );
  727. hole_enabled = enabled;
  728. }
  729. else
  730. {
  731. mComboHoleType->setCurrentByIndex( MI_HOLE_SAME );
  732. hole_enabled = FALSE;
  733. }
  735. // Cut interpretation varies based on base object type
  736. F32 cut_begin, cut_end, adv_cut_begin, adv_cut_end;
  738. if ( selected_item == MI_SPHERE || selected_item == MI_TORUS || 
  739.  selected_item == MI_TUBE   || selected_item == MI_RING )
  740. {
  741. cut_begin = begin_t;
  742. cut_end = end_t;
  743. adv_cut_begin = begin_s;
  744. adv_cut_end = end_s;
  745. }
  746. else
  747. {
  748. cut_begin       = begin_s;
  749. cut_end         = end_s;
  750. adv_cut_begin   = begin_t;
  751. adv_cut_end     = end_t;
  752. }
  754. mSpinCutBegin ->set( cut_begin );
  755. mSpinCutEnd ->set( cut_end );
  756. mCtrlPathBegin ->set( adv_cut_begin );
  757. mCtrlPathEnd ->set( adv_cut_end );
  759. // Twist
  760. F32 twist = volume_params.getTwist();
  761. F32 twist_begin = volume_params.getTwistBegin();
  762. // Check the path type for conversion.
  763. if (path == LL_PCODE_PATH_LINE || path == LL_PCODE_PATH_FLEXIBLE)
  764. {
  765. twist *= OBJECT_TWIST_LINEAR_MAX;
  766. twist_begin *= OBJECT_TWIST_LINEAR_MAX;
  767. }
  768. else
  769. {
  770. twist *= OBJECT_TWIST_MAX;
  771. twist_begin *= OBJECT_TWIST_MAX;
  772. }
  774. mSpinTwist ->set( twist );
  775. mSpinTwistBegin ->set( twist_begin );
  777. // Shear
  778. F32 shear_x = volume_params.getShearX();
  779. F32 shear_y = volume_params.getShearY();
  780. mSpinShearX->set( shear_x );
  781. mSpinShearY->set( shear_y );
  783. // Taper
  784. F32 taper_x = volume_params.getTaperX();
  785. F32 taper_y = volume_params.getTaperY();
  786. mSpinTaperX->set( taper_x );
  787. mSpinTaperY->set( taper_y );
  789. // Radius offset.
  790. F32 radius_offset = volume_params.getRadiusOffset();
  791. // Limit radius offset, based on taper and hole size y.
  792. F32 radius_mag = fabs(radius_offset);
  793. F32 hole_y_mag = fabs(scale_y);
  794. F32 taper_y_mag  = fabs(taper_y);
  795. // Check to see if the taper effects us.
  796. if ( (radius_offset > 0.f && taper_y < 0.f) ||
  797.  (radius_offset < 0.f && taper_y > 0.f) )
  798. {
  799. // The taper does not help increase the radius offset range.
  800. taper_y_mag = 0.f;
  801. }
  802. F32 max_radius_mag = 1.f - hole_y_mag * (1.f - taper_y_mag) / (1.f - hole_y_mag);
  803. // Enforce the maximum magnitude.
  804. if (radius_mag > max_radius_mag)
  805. {
  806. // Check radius offset sign.
  807. if (radius_offset < 0.f)
  808. {
  809. radius_offset = -max_radius_mag;
  810. }
  811. else
  812. {
  813. radius_offset = max_radius_mag;
  814. }
  815. }
  816. mSpinRadiusOffset->set( radius_offset);
  818. // Revolutions
  819. F32 revolutions = volume_params.getRevolutions();
  820. mSpinRevolutions->set( revolutions );
  822. // Skew
  823. F32 skew = volume_params.getSkew();
  824. // Limit skew, based on revolutions hole size x.
  825. F32 skew_mag= fabs(skew);
  826. F32 min_skew_mag = 1.0f - 1.0f / (revolutions * scale_x + 1.0f);
  827. // Discontinuity; A revolution of 1 allows skews below 0.5.
  828. if ( fabs(revolutions - 1.0f) < 0.001)
  829. min_skew_mag = 0.0f;
  831. // Clip skew.
  832. if (skew_mag < min_skew_mag)
  833. {
  834. // Check skew sign.
  835. if (skew < 0.0f)
  836. {
  837. skew = -min_skew_mag;
  838. }
  839. else 
  840. {
  841. skew = min_skew_mag;
  842. }
  843. }
  844. mSpinSkew->set( skew );
  845. }
  847. // Compute control visibility, label names, and twist range.
  848. // Start with defaults.
  849. BOOL cut_visible                = TRUE;
  850. BOOL hollow_visible             = TRUE;
  851. BOOL top_size_x_visible = TRUE;
  852. BOOL top_size_y_visible = TRUE;
  853. BOOL top_shear_x_visible = TRUE;
  854. BOOL top_shear_y_visible = TRUE;
  855. BOOL twist_visible = TRUE;
  856. BOOL advanced_cut_visible = FALSE;
  857. BOOL taper_visible = FALSE;
  858. BOOL skew_visible = FALSE;
  859. BOOL radius_offset_visible = FALSE;
  860. BOOL revolutions_visible = FALSE;
  861. BOOL sculpt_texture_visible     = FALSE;
  862. F32  twist_min = OBJECT_TWIST_LINEAR_MIN;
  863. F32  twist_max = OBJECT_TWIST_LINEAR_MAX;
  864. F32  twist_inc = OBJECT_TWIST_LINEAR_INC;
  866. BOOL advanced_is_dimple = FALSE;
  867. BOOL advanced_is_slice = FALSE;
  868. BOOL size_is_hole = FALSE;
  870. // Tune based on overall volume type
  871. switch (selected_item)
  872. {
  873. case MI_SPHERE:
  874. top_size_x_visible = FALSE;
  875. top_size_y_visible = FALSE;
  876. top_shear_x_visible = FALSE;
  877. top_shear_y_visible = FALSE;
  878. //twist_visible = FALSE;
  879. advanced_cut_visible = TRUE;
  880. advanced_is_dimple = TRUE;
  881. twist_min = OBJECT_TWIST_MIN;
  882. twist_max = OBJECT_TWIST_MAX;
  883. twist_inc = OBJECT_TWIST_INC;
  884. break;
  886. case MI_TORUS:
  887. case MI_TUBE:
  888. case MI_RING:
  889. //top_size_x_visible = FALSE;
  890. //top_size_y_visible = FALSE;
  891.    size_is_hole  = TRUE;
  892. skew_visible = TRUE;
  893. advanced_cut_visible = TRUE;
  894. taper_visible = TRUE;
  895. radius_offset_visible = TRUE;
  896. revolutions_visible = TRUE;
  897. twist_min = OBJECT_TWIST_MIN;
  898. twist_max = OBJECT_TWIST_MAX;
  899. twist_inc = OBJECT_TWIST_INC;
  901. break;
  903. case MI_SCULPT:
  904. cut_visible             = FALSE;
  905. hollow_visible          = FALSE;
  906. twist_visible           = FALSE;
  907. top_size_x_visible      = FALSE;
  908. top_size_y_visible      = FALSE;
  909. top_shear_x_visible     = FALSE;
  910. top_shear_y_visible     = FALSE;
  911. skew_visible            = FALSE;
  912. advanced_cut_visible    = FALSE;
  913. taper_visible           = FALSE;
  914. radius_offset_visible   = FALSE;
  915. revolutions_visible     = FALSE;
  916. sculpt_texture_visible  = TRUE;
  918. break;
  920. case MI_BOX:
  921. advanced_cut_visible = TRUE;
  922. advanced_is_slice = TRUE;
  923. break;
  925. case MI_CYLINDER:
  926. advanced_cut_visible = TRUE;
  927. advanced_is_slice = TRUE;
  928. break;
  930. case MI_PRISM:
  931. advanced_cut_visible = TRUE;
  932. advanced_is_slice = TRUE;
  933. break;
  935. default:
  936. break;
  937. }
  939. // Check if we need to change top size/hole size params.
  940. switch (selected_item)
  941. {
  942. case MI_SPHERE:
  943. case MI_TORUS:
  944. case MI_TUBE:
  945. case MI_RING:
  946. mSpinScaleX->set( scale_x );
  947. mSpinScaleY->set( scale_y );
  948. mSpinScaleX->setMinValue(OBJECT_MIN_HOLE_SIZE);
  949. mSpinScaleX->setMaxValue(OBJECT_MAX_HOLE_SIZE_X);
  950. mSpinScaleY->setMinValue(OBJECT_MIN_HOLE_SIZE);
  951. mSpinScaleY->setMaxValue(OBJECT_MAX_HOLE_SIZE_Y);
  952. break;
  953. default:
  954. if (editable)
  955. {
  956. mSpinScaleX->set( 1.f - scale_x );
  957. mSpinScaleY->set( 1.f - scale_y );
  958. mSpinScaleX->setMinValue(-1.f);
  959. mSpinScaleX->setMaxValue(1.f);
  960. mSpinScaleY->setMinValue(-1.f);
  961. mSpinScaleY->setMaxValue(1.f);
  962. }
  963. break;
  964. }
  966. // Check if we need to limit the hollow based on the hole type.
  967. if (  selected_hole == MI_HOLE_SQUARE && 
  968.   ( selected_item == MI_CYLINDER || selected_item == MI_TORUS ||
  969.     selected_item == MI_PRISM    || selected_item == MI_RING  ||
  970. selected_item == MI_SPHERE ) )
  971. {
  972. mSpinHollow->setMinValue(0.f);
  973. mSpinHollow->setMaxValue(70.f);
  974. }
  975. else 
  976. {
  977. mSpinHollow->setMinValue(0.f);
  978. mSpinHollow->setMaxValue(95.f);
  979. }
  981. // Update field enablement
  982. mLabelBaseType ->setEnabled( enabled );
  983. mComboBaseType ->setEnabled( enabled );
  985. mLabelCut ->setEnabled( enabled );
  986. mSpinCutBegin ->setEnabled( enabled );
  987. mSpinCutEnd ->setEnabled( enabled );
  989. mLabelHollow ->setEnabled( enabled );
  990. mSpinHollow ->setEnabled( enabled );
  991. mLabelHoleType ->setEnabled( hole_enabled );
  992. mComboHoleType ->setEnabled( hole_enabled );
  994. mLabelTwist ->setEnabled( enabled );
  995. mSpinTwist ->setEnabled( enabled );
  996. mSpinTwistBegin ->setEnabled( enabled );
  998. mLabelSkew ->setEnabled( enabled );
  999. mSpinSkew ->setEnabled( enabled );
  1001. childSetVisible("scale_hole", FALSE);
  1002. childSetVisible("scale_taper", FALSE);
  1003. if (top_size_x_visible || top_size_y_visible)
  1004. {
  1005. if (size_is_hole)
  1006. {
  1007. childSetVisible("scale_hole", TRUE);
  1008. childSetEnabled("scale_hole", enabled);
  1009. }
  1010. else
  1011. {
  1012. childSetVisible("scale_taper", TRUE);
  1013. childSetEnabled("scale_taper", enabled);
  1014. }
  1015. }
  1017. mSpinScaleX ->setEnabled( enabled );
  1018. mSpinScaleY ->setEnabled( enabled );
  1020. mLabelShear ->setEnabled( enabled );
  1021. mSpinShearX ->setEnabled( enabled );
  1022. mSpinShearY ->setEnabled( enabled );
  1024. childSetVisible("advanced_cut", FALSE);
  1025. childSetVisible("advanced_dimple", FALSE);
  1026. childSetVisible("advanced_slice", FALSE);
  1028. if (advanced_cut_visible)
  1029. {
  1030. if (advanced_is_dimple)
  1031. {
  1032. childSetVisible("advanced_dimple", TRUE);
  1033. childSetEnabled("advanced_dimple", enabled);
  1034. }
  1036. else if (advanced_is_slice)
  1037. {
  1038. childSetVisible("advanced_slice", TRUE);
  1039. childSetEnabled("advanced_slice", enabled);
  1040. }
  1041. else
  1042. {
  1043. childSetVisible("advanced_cut", TRUE);
  1044. childSetEnabled("advanced_cut", enabled);
  1045. }
  1046. }
  1048. mCtrlPathBegin ->setEnabled( enabled );
  1049. mCtrlPathEnd ->setEnabled( enabled );
  1051. mLabelTaper ->setEnabled( enabled );
  1052. mSpinTaperX ->setEnabled( enabled );
  1053. mSpinTaperY ->setEnabled( enabled );
  1055. mLabelRadiusOffset->setEnabled( enabled );
  1056. mSpinRadiusOffset ->setEnabled( enabled );
  1058. mLabelRevolutions->setEnabled( enabled );
  1059. mSpinRevolutions ->setEnabled( enabled );
  1061. // Update field visibility
  1062. mLabelCut ->setVisible( cut_visible );
  1063. mSpinCutBegin ->setVisible( cut_visible );
  1064. mSpinCutEnd ->setVisible( cut_visible ); 
  1066. mLabelHollow ->setVisible( hollow_visible );
  1067. mSpinHollow ->setVisible( hollow_visible );
  1068. mLabelHoleType ->setVisible( hollow_visible );
  1069. mComboHoleType ->setVisible( hollow_visible );
  1071. mLabelTwist ->setVisible( twist_visible );
  1072. mSpinTwist ->setVisible( twist_visible );
  1073. mSpinTwistBegin ->setVisible( twist_visible );
  1074. mSpinTwist ->setMinValue(  twist_min );
  1075. mSpinTwist ->setMaxValue(  twist_max );
  1076. mSpinTwist ->setIncrement( twist_inc );
  1077. mSpinTwistBegin ->setMinValue(  twist_min );
  1078. mSpinTwistBegin ->setMaxValue(  twist_max );
  1079. mSpinTwistBegin ->setIncrement( twist_inc );
  1081. mSpinScaleX ->setVisible( top_size_x_visible );
  1082. mSpinScaleY ->setVisible( top_size_y_visible );
  1084. mLabelSkew ->setVisible( skew_visible );
  1085. mSpinSkew ->setVisible( skew_visible );
  1087. mLabelShear ->setVisible( top_shear_x_visible || top_shear_y_visible );
  1088. mSpinShearX ->setVisible( top_shear_x_visible );
  1089. mSpinShearY ->setVisible( top_shear_y_visible );
  1091. mCtrlPathBegin ->setVisible( advanced_cut_visible );
  1092. mCtrlPathEnd ->setVisible( advanced_cut_visible );
  1094. mLabelTaper ->setVisible( taper_visible );
  1095. mSpinTaperX ->setVisible( taper_visible );
  1096. mSpinTaperY ->setVisible( taper_visible );
  1098. mLabelRadiusOffset->setVisible( radius_offset_visible );
  1099. mSpinRadiusOffset ->setVisible( radius_offset_visible );
  1101. mLabelRevolutions->setVisible( revolutions_visible );
  1102. mSpinRevolutions ->setVisible( revolutions_visible );
  1104. mCtrlSculptTexture->setVisible(sculpt_texture_visible);
  1105. mLabelSculptType->setVisible(sculpt_texture_visible);
  1106. mCtrlSculptType->setVisible(sculpt_texture_visible);
  1107. mCtrlSculptMirror->setVisible(sculpt_texture_visible);
  1108. mCtrlSculptInvert->setVisible(sculpt_texture_visible);
  1111. // sculpt texture
  1113. if (selected_item == MI_SCULPT)
  1114. {
  1115.         LLUUID id;
  1116. LLSculptParams *sculpt_params = (LLSculptParams *)objectp->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  1119. if (sculpt_params) // if we have a legal sculpt param block for this object:
  1120. {
  1121. if (mObject != objectp)  // we've just selected a new object, so save for undo
  1122. {
  1123. mSculptTextureRevert = sculpt_params->getSculptTexture();
  1124. mSculptTypeRevert    = sculpt_params->getSculptType();
  1125. }
  1127. LLTextureCtrl*  mTextureCtrl = getChild<LLTextureCtrl>("sculpt texture control");
  1128. if(mTextureCtrl)
  1129. {
  1130. mTextureCtrl->setTentative(FALSE);
  1131. mTextureCtrl->setEnabled(editable);
  1132. if (editable)
  1133. mTextureCtrl->setImageAssetID(sculpt_params->getSculptTexture());
  1134. else
  1135. mTextureCtrl->setImageAssetID(LLUUID::null);
  1136. }
  1138. U8 sculpt_type = sculpt_params->getSculptType();
  1139. U8 sculpt_stitching = sculpt_type & LL_SCULPT_TYPE_MASK;
  1140. BOOL sculpt_invert = sculpt_type & LL_SCULPT_FLAG_INVERT;
  1141. BOOL sculpt_mirror = sculpt_type & LL_SCULPT_FLAG_MIRROR;
  1143. if (mCtrlSculptType)
  1144. {
  1145. mCtrlSculptType->setCurrentByIndex(sculpt_stitching);
  1146. mCtrlSculptType->setEnabled(editable);
  1147. }
  1149. if (mCtrlSculptMirror)
  1150. {
  1151. mCtrlSculptMirror->set(sculpt_mirror);
  1152. mCtrlSculptMirror->setEnabled(editable);
  1153. }
  1155. if (mCtrlSculptInvert)
  1156. {
  1157. mCtrlSculptInvert->set(sculpt_invert);
  1158. mCtrlSculptInvert->setEnabled(editable);
  1159. }
  1161. if (mLabelSculptType)
  1162. {
  1163. mLabelSculptType->setEnabled(TRUE);
  1164. }
  1165. }
  1166. }
  1167. else
  1168. {
  1169. mSculptTextureRevert = LLUUID::null;
  1170. }
  1173. //----------------------------------------------------------------------------
  1175. mObject = objectp;
  1176. mRootObject = root_objectp;
  1177. }
  1179. // static
  1180. bool LLPanelObject::precommitValidate( const LLSD& data )
  1181. {
  1182. // TODO: Richard will fill this in later.  
  1183. return TRUE; // FALSE means that validation failed and new value should not be commited.
  1184. }
  1186. void LLPanelObject::sendIsPhysical()
  1187. {
  1188. BOOL value = mCheckPhysics->get();
  1189. if( mIsPhysical != value )
  1190. {
  1191. LLSelectMgr::getInstance()->selectionUpdatePhysics(value);
  1192. mIsPhysical = value;
  1194. llinfos << "update physics sent" << llendl;
  1195. }
  1196. else
  1197. {
  1198. llinfos << "update physics not changed" << llendl;
  1199. }
  1200. }
  1202. void LLPanelObject::sendIsTemporary()
  1203. {
  1204. BOOL value = mCheckTemporary->get();
  1205. if( mIsTemporary != value )
  1206. {
  1207. LLSelectMgr::getInstance()->selectionUpdateTemporary(value);
  1208. mIsTemporary = value;
  1210. llinfos << "update temporary sent" << llendl;
  1211. }
  1212. else
  1213. {
  1214. llinfos << "update temporary not changed" << llendl;
  1215. }
  1216. }
  1219. void LLPanelObject::sendIsPhantom()
  1220. {
  1221. BOOL value = mCheckPhantom->get();
  1222. if( mIsPhantom != value )
  1223. {
  1224. LLSelectMgr::getInstance()->selectionUpdatePhantom(value);
  1225. mIsPhantom = value;
  1227. llinfos << "update phantom sent" << llendl;
  1228. }
  1229. else
  1230. {
  1231. llinfos << "update phantom not changed" << llendl;
  1232. }
  1233. }
  1235. void LLPanelObject::sendCastShadows()
  1236. {
  1237. BOOL value = mCheckCastShadows->get();
  1238. if( mCastShadows != value )
  1239. {
  1240. LLSelectMgr::getInstance()->selectionUpdateCastShadows(value);
  1241. mCastShadows = value;
  1243. llinfos << "update cast shadows sent" << llendl;
  1244. }
  1245. else
  1246. {
  1247. llinfos << "update cast shadows not changed" << llendl;
  1248. }
  1249. }
  1251. // static
  1252. void LLPanelObject::onCommitMaterial( LLUICtrl* ctrl, void* userdata )
  1253. {
  1254. //LLPanelObject* self = (LLPanelObject*) userdata;
  1255. LLComboBox* box = (LLComboBox*) ctrl;
  1257. if (box)
  1258. {
  1259. // apply the currently selected material to the object
  1260. const std::string& material_name = box->getSimple();
  1261. std::string LEGACY_FULLBRIGHT_DESC = LLTrans::getString("Fullbright");
  1262. if (material_name != LEGACY_FULLBRIGHT_DESC)
  1263. {
  1264. U8 material_code = LLMaterialTable::basic.getMCode(material_name);
  1265. LLSelectMgr::getInstance()->selectionSetMaterial(material_code);
  1266. }
  1267. }
  1268. }
  1270. // static
  1271. void LLPanelObject::onCommitParametric( LLUICtrl* ctrl, void* userdata )
  1272. {
  1273. LLPanelObject* self = (LLPanelObject*) userdata;
  1275. if (self->mObject.isNull())
  1276. {
  1277. return;
  1278. }
  1280. if (self->mObject->getPCode() != LL_PCODE_VOLUME)
  1281. {
  1282. // Don't allow modification of non-volume objects.
  1283. return;
  1284. }
  1286. LLVolume *volume = self->mObject->getVolume();
  1287. if (!volume)
  1288. {
  1289. return;
  1290. }
  1292. LLVolumeParams volume_params;
  1293. self->getVolumeParams(volume_params);
  1297. // set sculpting
  1298. S32 selected_type = self->mComboBaseType->getCurrentIndex();
  1300. if (selected_type == MI_SCULPT)
  1301. {
  1302. self->mObject->setParameterEntryInUse(LLNetworkData::PARAMS_SCULPT, TRUE, TRUE);
  1303. LLSculptParams *sculpt_params = (LLSculptParams *)self->mObject->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  1304. if (sculpt_params)
  1305. volume_params.setSculptID(sculpt_params->getSculptTexture(), sculpt_params->getSculptType());
  1306. }
  1307. else
  1308. {
  1309. LLSculptParams *sculpt_params = (LLSculptParams *)self->mObject->getParameterEntry(LLNetworkData::PARAMS_SCULPT);
  1310. if (sculpt_params)
  1311. self->mObject->setParameterEntryInUse(LLNetworkData::PARAMS_SCULPT, FALSE, TRUE);
  1312. }
  1314. // Update the volume, if necessary.
  1315. self->mObject->updateVolume(volume_params);
  1318. // This was added to make sure thate when changes are made, the UI
  1319. // adjusts to present valid options.
  1320. // *FIX: only some changes, ie, hollow or primitive type changes,
  1321. // require a refresh.
  1322. self->refresh();
  1324. }
  1326. void LLPanelObject::getVolumeParams(LLVolumeParams& volume_params)
  1327. {
  1328. // Figure out what type of volume to make
  1329. S32 was_selected_type = mSelectedType;
  1330. S32 selected_type = mComboBaseType->getCurrentIndex();
  1331. U8 profile;
  1332. U8 path;
  1333. switch ( selected_type )
  1334. {
  1335. case MI_CYLINDER:
  1336. profile = LL_PCODE_PROFILE_CIRCLE;
  1337. path = LL_PCODE_PATH_LINE;
  1338. break;
  1340. case MI_BOX:
  1341. profile = LL_PCODE_PROFILE_SQUARE;
  1342. path = LL_PCODE_PATH_LINE;
  1343. break;
  1345. case MI_PRISM:
  1346. profile = LL_PCODE_PROFILE_EQUALTRI;
  1347. path = LL_PCODE_PATH_LINE;
  1348. break;
  1350. case MI_SPHERE:
  1351. profile = LL_PCODE_PROFILE_CIRCLE_HALF;
  1352. path = LL_PCODE_PATH_CIRCLE;
  1353. break;
  1355. case MI_TORUS:
  1356. profile = LL_PCODE_PROFILE_CIRCLE;
  1357. path = LL_PCODE_PATH_CIRCLE;
  1358. break;
  1360. case MI_TUBE:
  1361. profile = LL_PCODE_PROFILE_SQUARE;
  1362. path = LL_PCODE_PATH_CIRCLE;
  1363. break;
  1365. case MI_RING:
  1366. profile = LL_PCODE_PROFILE_EQUALTRI;
  1367. path = LL_PCODE_PATH_CIRCLE;
  1368. break;
  1370. case MI_SCULPT:
  1371. profile = LL_PCODE_PROFILE_CIRCLE;
  1372. path = LL_PCODE_PATH_CIRCLE;
  1373. break;
  1375. default:
  1376. llwarns << "Unknown base type " << selected_type 
  1377. << " in getVolumeParams()" << llendl;
  1378. // assume a box
  1379. selected_type = MI_BOX;
  1380. profile = LL_PCODE_PROFILE_SQUARE;
  1381. path = LL_PCODE_PATH_LINE;
  1382. break;
  1383. }
  1386. if (path == LL_PCODE_PATH_LINE)
  1387. {
  1388. LLVOVolume *volobjp = (LLVOVolume *)(LLViewerObject*)(mObject);
  1389. if (volobjp->isFlexible())
  1390. {
  1391. path = LL_PCODE_PATH_FLEXIBLE;
  1392. }
  1393. }
  1395. S32 selected_hole = mComboHoleType->getCurrentIndex();
  1396. U8 hole;
  1397. switch (selected_hole)
  1398. {
  1399. case MI_HOLE_CIRCLE: 
  1400. hole = LL_PCODE_HOLE_CIRCLE;
  1401. break;
  1402. case MI_HOLE_SQUARE:
  1403. hole = LL_PCODE_HOLE_SQUARE;
  1404. break;
  1405. case MI_HOLE_TRIANGLE:
  1406. hole = LL_PCODE_HOLE_TRIANGLE;
  1407. break;
  1408. case MI_HOLE_SAME:
  1409. default:
  1410. hole = LL_PCODE_HOLE_SAME;
  1411. break;
  1412. }
  1414. volume_params.setType(profile | hole, path);
  1415. mSelectedType = selected_type;
  1417. // Compute cut start/end
  1418. F32 cut_begin = mSpinCutBegin->get();
  1419. F32 cut_end = mSpinCutEnd->get();
  1421. // Make sure at least OBJECT_CUT_INC of the object survives
  1422. if (cut_begin > cut_end - OBJECT_MIN_CUT_INC)
  1423. {
  1424. cut_begin = cut_end - OBJECT_MIN_CUT_INC;
  1425. mSpinCutBegin->set(cut_begin);
  1426. }
  1428. F32 adv_cut_begin = mCtrlPathBegin->get();
  1429. F32 adv_cut_end = mCtrlPathEnd->get();
  1431. // Make sure at least OBJECT_CUT_INC of the object survives
  1432. if (adv_cut_begin > adv_cut_end - OBJECT_MIN_CUT_INC)
  1433. {
  1434. adv_cut_begin = adv_cut_end - OBJECT_MIN_CUT_INC;
  1435. mCtrlPathBegin->set(adv_cut_begin);
  1436. }
  1438. F32 begin_s, end_s;
  1439. F32 begin_t, end_t;
  1441. if (selected_type == MI_SPHERE || selected_type == MI_TORUS || 
  1442. selected_type == MI_TUBE   || selected_type == MI_RING)
  1443. {
  1444. begin_s = adv_cut_begin;
  1445. end_s = adv_cut_end;
  1447. begin_t = cut_begin;
  1448. end_t = cut_end;
  1449. }
  1450. else
  1451. {
  1452. begin_s = cut_begin;
  1453. end_s = cut_end;
  1455. begin_t = adv_cut_begin;
  1456. end_t = adv_cut_end;
  1457. }
  1459. volume_params.setBeginAndEndS(begin_s, end_s);
  1460. volume_params.setBeginAndEndT(begin_t, end_t);
  1462. // Hollowness
  1463. F32 hollow = mSpinHollow->get() / 100.f;
  1465. if (  selected_hole == MI_HOLE_SQUARE && 
  1466. ( selected_type == MI_CYLINDER || selected_type == MI_TORUS ||
  1467.   selected_type == MI_PRISM    || selected_type == MI_RING  ||
  1468.   selected_type == MI_SPHERE ) )
  1469. {
  1470. if (hollow > 0.7f) hollow = 0.7f;
  1471. }
  1473. volume_params.setHollow( hollow );
  1475. // Twist Begin,End
  1476. F32 twist_begin = mSpinTwistBegin->get();
  1477. F32 twist = mSpinTwist->get();
  1478. // Check the path type for twist conversion.
  1479. if (path == LL_PCODE_PATH_LINE || path == LL_PCODE_PATH_FLEXIBLE)
  1480. {
  1481. twist_begin /= OBJECT_TWIST_LINEAR_MAX;
  1482. twist /= OBJECT_TWIST_LINEAR_MAX;
  1483. }
  1484. else
  1485. {
  1486. twist_begin /= OBJECT_TWIST_MAX;
  1487. twist /= OBJECT_TWIST_MAX;
  1488. }
  1490. volume_params.setTwistBegin(twist_begin);
  1491. volume_params.setTwist(twist);
  1493. // Scale X,Y
  1494. F32 scale_x = mSpinScaleX->get();
  1495. F32 scale_y = mSpinScaleY->get();
  1496. if ( was_selected_type == MI_BOX || was_selected_type == MI_CYLINDER || was_selected_type == MI_PRISM)
  1497. {
  1498. scale_x = 1.f - scale_x;
  1499. scale_y = 1.f - scale_y;
  1500. }
  1502. // Skew
  1503. F32 skew = mSpinSkew->get();
  1505. // Taper X,Y
  1506. F32 taper_x = mSpinTaperX->get();
  1507. F32 taper_y = mSpinTaperY->get();
  1509. // Radius offset
  1510. F32 radius_offset = mSpinRadiusOffset->get();
  1512. // Revolutions
  1513. F32 revolutions   = mSpinRevolutions->get();
  1515. if ( selected_type == MI_SPHERE )
  1516. {
  1517. // Snap values to valid sphere parameters.
  1518. scale_x = 1.0f;
  1519. scale_y = 1.0f;
  1520. skew = 0.0f;
  1521. taper_x = 0.0f;
  1522. taper_y = 0.0f;
  1523. radius_offset = 0.0f;
  1524. revolutions = 1.0f;
  1525. }
  1526. else if ( selected_type == MI_TORUS || selected_type == MI_TUBE ||
  1527.   selected_type == MI_RING )
  1528. {
  1529. scale_x = llclamp(
  1530. scale_x,
  1531. OBJECT_MIN_HOLE_SIZE,
  1532. OBJECT_MAX_HOLE_SIZE_X);
  1533. scale_y = llclamp(
  1534. scale_y,
  1535. OBJECT_MIN_HOLE_SIZE,
  1536. OBJECT_MAX_HOLE_SIZE_Y);
  1538. // Limit radius offset, based on taper and hole size y.
  1539. F32 radius_mag = fabs(radius_offset);
  1540. F32 hole_y_mag = fabs(scale_y);
  1541. F32 taper_y_mag  = fabs(taper_y);
  1542. // Check to see if the taper effects us.
  1543. if ( (radius_offset > 0.f && taper_y < 0.f) ||
  1544.  (radius_offset < 0.f && taper_y > 0.f) )
  1545. {
  1546. // The taper does not help increase the radius offset range.
  1547. taper_y_mag = 0.f;
  1548. }
  1549. F32 max_radius_mag = 1.f - hole_y_mag * (1.f - taper_y_mag) / (1.f - hole_y_mag);
  1550. // Enforce the maximum magnitude.
  1551. if (radius_mag > max_radius_mag)
  1552. {
  1553. // Check radius offset sign.
  1554. if (radius_offset < 0.f)
  1555. {
  1556. radius_offset = -max_radius_mag;
  1557. }
  1558. else
  1559. {
  1560. radius_offset = max_radius_mag;
  1561. }
  1562. }
  1564. // Check the skew value against the revolutions.
  1565. F32 skew_mag= fabs(skew);
  1566. F32 min_skew_mag = 1.0f - 1.0f / (revolutions * scale_x + 1.0f);
  1567. // Discontinuity; A revolution of 1 allows skews below 0.5.
  1568. if ( fabs(revolutions - 1.0f) < 0.001)
  1569. min_skew_mag = 0.0f;
  1571. // Clip skew.
  1572. if (skew_mag < min_skew_mag)
  1573. {
  1574. // Check skew sign.
  1575. if (skew < 0.0f)
  1576. {
  1577. skew = -min_skew_mag;
  1578. }
  1579. else 
  1580. {
  1581. skew = min_skew_mag;
  1582. }
  1583. }
  1584. }
  1586. volume_params.setRatio( scale_x, scale_y );
  1587. volume_params.setSkew(skew);
  1588. volume_params.setTaper( taper_x, taper_y );
  1589. volume_params.setRadiusOffset(radius_offset);
  1590. volume_params.setRevolutions(revolutions);
  1592. // Shear X,Y
  1593. F32 shear_x = mSpinShearX->get();
  1594. F32 shear_y = mSpinShearY->get();
  1595. volume_params.setShear( shear_x, shear_y );
  1597. if (selected_type == MI_SCULPT)
  1598. {
  1599. volume_params.setSculptID(LLUUID::null, 0);
  1600. volume_params.setBeginAndEndT   (0, 1);
  1601. volume_params.setBeginAndEndS   (0, 1);
  1602. volume_params.setHollow         (0);
  1603. volume_params.setTwistBegin     (0);
  1604. volume_params.setTwistEnd       (0);
  1605. volume_params.setRatio          (1, 0.5);
  1606. volume_params.setShear          (0, 0);
  1607. volume_params.setTaper          (0, 0);
  1608. volume_params.setRevolutions    (1);
  1609. volume_params.setRadiusOffset   (0);
  1610. volume_params.setSkew           (0);
  1611. }
  1613. }
  1615. // BUG: Make work with multiple objects
  1616. void LLPanelObject::sendRotation(BOOL btn_down)
  1617. {
  1618. if (mObject.isNull()) return;
  1620. LLVector3 new_rot(mCtrlRotX->get(), mCtrlRotY->get(), mCtrlRotZ->get());
  1621. new_rot.mV[VX] = llround(new_rot.mV[VX], OBJECT_ROTATION_PRECISION);
  1622. new_rot.mV[VY] = llround(new_rot.mV[VY], OBJECT_ROTATION_PRECISION);
  1623. new_rot.mV[VZ] = llround(new_rot.mV[VZ], OBJECT_ROTATION_PRECISION);
  1625. // Note: must compare before conversion to radians
  1626. LLVector3 delta = new_rot - mCurEulerDegrees;
  1628. if (delta.magVec() >= 0.0005f)
  1629. {
  1630. mCurEulerDegrees = new_rot;
  1631. new_rot *= DEG_TO_RAD;
  1633. LLQuaternion rotation;
  1634. rotation.setQuat(new_rot.mV[VX], new_rot.mV[VY], new_rot.mV[VZ]);
  1636. if (mRootObject != mObject)
  1637. {
  1638. rotation = rotation * ~mRootObject->getRotationRegion();
  1639. }
  1640. std::vector<LLVector3>& child_positions = mObject->mUnselectedChildrenPositions ;
  1641. std::vector<LLQuaternion> child_rotations;
  1642. if (mObject->isRootEdit())
  1643. {
  1644. mObject->saveUnselectedChildrenRotation(child_rotations) ;
  1645. mObject->saveUnselectedChildrenPosition(child_positions) ;
  1646. }
  1648. mObject->setRotation(rotation);
  1649. LLManip::rebuild(mObject) ;
  1651. // for individually selected roots, we need to counterrotate all the children
  1652. if (mObject->isRootEdit())
  1653. {
  1654. mObject->resetChildrenRotationAndPosition(child_rotations, child_positions) ;
  1655. }
  1657. if(!btn_down)
  1658. {
  1659. child_positions.clear() ;
  1660. LLSelectMgr::getInstance()->sendMultipleUpdate(UPD_ROTATION | UPD_POSITION);
  1661. }
  1662. }
  1663. }
  1666. // BUG: Make work with multiple objects
  1667. void LLPanelObject::sendScale(BOOL btn_down)
  1668. {
  1669. if (mObject.isNull()) return;
  1671. LLVector3 newscale(mCtrlScaleX->get(), mCtrlScaleY->get(), mCtrlScaleZ->get());
  1673. LLVector3 delta = newscale - mObject->getScale();
  1674. if (delta.magVec() >= 0.0005f)
  1675. {
  1676. // scale changed by more than 1/2 millimeter
  1678. // check to see if we aren't scaling the textures
  1679. // (in which case the tex coord's need to be recomputed)
  1680. BOOL dont_stretch_textures = !LLManipScale::getStretchTextures();
  1681. if (dont_stretch_textures)
  1682. {
  1683. LLSelectMgr::getInstance()->saveSelectedObjectTransform(SELECT_ACTION_TYPE_SCALE);
  1684. }
  1686. mObject->setScale(newscale, TRUE);
  1688. if(!btn_down)
  1689. {
  1690. LLSelectMgr::getInstance()->sendMultipleUpdate(UPD_SCALE | UPD_POSITION);
  1691. }
  1693. LLSelectMgr::getInstance()->adjustTexturesByScale(TRUE, !dont_stretch_textures);
  1694. // llinfos << "scale sent" << llendl;
  1695. }
  1696. else
  1697. {
  1698. // llinfos << "scale not changed" << llendl;
  1699. }
  1700. }
  1703. void LLPanelObject::sendPosition(BOOL btn_down)
  1704. {
  1705. if (mObject.isNull()) return;
  1707. LLVector3 newpos(mCtrlPosX->get(), mCtrlPosY->get(), mCtrlPosZ->get());
  1708. LLViewerRegion* regionp = mObject->getRegion();
  1710. // Clamp the Z height
  1711. const F32 height = newpos.mV[VZ];
  1712. const F32 min_height = LLWorld::getInstance()->getMinAllowedZ(mObject);
  1713. const F32 max_height = LLWorld::getInstance()->getRegionMaxHeight();
  1715. if (!mObject->isAttachment())
  1716. {
  1717. if ( height < min_height)
  1718. {
  1719. newpos.mV[VZ] = min_height;
  1720. mCtrlPosZ->set( min_height );
  1721. }
  1722. else if ( height > max_height )
  1723. {
  1724. newpos.mV[VZ] = max_height;
  1725. mCtrlPosZ->set( max_height );
  1726. }
  1728. // Grass is always drawn on the ground, so clamp its position to the ground
  1729. if (mObject->getPCode() == LL_PCODE_LEGACY_GRASS)
  1730. {
  1731. mCtrlPosZ->set(LLWorld::getInstance()->resolveLandHeightAgent(newpos) + 1.f);
  1732. }
  1733. }
  1735. // Make sure new position is in a valid region, so the object
  1736. // won't get dumped by the simulator.
  1737. LLVector3d new_pos_global = regionp->getPosGlobalFromRegion(newpos);
  1739. if ( LLWorld::getInstance()->positionRegionValidGlobal(new_pos_global) )
  1740. {
  1741. // send only if the position is changed, that is, the delta vector is not zero
  1742. LLVector3d old_pos_global = mObject->getPositionGlobal();
  1743. LLVector3d delta = new_pos_global - old_pos_global;
  1744. // moved more than 1/2 millimeter
  1745. if (delta.magVec() >= 0.0005f)
  1746. {
  1747. if (mRootObject != mObject)
  1748. {
  1749. newpos = newpos - mRootObject->getPositionRegion();
  1750. newpos = newpos * ~mRootObject->getRotationRegion();
  1751. mObject->setPositionParent(newpos);
  1752. }
  1753. else
  1754. {
  1755. mObject->setPositionEdit(newpos);
  1756. }
  1758. LLManip::rebuild(mObject) ;
  1760. // for individually selected roots, we need to counter-translate all unselected children
  1761. if (mObject->isRootEdit())
  1762. {
  1763. // only offset by parent's translation
  1764. mObject->resetChildrenPosition(LLVector3(-delta), TRUE) ;
  1765. }
  1767. if(!btn_down)
  1768. {
  1769. LLSelectMgr::getInstance()->sendMultipleUpdate(UPD_POSITION);
  1770. }
  1772. LLSelectMgr::getInstance()->updateSelectionCenter();
  1773. }
  1774. }
  1775. else
  1776. {
  1777. // move failed, so we update the UI with the correct values
  1778. LLVector3 vec = mRootObject->getPositionRegion();
  1779. mCtrlPosX->set(vec.mV[VX]);
  1780. mCtrlPosY->set(vec.mV[VY]);
  1781. mCtrlPosZ->set(vec.mV[VZ]);
  1782. }
  1783. }
  1785. void LLPanelObject::sendSculpt()
  1786. {
  1787. if (mObject.isNull())
  1788. return;
  1790. LLSculptParams sculpt_params;
  1792. if (mCtrlSculptTexture)
  1793. sculpt_params.setSculptTexture(mCtrlSculptTexture->getImageAssetID());
  1795. U8 sculpt_type = 0;
  1797. if (mCtrlSculptType)
  1798. sculpt_type |= mCtrlSculptType->getCurrentIndex();
  1800. if ((mCtrlSculptMirror) && (mCtrlSculptMirror->get()))
  1801. sculpt_type |= LL_SCULPT_FLAG_MIRROR;
  1803. if ((mCtrlSculptInvert) && (mCtrlSculptInvert->get()))
  1804. sculpt_type |= LL_SCULPT_FLAG_INVERT;
  1806. sculpt_params.setSculptType(sculpt_type);
  1807. mObject->setParameterEntry(LLNetworkData::PARAMS_SCULPT, sculpt_params, TRUE);
  1808. }
  1810. void LLPanelObject::refresh()
  1811. {
  1812. getState();
  1813. if (mObject.notNull() && mObject->isDead())
  1814. {
  1815. mObject = NULL;
  1816. }
  1818. if (mRootObject.notNull() && mRootObject->isDead())
  1819. {
  1820. mRootObject = NULL;
  1821. }
  1822. }
  1825. void LLPanelObject::draw()
  1826. {
  1827. const LLColor4 white( 1.0f, 1.0f, 1.0f, 1);
  1828. const LLColor4 red( 1.0f, 0.25f, 0.f, 1);
  1829. const LLColor4 green( 0.f, 1.0f, 0.f, 1);
  1830. const LLColor4 blue( 0.f, 0.5f, 1.0f, 1);
  1832. // Tune the colors of the labels
  1833. LLTool* tool = LLToolMgr::getInstance()->getCurrentTool();
  1835. if (tool == LLToolCompTranslate::getInstance())
  1836. {
  1837. mCtrlPosX ->setLabelColor(red);
  1838. mCtrlPosY ->setLabelColor(green);
  1839. mCtrlPosZ ->setLabelColor(blue);
  1841. mCtrlScaleX ->setLabelColor(white);
  1842. mCtrlScaleY ->setLabelColor(white);
  1843. mCtrlScaleZ ->setLabelColor(white);
  1845. mCtrlRotX ->setLabelColor(white);
  1846. mCtrlRotY ->setLabelColor(white);
  1847. mCtrlRotZ ->setLabelColor(white);
  1848. }
  1849. else if ( tool == LLToolCompScale::getInstance() )
  1850. {
  1851. mCtrlPosX ->setLabelColor(white);
  1852. mCtrlPosY ->setLabelColor(white);
  1853. mCtrlPosZ ->setLabelColor(white);
  1855. mCtrlScaleX ->setLabelColor(red);
  1856. mCtrlScaleY ->setLabelColor(green);
  1857. mCtrlScaleZ ->setLabelColor(blue);
  1859. mCtrlRotX ->setLabelColor(white);
  1860. mCtrlRotY ->setLabelColor(white);
  1861. mCtrlRotZ ->setLabelColor(white);
  1862. }
  1863. else if ( tool == LLToolCompRotate::getInstance() )
  1864. {
  1865. mCtrlPosX ->setLabelColor(white);
  1866. mCtrlPosY ->setLabelColor(white);
  1867. mCtrlPosZ ->setLabelColor(white);
  1869. mCtrlScaleX ->setLabelColor(white);
  1870. mCtrlScaleY ->setLabelColor(white);
  1871. mCtrlScaleZ ->setLabelColor(white);
  1873. mCtrlRotX ->setLabelColor(red);
  1874. mCtrlRotY ->setLabelColor(green);
  1875. mCtrlRotZ ->setLabelColor(blue);
  1876. }
  1877. else
  1878. {
  1879. mCtrlPosX ->setLabelColor(white);
  1880. mCtrlPosY ->setLabelColor(white);
  1881. mCtrlPosZ ->setLabelColor(white);
  1883. mCtrlScaleX ->setLabelColor(white);
  1884. mCtrlScaleY ->setLabelColor(white);
  1885. mCtrlScaleZ ->setLabelColor(white);
  1887. mCtrlRotX ->setLabelColor(white);
  1888. mCtrlRotY ->setLabelColor(white);
  1889. mCtrlRotZ ->setLabelColor(white);
  1890. }
  1892. LLPanel::draw();
  1893. }
  1895. // virtual
  1896. void LLPanelObject::clearCtrls()
  1897. {
  1898. LLPanel::clearCtrls();
  1900. mCheckLock ->set(FALSE);
  1901. mCheckLock ->setEnabled( FALSE );
  1902. mCheckPhysics ->set(FALSE);
  1903. mCheckPhysics ->setEnabled( FALSE );
  1904. mCheckTemporary ->set(FALSE);
  1905. mCheckTemporary ->setEnabled( FALSE );
  1906. mCheckPhantom ->set(FALSE);
  1907. mCheckPhantom ->setEnabled( FALSE );
  1908. #if 0 // 1.9.2
  1909. mCheckCastShadows->set(FALSE);
  1910. mCheckCastShadows->setEnabled( FALSE );
  1911. #endif
  1912. mComboMaterial ->setEnabled( FALSE );
  1913. mLabelMaterial ->setEnabled( FALSE );
  1914. // Disable text labels
  1915. mLabelPosition ->setEnabled( FALSE );
  1916. mLabelSize ->setEnabled( FALSE );
  1917. mLabelRotation ->setEnabled( FALSE );
  1918. mLabelBaseType ->setEnabled( FALSE );
  1919. mLabelCut ->setEnabled( FALSE );
  1920. mLabelHollow ->setEnabled( FALSE );
  1921. mLabelHoleType ->setEnabled( FALSE );
  1922. mLabelTwist ->setEnabled( FALSE );
  1923. mLabelSkew ->setEnabled( FALSE );
  1924. mLabelShear ->setEnabled( FALSE );
  1925. mLabelTaper ->setEnabled( FALSE );
  1926. mLabelRadiusOffset->setEnabled( FALSE );
  1927. mLabelRevolutions->setEnabled( FALSE );
  1929. childSetVisible("select_single", FALSE);
  1930. childSetVisible("edit_object", TRUE);
  1931. childSetEnabled("edit_object", FALSE);
  1933. childSetEnabled("scale_hole", FALSE);
  1934. childSetEnabled("scale_taper", FALSE);
  1935. childSetEnabled("advanced_cut", FALSE);
  1936. childSetEnabled("advanced_dimple", FALSE);
  1937. childSetVisible("advanced_slice", FALSE);
  1938. }
  1940. //
  1941. // Static functions
  1942. //
  1944. // static
  1945. void LLPanelObject::onCommitLock(LLUICtrl *ctrl, void *data)
  1946. {
  1947. // Checkbox will have toggled itself
  1948. LLPanelObject *self = (LLPanelObject *)data;
  1950. if(self->mRootObject.isNull()) return;
  1952. BOOL new_state = self->mCheckLock->get();
  1954. LLSelectMgr::getInstance()->selectionSetObjectPermissions(PERM_OWNER, !new_state, PERM_MOVE | PERM_MODIFY);
  1955. }
  1957. // static
  1958. void LLPanelObject::onCommitPosition( LLUICtrl* ctrl, void* userdata )
  1959. {
  1960. LLPanelObject* self = (LLPanelObject*) userdata;
  1961. BOOL btn_down = ((LLSpinCtrl*)ctrl)->isMouseHeldDown() ;
  1962. self->sendPosition(btn_down);
  1963. }
  1965. // static
  1966. void LLPanelObject::onCommitScale( LLUICtrl* ctrl, void* userdata )
  1967. {
  1968. LLPanelObject* self = (LLPanelObject*) userdata;
  1969. BOOL btn_down = ((LLSpinCtrl*)ctrl)->isMouseHeldDown() ;
  1970. self->sendScale(btn_down);
  1971. }
  1973. // static
  1974. void LLPanelObject::onCommitRotation( LLUICtrl* ctrl, void* userdata )
  1975. {
  1976. LLPanelObject* self = (LLPanelObject*) userdata;
  1977. BOOL btn_down = ((LLSpinCtrl*)ctrl)->isMouseHeldDown() ;
  1978. self->sendRotation(btn_down);
  1979. }
  1981. // static
  1982. void LLPanelObject::onCommitPhysics( LLUICtrl* ctrl, void* userdata )
  1983. {
  1984. LLPanelObject* self = (LLPanelObject*) userdata;
  1985. self->sendIsPhysical();
  1986. }
  1988. // static
  1989. void LLPanelObject::onCommitTemporary( LLUICtrl* ctrl, void* userdata )
  1990. {
  1991. LLPanelObject* self = (LLPanelObject*) userdata;
  1992. self->sendIsTemporary();
  1993. }
  1995. // static
  1996. void LLPanelObject::onCommitPhantom( LLUICtrl* ctrl, void* userdata )
  1997. {
  1998. LLPanelObject* self = (LLPanelObject*) userdata;
  1999. self->sendIsPhantom();
  2000. }
  2002. // static
  2003. void LLPanelObject::onCommitCastShadows( LLUICtrl* ctrl, void* userdata )
  2004. {
  2005. LLPanelObject* self = (LLPanelObject*) userdata;
  2006. self->sendCastShadows();
  2007. }
  2010. void LLPanelObject::onSelectSculpt(const LLSD& data)
  2011. {
  2012.     LLTextureCtrl* mTextureCtrl = getChild<LLTextureCtrl>("sculpt texture control");
  2014. if (mTextureCtrl)
  2015. {
  2016. mSculptTextureRevert = mTextureCtrl->getImageAssetID();
  2017. }
  2019. sendSculpt();
  2020. }
  2023. void LLPanelObject::onCommitSculpt( const LLSD& data )
  2024. {
  2025. sendSculpt();
  2026. }
  2028. BOOL LLPanelObject::onDropSculpt(LLInventoryItem* item)
  2029. {
  2030.     LLTextureCtrl* mTextureCtrl = getChild<LLTextureCtrl>("sculpt texture control");
  2032. if (mTextureCtrl)
  2033. {
  2034. LLUUID asset = item->getAssetUUID();
  2036. mTextureCtrl->setImageAssetID(asset);
  2037. mSculptTextureRevert = asset;
  2038. }
  2040. return TRUE;
  2041. }
  2044. void LLPanelObject::onCancelSculpt(const LLSD& data)
  2045. {
  2046. LLTextureCtrl* mTextureCtrl = getChild<LLTextureCtrl>("sculpt texture control");
  2047. if(!mTextureCtrl)
  2048. return;
  2050. mTextureCtrl->setImageAssetID(mSculptTextureRevert);
  2052. sendSculpt();
  2053. }
  2055. // static
  2056. void LLPanelObject::onCommitSculptType(LLUICtrl *ctrl, void* userdata)
  2057. {
  2058. LLPanelObject* self = (LLPanelObject*) userdata;
  2060. self->sendSculpt();
  2061. }