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

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

游戏引擎

开发平台：

C++ Builder

llpanelvolume.cpp：源码内容
  1. /** 
  2.  * @file llpanelvolume.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 "llpanelvolume.h"
  38. // linden library includes
  39. #include "llclickaction.h"
  40. #include "lleconomy.h"
  41. #include "llerror.h"
  42. #include "llfontgl.h"
  43. #include "llflexibleobject.h"
  44. #include "llmaterialtable.h"
  45. #include "llpermissionsflags.h"
  46. #include "llstring.h"
  47. #include "llvolume.h"
  48. #include "m3math.h"
  49. #include "material_codes.h"
  51. // project includes
  52. #include "llbutton.h"
  53. #include "llcheckboxctrl.h"
  54. #include "llcolorswatch.h"
  55. #include "lltexturectrl.h"
  56. #include "llcombobox.h"
  57. //#include "llfirstuse.h"
  58. #include "llfocusmgr.h"
  59. #include "llmanipscale.h"
  60. #include "llpreviewscript.h"
  61. #include "llresmgr.h"
  62. #include "llselectmgr.h"
  63. #include "llspinctrl.h"
  64. #include "lltextbox.h"
  65. #include "lltool.h"
  66. #include "lltoolcomp.h"
  67. #include "lltoolmgr.h"
  68. #include "llui.h"
  69. #include "llviewerobject.h"
  70. #include "llviewerregion.h"
  71. #include "llviewerwindow.h"
  72. #include "llvovolume.h"
  73. #include "llworld.h"
  74. #include "pipeline.h"
  75. #include "llviewershadermgr.h"
  77. #include "lldrawpool.h"
  78. #include "lluictrlfactory.h"
  80. // "Features" Tab
  82. BOOL LLPanelVolume::postBuild()
  83. {
  84. // Flexible Objects Parameters
  85. {
  86. childSetCommitCallback("Flexible1D Checkbox Ctrl",onCommitIsFlexible,this);
  87. childSetCommitCallback("FlexNumSections",onCommitFlexible,this);
  88. childSetValidate("FlexNumSections",precommitValidate);
  89. childSetCommitCallback("FlexGravity",onCommitFlexible,this);
  90. childSetValidate("FlexGravity",precommitValidate);
  91. childSetCommitCallback("FlexFriction",onCommitFlexible,this);
  92. childSetValidate("FlexFriction",precommitValidate);
  93. childSetCommitCallback("FlexWind",onCommitFlexible,this);
  94. childSetValidate("FlexWind",precommitValidate);
  95. childSetCommitCallback("FlexTension",onCommitFlexible,this);
  96. childSetValidate("FlexTension",precommitValidate);
  97. childSetCommitCallback("FlexForceX",onCommitFlexible,this);
  98. childSetValidate("FlexForceX",precommitValidate);
  99. childSetCommitCallback("FlexForceY",onCommitFlexible,this);
  100. childSetValidate("FlexForceY",precommitValidate);
  101. childSetCommitCallback("FlexForceZ",onCommitFlexible,this);
  102. childSetValidate("FlexForceZ",precommitValidate);
  103. }
  105. // LIGHT Parameters
  106. {
  107. childSetCommitCallback("Light Checkbox Ctrl",onCommitIsLight,this);
  108. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  109. if(LightColorSwatch){
  110. LightColorSwatch->setOnCancelCallback(boost::bind(&LLPanelVolume::onLightCancelColor, this, _2));
  111. LightColorSwatch->setOnSelectCallback(boost::bind(&LLPanelVolume::onLightSelectColor, this, _2));
  112. childSetCommitCallback("colorswatch",onCommitLight,this);
  113. }
  115. LLTextureCtrl* LightTexPicker = getChild<LLTextureCtrl>("light texture control");
  116. if (LightTexPicker)
  117. {
  118. LightTexPicker->setOnCancelCallback(boost::bind(&LLPanelVolume::onLightCancelTexture, this, _2));
  119. LightTexPicker->setOnSelectCallback(boost::bind(&LLPanelVolume::onLightSelectTexture, this, _2));
  120. childSetCommitCallback("light texture control", onCommitLight, this);
  121. }
  123. childSetCommitCallback("Light Intensity",onCommitLight,this);
  124. childSetValidate("Light Intensity",precommitValidate);
  125. childSetCommitCallback("Light Radius",onCommitLight,this);
  126. childSetValidate("Light Radius",precommitValidate);
  127. childSetCommitCallback("Light Falloff",onCommitLight,this);
  128. childSetValidate("Light Falloff",precommitValidate);
  130. childSetCommitCallback("Light FOV", onCommitLight, this);
  131. childSetValidate("Light FOV", precommitValidate);
  132. childSetCommitCallback("Light Focus", onCommitLight, this);
  133. childSetValidate("Light Focus", precommitValidate);
  134. childSetCommitCallback("Light Ambiance", onCommitLight, this);
  135. childSetValidate("Light Ambiance", precommitValidate);
  136. }
  138. // Start with everyone disabled
  139. clearCtrls();
  141. return TRUE;
  142. }
  144. LLPanelVolume::LLPanelVolume()
  145. : LLPanel()
  146. {
  147. setMouseOpaque(FALSE);
  149. }
  152. LLPanelVolume::~LLPanelVolume()
  153. {
  154. // Children all cleaned up by default view destructor.
  155. }
  157. void LLPanelVolume::getState( )
  158. {
  159. LLViewerObject* objectp = LLSelectMgr::getInstance()->getSelection()->getFirstRootObject();
  160. LLViewerObject* root_objectp = objectp;
  161. if(!objectp)
  162. {
  163. objectp = LLSelectMgr::getInstance()->getSelection()->getFirstObject();
  164. // *FIX: shouldn't we just keep the child?
  165. if (objectp)
  166. {
  167. LLViewerObject* parentp = objectp->getRootEdit();
  169. if (parentp)
  170. {
  171. root_objectp = parentp;
  172. }
  173. else
  174. {
  175. root_objectp = objectp;
  176. }
  177. }
  178. }
  180. LLVOVolume *volobjp = NULL;
  181. if ( objectp && (objectp->getPCode() == LL_PCODE_VOLUME))
  182. {
  183. volobjp = (LLVOVolume *)objectp;
  184. }
  186. if( !objectp )
  187. {
  188. //forfeit focus
  189. if (gFocusMgr.childHasKeyboardFocus(this))
  190. {
  191. gFocusMgr.setKeyboardFocus(NULL);
  192. }
  194. // Disable all text input fields
  195. clearCtrls();
  197. return;
  198. }
  200. BOOL owners_identical;
  201. LLUUID owner_id;
  202. std::string owner_name;
  203. owners_identical = LLSelectMgr::getInstance()->selectGetOwner(owner_id, owner_name);
  205. // BUG? Check for all objects being editable?
  206. BOOL editable = root_objectp->permModify();
  207. BOOL single_volume = LLSelectMgr::getInstance()->selectionAllPCode( LL_PCODE_VOLUME )
  208. && LLSelectMgr::getInstance()->getSelection()->getObjectCount() == 1;
  210. // Select Single Message
  211. if (single_volume)
  212. {
  213. childSetVisible("edit_object",true);
  214. childSetEnabled("edit_object",true);
  215. childSetVisible("select_single",false);
  216. }
  217. else
  218. {
  219. childSetVisible("edit_object",false);
  220. childSetVisible("select_single",true);
  221. childSetEnabled("select_single",true);
  222. }
  224. // Light properties
  225. BOOL is_light = volobjp && volobjp->getIsLight();
  226. childSetValue("Light Checkbox Ctrl",is_light);
  227. childSetEnabled("Light Checkbox Ctrl",editable && single_volume && volobjp);
  229. if (is_light && editable && single_volume)
  230. {
  231. childSetEnabled("label color",true);
  232. //mLabelColor  ->setEnabled( TRUE );
  233. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  234. if(LightColorSwatch)
  235. {
  236. LightColorSwatch->setEnabled( TRUE );
  237. LightColorSwatch->setValid( TRUE );
  238. LightColorSwatch->set(volobjp->getLightBaseColor());
  239. }
  241. LLTextureCtrl* LightTextureCtrl = getChild<LLTextureCtrl>("light texture control");
  242. if (LightTextureCtrl)
  243. {
  244. LightTextureCtrl->setEnabled(TRUE);
  245. LightTextureCtrl->setValid(TRUE);
  246. LightTextureCtrl->setImageAssetID(volobjp->getLightTextureID());
  247. }
  249. childSetEnabled("Light Intensity",true);
  250. childSetEnabled("Light Radius",true);
  251. childSetEnabled("Light Falloff",true);
  253. childSetEnabled("Light FOV", true);
  254. childSetEnabled("Light Focus", true);
  255. childSetEnabled("Light Ambiance", true);
  257. childSetValue("Light Intensity",volobjp->getLightIntensity());
  258. childSetValue("Light Radius",volobjp->getLightRadius());
  259. childSetValue("Light Falloff",volobjp->getLightFalloff());
  261. LLVector3 params = volobjp->getSpotLightParams();
  262. childSetValue("Light FOV", params.mV[0]);
  263. childSetValue("Light Focus", params.mV[1]);
  264. childSetValue("Light Ambiance", params.mV[2]);
  266. mLightSavedColor = volobjp->getLightColor();
  267. }
  268. else
  269. {
  270. getChild<LLSpinCtrl>("Light Intensity", true)->clear();
  271. getChild<LLSpinCtrl>("Light Radius", true)->clear();
  272. getChild<LLSpinCtrl>("Light Falloff", true)->clear();
  274. childSetEnabled("label color",false);
  275. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  276. if(LightColorSwatch)
  277. {
  278. LightColorSwatch->setEnabled( FALSE );
  279. LightColorSwatch->setValid( FALSE );
  280. }
  281. LLTextureCtrl* LightTextureCtrl = getChild<LLTextureCtrl>("light texture control");
  282. if (LightTextureCtrl)
  283. {
  284. LightTextureCtrl->setEnabled(FALSE);
  285. LightTextureCtrl->setValid(FALSE);
  286. }
  288. childSetEnabled("Light Intensity",false);
  289. childSetEnabled("Light Radius",false);
  290. childSetEnabled("Light Falloff",false);
  292. childSetEnabled("Light FOV",false);
  293. childSetEnabled("Light Focus",false);
  294. childSetEnabled("Light Ambiance",false);
  295. }
  297. // Flexible properties
  298. BOOL is_flexible = volobjp && volobjp->isFlexible();
  299. childSetValue("Flexible1D Checkbox Ctrl",is_flexible);
  300. if (is_flexible || (volobjp && volobjp->canBeFlexible()))
  301. {
  302. childSetEnabled("Flexible1D Checkbox Ctrl", editable && single_volume && volobjp);
  303. }
  304. else
  305. {
  306. childSetEnabled("Flexible1D Checkbox Ctrl", false);
  307. }
  308. if (is_flexible && editable && single_volume)
  309. {
  310. childSetVisible("FlexNumSections",true);
  311. childSetVisible("FlexGravity",true);
  312. childSetVisible("FlexTension",true);
  313. childSetVisible("FlexFriction",true);
  314. childSetVisible("FlexWind",true);
  315. childSetVisible("FlexForceX",true);
  316. childSetVisible("FlexForceY",true);
  317. childSetVisible("FlexForceZ",true);
  319. childSetEnabled("FlexNumSections",true);
  320. childSetEnabled("FlexGravity",true);
  321. childSetEnabled("FlexTension",true);
  322. childSetEnabled("FlexFriction",true);
  323. childSetEnabled("FlexWind",true);
  324. childSetEnabled("FlexForceX",true);
  325. childSetEnabled("FlexForceY",true);
  326. childSetEnabled("FlexForceZ",true);
  328. LLFlexibleObjectData *attributes = (LLFlexibleObjectData *)objectp->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
  330. childSetValue("FlexNumSections",(F32)attributes->getSimulateLOD());
  331. childSetValue("FlexGravity",attributes->getGravity());
  332. childSetValue("FlexTension",attributes->getTension());
  333. childSetValue("FlexFriction",attributes->getAirFriction());
  334. childSetValue("FlexWind",attributes->getWindSensitivity());
  335. childSetValue("FlexForceX",attributes->getUserForce().mV[VX]);
  336. childSetValue("FlexForceY",attributes->getUserForce().mV[VY]);
  337. childSetValue("FlexForceZ",attributes->getUserForce().mV[VZ]);
  338. }
  339. else
  340. {
  341. getChild<LLSpinCtrl>("FlexNumSections", true)->clear();
  342. getChild<LLSpinCtrl>("FlexGravity", true)->clear();
  343. getChild<LLSpinCtrl>("FlexTension", true)->clear();
  344. getChild<LLSpinCtrl>("FlexFriction", true)->clear();
  345. getChild<LLSpinCtrl>("FlexWind", true)->clear();
  346. getChild<LLSpinCtrl>("FlexForceX", true)->clear();
  347. getChild<LLSpinCtrl>("FlexForceY", true)->clear();
  348. getChild<LLSpinCtrl>("FlexForceZ", true)->clear();
  350. childSetEnabled("FlexNumSections",false);
  351. childSetEnabled("FlexGravity",false);
  352. childSetEnabled("FlexTension",false);
  353. childSetEnabled("FlexFriction",false);
  354. childSetEnabled("FlexWind",false);
  355. childSetEnabled("FlexForceX",false);
  356. childSetEnabled("FlexForceY",false);
  357. childSetEnabled("FlexForceZ",false);
  358. }
  360. mObject = objectp;
  361. mRootObject = root_objectp;
  362. }
  364. // static
  365. bool LLPanelVolume::precommitValidate( const LLSD& data )
  366. {
  367. // TODO: Richard will fill this in later.  
  368. return TRUE; // FALSE means that validation failed and new value should not be commited.
  369. }
  372. void LLPanelVolume::refresh()
  373. {
  374. getState();
  375. if (mObject.notNull() && mObject->isDead())
  376. {
  377. mObject = NULL;
  378. }
  380. if (mRootObject.notNull() && mRootObject->isDead())
  381. {
  382. mRootObject = NULL;
  383. }
  385. BOOL visible = LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_DEFERRED) > 0 ? TRUE : FALSE;
  387. childSetVisible("label texture", visible);
  388. childSetVisible("Light FOV", visible);
  389. childSetVisible("Light Focus", visible);
  390. childSetVisible("Light Ambiance", visible);
  391. childSetVisible("light texture control", visible);
  393. }
  396. void LLPanelVolume::draw()
  397. {
  398. LLPanel::draw();
  399. }
  401. // virtual
  402. void LLPanelVolume::clearCtrls()
  403. {
  404. LLPanel::clearCtrls();
  406. childSetEnabled("select_single",false);
  407. childSetVisible("select_single",true);
  408. childSetEnabled("edit_object",false);
  409. childSetVisible("edit_object",false);
  410. childSetEnabled("Light Checkbox Ctrl",false);
  411. childSetEnabled("label color",false);
  412. childSetEnabled("label color",false);
  413. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  414. if(LightColorSwatch)
  415. {
  416. LightColorSwatch->setEnabled( FALSE );
  417. LightColorSwatch->setValid( FALSE );
  418. }
  419. LLTextureCtrl* LightTextureCtrl = getChild<LLTextureCtrl>("light texture control");
  420. if(LightTextureCtrl)
  421. {
  422. LightTextureCtrl->setEnabled( FALSE );
  423. LightTextureCtrl->setValid( FALSE );
  424. }
  426. childSetEnabled("Light Intensity",false);
  427. childSetEnabled("Light Radius",false);
  428. childSetEnabled("Light Falloff",false);
  430. childSetEnabled("Flexible1D Checkbox Ctrl",false);
  431. childSetEnabled("FlexNumSections",false);
  432. childSetEnabled("FlexGravity",false);
  433. childSetEnabled("FlexTension",false);
  434. childSetEnabled("FlexFriction",false);
  435. childSetEnabled("FlexWind",false);
  436. childSetEnabled("FlexForceX",false);
  437. childSetEnabled("FlexForceY",false);
  438. childSetEnabled("FlexForceZ",false);
  439. }
  441. //
  442. // Static functions
  443. //
  445. void LLPanelVolume::sendIsLight()
  446. {
  447. LLViewerObject* objectp = mObject;
  448. if (!objectp || (objectp->getPCode() != LL_PCODE_VOLUME))
  449. {
  450. return;
  451. }
  452. LLVOVolume *volobjp = (LLVOVolume *)objectp;
  454. BOOL value = childGetValue("Light Checkbox Ctrl");
  455. volobjp->setIsLight(value);
  456. llinfos << "update light sent" << llendl;
  457. }
  459. void LLPanelVolume::sendIsFlexible()
  460. {
  461. LLViewerObject* objectp = mObject;
  462. if (!objectp || (objectp->getPCode() != LL_PCODE_VOLUME))
  463. {
  464. return;
  465. }
  466. LLVOVolume *volobjp = (LLVOVolume *)objectp;
  468. BOOL is_flexible = childGetValue("Flexible1D Checkbox Ctrl");
  469. //BOOL is_flexible = mCheckFlexible1D->get();
  471. if (is_flexible)
  472. {
  473. //LLFirstUse::useFlexible();
  475. if (objectp->getClickAction() == CLICK_ACTION_SIT)
  476. {
  477. LLSelectMgr::getInstance()->selectionSetClickAction(CLICK_ACTION_NONE);
  478. }
  480. }
  482. if (volobjp->setIsFlexible(is_flexible))
  483. {
  484. mObject->sendShapeUpdate();
  485. LLSelectMgr::getInstance()->selectionUpdatePhantom(volobjp->flagPhantom());
  486. }
  488. llinfos << "update flexible sent" << llendl;
  489. }
  491. void LLPanelVolume::onLightCancelColor(const LLSD& data)
  492. {
  493. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  494. if(LightColorSwatch)
  495. {
  496. LightColorSwatch->setColor(mLightSavedColor);
  497. }
  498. onLightSelectColor(data);
  499. }
  501. void LLPanelVolume::onLightCancelTexture(const LLSD& data)
  502. {
  503. LLTextureCtrl* LightTextureCtrl = getChild<LLTextureCtrl>("light texture control");
  504. if (LightTextureCtrl)
  505. {
  506. LightTextureCtrl->setImageAssetID(mLightSavedTexture);
  507. }
  508. }
  510. void LLPanelVolume::onLightSelectColor(const LLSD& data)
  511. {
  512. LLViewerObject* objectp = mObject;
  513. if (!objectp || (objectp->getPCode() != LL_PCODE_VOLUME))
  514. {
  515. return;
  516. }
  517. LLVOVolume *volobjp = (LLVOVolume *)objectp;
  520. LLColorSwatchCtrl* LightColorSwatch = getChild<LLColorSwatchCtrl>("colorswatch");
  521. if(LightColorSwatch)
  522. {
  523. LLColor4 clr = LightColorSwatch->get();
  524. LLColor3 clr3( clr );
  525. volobjp->setLightColor(clr3);
  526. mLightSavedColor = clr;
  527. }
  528. }
  530. void LLPanelVolume::onLightSelectTexture(const LLSD& data)
  531. {
  532. if (mObject.isNull() || (mObject->getPCode() != LL_PCODE_VOLUME))
  533. {
  534. return;
  535. }
  536. LLVOVolume *volobjp = (LLVOVolume *) mObject.get();
  539. LLTextureCtrl* LightTextureCtrl = getChild<LLTextureCtrl>("light texture control");
  540. if(LightTextureCtrl)
  541. {
  542. LLUUID id = LightTextureCtrl->getImageAssetID();
  543. volobjp->setLightTextureID(id);
  544. mLightSavedTexture = id;
  545. }
  546. }
  548. // static
  549. void LLPanelVolume::onCommitLight( LLUICtrl* ctrl, void* userdata )
  550. {
  551. LLPanelVolume* self = (LLPanelVolume*) userdata;
  552. LLViewerObject* objectp = self->mObject;
  553. if (!objectp || (objectp->getPCode() != LL_PCODE_VOLUME))
  554. {
  555. return;
  556. }
  557. LLVOVolume *volobjp = (LLVOVolume *)objectp;
  560. volobjp->setLightIntensity((F32)self->childGetValue("Light Intensity").asReal());
  561. volobjp->setLightRadius((F32)self->childGetValue("Light Radius").asReal());
  562. volobjp->setLightFalloff((F32)self->childGetValue("Light Falloff").asReal());
  564. LLColorSwatchCtrl* LightColorSwatch = self->getChild<LLColorSwatchCtrl>("colorswatch");
  565. if(LightColorSwatch)
  566. {
  567. LLColor4 clr = LightColorSwatch->get();
  568. volobjp->setLightColor(LLColor3(clr));
  569. }
  571. LLTextureCtrl* LightTextureCtrl = self->getChild<LLTextureCtrl>("light texture control");
  572. if(LightTextureCtrl)
  573. {
  574. LLUUID id = LightTextureCtrl->getImageAssetID();
  575. if (id.notNull())
  576. {
  577. if (volobjp->getLightTextureID().isNull())
  578. { //this commit is making this a spot light, set UI to default params
  579. volobjp->setLightTextureID(id);
  580. LLVector3 spot_params = volobjp->getSpotLightParams();
  581. self->childSetValue("Light FOV", spot_params.mV[0]);
  582. self->childSetValue("Light Focus", spot_params.mV[1]);
  583. self->childSetValue("Light Ambiance", spot_params.mV[2]);
  584. }
  585. else
  586. { //modifying existing params
  587. LLVector3 spot_params;
  588. spot_params.mV[0] = (F32) self->childGetValue("Light FOV").asReal();
  589. spot_params.mV[1] = (F32) self->childGetValue("Light Focus").asReal();
  590. spot_params.mV[2] = (F32) self->childGetValue("Light Ambiance").asReal();
  591. volobjp->setSpotLightParams(spot_params);
  592. }
  593. }
  594. else if (volobjp->getLightTextureID().notNull())
  595. { //no longer a spot light
  596. volobjp->setLightTextureID(id);
  597. //self->childDisable("Light FOV");
  598. //self->childDisable("Light Focus");
  599. //self->childDisable("Light Ambiance");
  600. }
  601. }
  604. }
  606. // static
  607. void LLPanelVolume::onCommitIsLight( LLUICtrl* ctrl, void* userdata )
  608. {
  609. LLPanelVolume* self = (LLPanelVolume*) userdata;
  610. self->sendIsLight();
  611. }
  613. //----------------------------------------------------------------------------
  615. // static
  616. void LLPanelVolume::onCommitFlexible( LLUICtrl* ctrl, void* userdata )
  617. {
  618. LLPanelVolume* self = (LLPanelVolume*) userdata;
  619. LLViewerObject* objectp = self->mObject;
  620. if (!objectp || (objectp->getPCode() != LL_PCODE_VOLUME))
  621. {
  622. return;
  623. }
  625. LLFlexibleObjectData *attributes = (LLFlexibleObjectData *)objectp->getParameterEntry(LLNetworkData::PARAMS_FLEXIBLE);
  626. if (attributes)
  627. {
  628. LLFlexibleObjectData new_attributes;
  629. new_attributes = *attributes;
  632. new_attributes.setSimulateLOD(self->childGetValue("FlexNumSections").asInteger());//(S32)self->mSpinSections->get());
  633. new_attributes.setGravity((F32)self->childGetValue("FlexGravity").asReal());
  634. new_attributes.setTension((F32)self->childGetValue("FlexTension").asReal());
  635. new_attributes.setAirFriction((F32)self->childGetValue("FlexFriction").asReal());
  636. new_attributes.setWindSensitivity((F32)self->childGetValue("FlexWind").asReal());
  637. F32 fx = (F32)self->childGetValue("FlexForceX").asReal();
  638. F32 fy = (F32)self->childGetValue("FlexForceY").asReal();
  639. F32 fz = (F32)self->childGetValue("FlexForceZ").asReal();
  640. LLVector3 force(fx,fy,fz);
  642. new_attributes.setUserForce(force);
  643. objectp->setParameterEntry(LLNetworkData::PARAMS_FLEXIBLE, new_attributes, true);
  644. }
  646. // Values may fail validation
  647. self->refresh();
  648. }
  650. // static
  651. void LLPanelVolume::onCommitIsFlexible( LLUICtrl* ctrl, void* userdata )
  652. {
  653. LLPanelVolume* self = (LLPanelVolume*) userdata;
  654. self->sendIsFlexible();
  655. }