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

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

游戏引擎

开发平台：

C++ Builder

lldriverparam.cpp：源码内容
  1. /** 
  2.  * @file lldriverparam.cpp
  3.  * @brief A visual parameter that drives (controls) other visual parameters.
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "llviewerprecompiledheaders.h"
  35. #include "lldriverparam.h"
  37. #include "llfasttimer.h"
  38. #include "llvoavatar.h"
  39. #include "llvoavatarself.h"
  40. #include "llagent.h"
  41. #include "llwearable.h"
  42. #include "llagentwearables.h"
  44. //-----------------------------------------------------------------------------
  45. // LLDriverParamInfo
  46. //-----------------------------------------------------------------------------
  48. LLDriverParamInfo::LLDriverParamInfo()
  49. {
  50. }
  52. BOOL LLDriverParamInfo::parseXml(LLXmlTreeNode* node)
  53. {
  54. llassert( node->hasName( "param" ) && node->getChildByName( "param_driver" ) );
  56. if( !LLViewerVisualParamInfo::parseXml( node ))
  57. return FALSE;
  59. LLXmlTreeNode* param_driver_node = node->getChildByName( "param_driver" );
  60. if( !param_driver_node )
  61. return FALSE;
  63. for (LLXmlTreeNode* child = param_driver_node->getChildByName( "driven" );
  64.  child;
  65.  child = param_driver_node->getNextNamedChild())
  66. {
  67. S32 driven_id;
  68. static LLStdStringHandle id_string = LLXmlTree::addAttributeString("id");
  69. if( child->getFastAttributeS32( id_string, driven_id ) )
  70. {
  71. F32 min1 = mMinWeight;
  72. F32 max1 = mMaxWeight;
  73. F32 max2 = max1;
  74. F32 min2 = max1;
  76. // driven    ________ //
  77. // ^        /|       | //
  78. // |       / |       |  //
  79. // |      /  |       |   //
  80. // |     /   |       |    //
  81. // |    /    |       |     //
  82. //-------|----|-------|----|-------> driver //
  83. //  | min1   max1    max2  min2
  85. static LLStdStringHandle min1_string = LLXmlTree::addAttributeString("min1");
  86. child->getFastAttributeF32( min1_string, min1 ); // optional
  87. static LLStdStringHandle max1_string = LLXmlTree::addAttributeString("max1");
  88. child->getFastAttributeF32( max1_string, max1 ); // optional
  89. static LLStdStringHandle max2_string = LLXmlTree::addAttributeString("max2");
  90. child->getFastAttributeF32( max2_string, max2 ); // optional
  91. static LLStdStringHandle min2_string = LLXmlTree::addAttributeString("min2");
  92. child->getFastAttributeF32( min2_string, min2 ); // optional
  94. // Push these on the front of the deque, so that we can construct
  95. // them in order later (faster)
  96. mDrivenInfoList.push_front( LLDrivenEntryInfo( driven_id, min1, max1, max2, min2 ) );
  97. }
  98. else
  99. {
  100. llerrs << "<driven> Unable to resolve driven parameter: " << driven_id << llendl;
  101. return FALSE;
  102. }
  103. }
  104. return TRUE;
  105. }
  107. //virtual 
  108. void LLDriverParamInfo::toStream(std::ostream &out)
  109. {
  110. LLViewerVisualParamInfo::toStream(out);
  111. out << "driver" << "t";
  112. out << mDrivenInfoList.size() << "t";
  113. for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++)
  114. {
  115. LLDrivenEntryInfo driven = *iter;
  116. out << driven.mDrivenID << "t";
  117. }
  119. out << std::endl;
  121. LLVOAvatarSelf *avatar = gAgent.getAvatarObject();
  122. if(avatar)
  123. {
  124. for (entry_info_list_t::iterator iter = mDrivenInfoList.begin(); iter != mDrivenInfoList.end(); iter++)
  125. {
  126. LLDrivenEntryInfo driven = *iter;
  127. LLViewerVisualParam *param = (LLViewerVisualParam*)avatar->getVisualParam(driven.mDrivenID);
  128. if (param)
  129. {
  130. param->getInfo()->toStream(out);
  131. if (param->getWearableType() != mWearableType)
  132. {
  133. if(param->getCrossWearable())
  134. {
  135. out << "cross-wearable" << "t";
  136. }
  137. else
  138. {
  139. out << "ERROR!" << "t";
  140. }
  141. }
  142. else
  143. {
  144. out << "valid" << "t";
  145. }
  146. }
  147. else
  148. {
  149. llwarns << "could not get parameter " << driven.mDrivenID << " from avatar " << avatar << " for driver parameter " << getID() << llendl;
  150. }
  151. out << std::endl;
  152. }
  153. }
  154. }
  156. //-----------------------------------------------------------------------------
  157. // LLDriverParam
  158. //-----------------------------------------------------------------------------
  160. LLDriverParam::LLDriverParam(LLVOAvatar *avatarp) : 
  161. mCurrentDistortionParam( NULL ), 
  162. mAvatarp(avatarp), 
  163. mWearablep(NULL)
  164. {
  165. }
  167. LLDriverParam::LLDriverParam(LLWearable *wearablep) : 
  168. mCurrentDistortionParam( NULL ), 
  169. mAvatarp(NULL), 
  170. mWearablep(wearablep)
  171. {
  172. }
  174. LLDriverParam::~LLDriverParam()
  175. {
  176. }
  178. BOOL LLDriverParam::setInfo(LLDriverParamInfo *info)
  179. {
  180. llassert(mInfo == NULL);
  181. if (info->mID < 0)
  182. return FALSE;
  183. mInfo = info;
  184. mID = info->mID;
  186. setWeight(getDefaultWeight(), FALSE );
  188. return TRUE;
  189. }
  191. void LLDriverParam::setWearable(LLWearable *wearablep)
  192. {
  193. if (wearablep)
  194. {
  195. mWearablep = wearablep;
  196. mAvatarp = NULL;
  197. }
  198. }
  200. void LLDriverParam::setAvatar(LLVOAvatar *avatarp)
  201. {
  202. if (avatarp)
  203. {
  204. mWearablep = NULL;
  205. mAvatarp = avatarp;
  206. }
  207. }
  209. /*virtual*/ LLViewerVisualParam* LLDriverParam::cloneParam(LLWearable* wearable) const
  210. {
  211. LLDriverParam *new_param;
  212. if (wearable)
  213. {
  214. new_param = new LLDriverParam(wearable);
  215. }
  216. else
  217. {
  218. if (mWearablep)
  219. {
  220. new_param = new LLDriverParam(mWearablep);
  221. }
  222. else
  223. {
  224. new_param = new LLDriverParam(mAvatarp);
  225. }
  226. }
  227. *new_param = *this;
  228. return new_param;
  229. }
  231. #if 0 // obsolete
  232. BOOL LLDriverParam::parseData(LLXmlTreeNode* node)
  233. {
  234. LLDriverParamInfo* info = new LLDriverParamInfo;
  236. info->parseXml(node);
  237. if (!setInfo(info))
  238. {
  239. delete info;
  240. return FALSE;
  241. }
  242. return TRUE;
  243. }
  244. #endif
  246. void LLDriverParam::setWeight(F32 weight, BOOL upload_bake)
  247. {
  248. F32 min_weight = getMinWeight();
  249. F32 max_weight = getMaxWeight();
  250. if (mIsAnimating)
  251. {
  252. // allow overshoot when animating
  253. mCurWeight = weight;
  254. }
  255. else
  256. {
  257. mCurWeight = llclamp(weight, min_weight, max_weight);
  258. }
  260. // driven    ________
  261. // ^        /|       |       ^
  262. // |       / |       |       |
  263. // |      /  |       |       |
  264. // |     /   |       |       |
  265. // |    /    |       |       |
  266. //-------|----|-------|----|-------> driver
  267. //  | min1   max1    max2  min2
  269. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  270. {
  271. LLDrivenEntry* driven = &(*iter);
  272. LLDrivenEntryInfo* info = driven->mInfo;
  274. F32 driven_weight = 0.f;
  275. F32 driven_min = driven->mParam->getMinWeight();
  276. F32 driven_max = driven->mParam->getMaxWeight();
  278. if (mIsAnimating)
  279. {
  280. // driven param doesn't interpolate (textures, for example)
  281. if (!driven->mParam->getAnimating())
  282. {
  283. continue;
  284. }
  285. if( mCurWeight < info->mMin1 )
  286. {
  287. if (info->mMin1 == min_weight)
  288. {
  289. if (info->mMin1 == info->mMax1)
  290. {
  291. driven_weight = driven_max;
  292. }
  293. else
  294. {
  295. //up slope extrapolation
  296. F32 t = (mCurWeight - info->mMin1) / (info->mMax1 - info->mMin1 );
  297. driven_weight = driven_min + t * (driven_max - driven_min);
  298. }
  299. }
  300. else
  301. {
  302. driven_weight = driven_min;
  303. }
  305. setDrivenWeight(driven,driven_weight,upload_bake);
  306. continue;
  307. }
  308. else 
  309. if ( mCurWeight > info->mMin2 )
  310. {
  311. if (info->mMin2 == max_weight)
  312. {
  313. if (info->mMin2 == info->mMax2)
  314. {
  315. driven_weight = driven_max;
  316. }
  317. else
  318. {
  319. //down slope extrapolation
  320. F32 t = (mCurWeight - info->mMax2) / (info->mMin2 - info->mMax2 );
  321. driven_weight = driven_max + t * (driven_min - driven_max);
  322. }
  323. }
  324. else
  325. {
  326. driven_weight = driven_min;
  327. }
  329. setDrivenWeight(driven,driven_weight,upload_bake);
  330. continue;
  331. }
  332. }
  334. driven_weight = getDrivenWeight(driven, mCurWeight);
  335. setDrivenWeight(driven,driven_weight,upload_bake);
  336. }
  337. }
  339. F32 LLDriverParam::getTotalDistortion()
  340. {
  341. F32 sum = 0.f;
  342. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  343. {
  344. LLDrivenEntry* driven = &(*iter);
  345. sum += driven->mParam->getTotalDistortion();
  346. }
  348. return sum; 
  349. }
  351. const LLVector3 &LLDriverParam::getAvgDistortion()
  352. {
  353. // It's not actually correct to take the average of averages, but it good enough here.
  354. LLVector3 sum;
  355. S32 count = 0;
  356. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  357. {
  358. LLDrivenEntry* driven = &(*iter);
  359. sum += driven->mParam->getAvgDistortion();
  360. count++;
  361. }
  362. sum /= (F32)count;
  364. mDefaultVec = sum;
  365. return mDefaultVec; 
  366. }
  368. F32 LLDriverParam::getMaxDistortion() 
  369. {
  370. F32 max = 0.f;
  371. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  372. {
  373. LLDrivenEntry* driven = &(*iter);
  374. F32 param_max = driven->mParam->getMaxDistortion();
  375. if( param_max > max )
  376. {
  377. max = param_max;
  378. }
  379. }
  381. return max; 
  382. }
  385. LLVector3 LLDriverParam::getVertexDistortion(S32 index, LLPolyMesh *poly_mesh)
  386. {
  387. LLVector3 sum;
  388. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  389. {
  390. LLDrivenEntry* driven = &(*iter);
  391. sum += driven->mParam->getVertexDistortion( index, poly_mesh );
  392. }
  393. return sum;
  394. }
  396. const LLVector3* LLDriverParam::getFirstDistortion(U32 *index, LLPolyMesh **poly_mesh)
  397. {
  398. mCurrentDistortionParam = NULL;
  399. const LLVector3* v = NULL;
  400. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  401. {
  402. LLDrivenEntry* driven = &(*iter);
  403. v = driven->mParam->getFirstDistortion( index, poly_mesh );
  404. if( v )
  405. {
  406. mCurrentDistortionParam = driven->mParam;
  407. break;
  408. }
  409. }
  411. return v;
  412. };
  414. const LLVector3* LLDriverParam::getNextDistortion(U32 *index, LLPolyMesh **poly_mesh)
  415. {
  416. llassert( mCurrentDistortionParam );
  417. if( !mCurrentDistortionParam )
  418. {
  419. return NULL;
  420. }
  422. LLDrivenEntry* driven = NULL;
  423. entry_list_t::iterator iter;
  425. // Set mDriven iteration to the right point
  426. for( iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  427. {
  428. driven = &(*iter);
  429. if( driven->mParam == mCurrentDistortionParam )
  430. {
  431. break;
  432. }
  433. }
  435. llassert(driven);
  436. if (!driven)
  437. {
  438. return NULL; // shouldn't happen, but...
  439. }
  441. // We're already in the middle of a param's distortions, so get the next one.
  442. const LLVector3* v = driven->mParam->getNextDistortion( index, poly_mesh );
  443. if( (!v) && (iter != mDriven.end()) )
  444. {
  445. // This param is finished, so start the next param.  It might not have any
  446. // distortions, though, so we have to loop to find the next param that does.
  447. for( iter++; iter != mDriven.end(); iter++ )
  448. {
  449. driven = &(*iter);
  450. v = driven->mParam->getFirstDistortion( index, poly_mesh );
  451. if( v )
  452. {
  453. mCurrentDistortionParam = driven->mParam;
  454. break;
  455. }
  456. }
  457. }
  459. return v;
  460. };
  462. //-----------------------------------------------------------------------------
  463. // setAnimationTarget()
  464. //-----------------------------------------------------------------------------
  465. void LLDriverParam::setAnimationTarget( F32 target_value, BOOL upload_bake )
  466. {
  467. LLVisualParam::setAnimationTarget(target_value, upload_bake);
  469. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  470. {
  471. LLDrivenEntry* driven = &(*iter);
  472. F32 driven_weight = getDrivenWeight(driven, mTargetWeight);
  474. // this isn't normally necessary, as driver params handle interpolation of their driven params
  475. // but texture params need to know to assume their final value at beginning of interpolation
  476. driven->mParam->setAnimationTarget(driven_weight, upload_bake);
  477. }
  478. }
  480. //-----------------------------------------------------------------------------
  481. // stopAnimating()
  482. //-----------------------------------------------------------------------------
  483. void LLDriverParam::stopAnimating(BOOL upload_bake)
  484. {
  485. LLVisualParam::stopAnimating(upload_bake);
  487. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  488. {
  489. LLDrivenEntry* driven = &(*iter);
  490. driven->mParam->setAnimating(FALSE);
  491. }
  492. }
  494. /*virtual*/ 
  495. BOOL LLDriverParam::linkDrivenParams(visual_param_mapper mapper, BOOL only_cross_params)
  496. {
  497. BOOL success = TRUE;
  498. LLDriverParamInfo::entry_info_list_t::iterator iter;
  499. for (iter = getInfo()->mDrivenInfoList.begin(); iter != getInfo()->mDrivenInfoList.end(); ++iter)
  500. {
  501. LLDrivenEntryInfo *driven_info = &(*iter);
  502. S32 driven_id = driven_info->mDrivenID;
  504. // check for already existing links. Do not overwrite.
  505. BOOL found = FALSE;
  506. for (entry_list_t::iterator driven_iter = mDriven.begin(); driven_iter != mDriven.end() && !found; ++driven_iter)
  507. {
  508. if (driven_iter->mInfo->mDrivenID == driven_id)
  509. {
  510. found = TRUE;
  511. }
  512. }
  514. if (!found)
  515. {
  516. LLViewerVisualParam* param = (LLViewerVisualParam*)mapper(driven_id);
  517. bool push = param && (!only_cross_params || param->getCrossWearable());
  518. if (push)
  519. {
  520. mDriven.push_back(LLDrivenEntry( param, driven_info ));
  521. }
  522. else
  523. {
  524. success = FALSE;
  525. }
  526. }
  527. }
  529. return success;
  530. }
  532. void LLDriverParam::resetDrivenParams()
  533. {
  534. mDriven.clear();
  535. mDriven.reserve(getInfo()->mDrivenInfoList.size());
  536. }
  538. void LLDriverParam::updateCrossDrivenParams(EWearableType driven_type)
  539. {
  540. bool needs_update = (getWearableType()==driven_type);
  542. // if the driver has a driven entry for the passed-in wearable type, we need to refresh the value
  543. for( entry_list_t::iterator iter = mDriven.begin(); iter != mDriven.end(); iter++ )
  544. {
  545. LLDrivenEntry* driven = &(*iter);
  546. if (driven && driven->mParam && driven->mParam->getCrossWearable() && driven->mParam->getWearableType() == driven_type)
  547. {
  548. needs_update = true;
  549. }
  550. }
  553. if (needs_update)
  554. {
  555. EWearableType driver_type = (EWearableType)getWearableType();
  557. // If we've gotten here, we've added a new wearable of type "type"
  558. // Thus this wearable needs to get updates from the driver wearable.
  559. // The call to setVisualParamWeight seems redundant, but is necessary
  560. // as the number of driven wearables has changed since the last update. -Nyx
  561. LLWearable *wearable = gAgentWearables.getTopWearable(driver_type);
  562. if (wearable)
  563. {
  564. wearable->setVisualParamWeight(mID, wearable->getVisualParamWeight(mID), false);
  565. }
  566. }
  567. }
  570. //-----------------------------------------------------------------------------
  571. // getDrivenWeight()
  572. //-----------------------------------------------------------------------------
  573. F32 LLDriverParam::getDrivenWeight(const LLDrivenEntry* driven, F32 input_weight)
  574. {
  575. F32 min_weight = getMinWeight();
  576. F32 max_weight = getMaxWeight();
  577. const LLDrivenEntryInfo* info = driven->mInfo;
  579. F32 driven_weight = 0.f;
  580. F32 driven_min = driven->mParam->getMinWeight();
  581. F32 driven_max = driven->mParam->getMaxWeight();
  583. if( input_weight <= info->mMin1 )
  584. {
  585. if( info->mMin1 == info->mMax1 && 
  586. info->mMin1 <= min_weight)
  587. {
  588. driven_weight = driven_max;
  589. }
  590. else
  591. {
  592. driven_weight = driven_min;
  593. }
  594. }
  595. else
  596. if( input_weight <= info->mMax1 )
  597. {
  598. F32 t = (input_weight - info->mMin1) / (info->mMax1 - info->mMin1 );
  599. driven_weight = driven_min + t * (driven_max - driven_min);
  600. }
  601. else
  602. if( input_weight <= info->mMax2 )
  603. {
  604. driven_weight = driven_max;
  605. }
  606. else
  607. if( input_weight <= info->mMin2 )
  608. {
  609. F32 t = (input_weight - info->mMax2) / (info->mMin2 - info->mMax2 );
  610. driven_weight = driven_max + t * (driven_min - driven_max);
  611. }
  612. else
  613. {
  614. if (info->mMax2 >= max_weight)
  615. {
  616. driven_weight = driven_max;
  617. }
  618. else
  619. {
  620. driven_weight = driven_min;
  621. }
  622. }
  624. return driven_weight;
  625. }
  627. void LLDriverParam::setDrivenWeight(LLDrivenEntry *driven, F32 driven_weight, bool upload_bake)
  628. {
  629. LLVOAvatarSelf *avatar_self = gAgent.getAvatarObject();
  630. if(mWearablep && 
  631.    driven->mParam->getCrossWearable() &&
  632.    mWearablep->isOnTop())
  633. {
  634. // call setWeight through LLVOAvatarSelf so other wearables can be updated with the correct values
  635. avatar_self->setVisualParamWeight( (LLVisualParam*)driven->mParam, driven_weight, upload_bake );
  636. }
  637. else
  638. {
  639. driven->mParam->setWeight( driven_weight, upload_bake );
  640. }
  641. }