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

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

游戏引擎

开发平台：

C++ Builder

llviewerpartsim.cpp：源码内容
  1. /** 
  2.  * @file llviewerpartsim.cpp
  3.  * @brief LLViewerPart class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2003&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2003-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 "llviewerpartsim.h"
  37. #include "llviewercontrol.h"
  39. #include "llagent.h"
  40. #include "llviewercamera.h"
  41. #include "llviewerobjectlist.h"
  42. #include "llviewerpartsource.h"
  43. #include "llviewerregion.h"
  44. #include "llvopartgroup.h"
  45. #include "llworld.h"
  46. #include "pipeline.h"
  47. #include "llspatialpartition.h"
  48. #include "llvovolume.h"
  50. const F32 PART_SIM_BOX_SIDE = 16.f;
  51. const F32 PART_SIM_BOX_OFFSET = 0.5f*PART_SIM_BOX_SIDE;
  52. const F32 PART_SIM_BOX_RAD = 0.5f*F_SQRT3*PART_SIM_BOX_SIDE;
  54. //static
  55. S32 LLViewerPartSim::sMaxParticleCount = 0;
  56. S32 LLViewerPartSim::sParticleCount = 0;
  57. S32 LLViewerPartSim::sParticleCount2 = 0;
  58. // This controls how greedy individual particle burst sources are allowed to be, and adapts according to how near the particle-count limit we are.
  59. F32 LLViewerPartSim::sParticleAdaptiveRate = 0.0625f;
  60. F32 LLViewerPartSim::sParticleBurstRate = 0.5f;
  62. //static
  63. const S32 LLViewerPartSim::MAX_PART_COUNT = 8192;
  64. const F32 LLViewerPartSim::PART_THROTTLE_THRESHOLD = 0.9f;
  65. const F32 LLViewerPartSim::PART_ADAPT_RATE_MULT = 2.0f;
  67. //static
  68. const F32 LLViewerPartSim::PART_THROTTLE_RESCALE = PART_THROTTLE_THRESHOLD / (1.0f-PART_THROTTLE_THRESHOLD);
  69. const F32 LLViewerPartSim::PART_ADAPT_RATE_MULT_RECIP = 1.0f/PART_ADAPT_RATE_MULT;
  72. U32 LLViewerPart::sNextPartID = 1;
  74. F32 calc_desired_size(LLViewerCamera* camera, LLVector3 pos, LLVector2 scale)
  75. {
  76. F32 desired_size = (pos - camera->getOrigin()).magVec();
  77. desired_size /= 4;
  78. return llclamp(desired_size, scale.magVec()*0.5f, PART_SIM_BOX_SIDE*2);
  79. }
  81. LLViewerPart::LLViewerPart() :
  82. mPartID(0),
  83. mLastUpdateTime(0.f),
  84. mSkipOffset(0.f),
  85. mVPCallback(NULL),
  86. mImagep(NULL)
  87. {
  88. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  89. mPartSourcep = NULL;
  91. ++LLViewerPartSim::sParticleCount2 ;
  92. }
  94. LLViewerPart::~LLViewerPart()
  95. {
  96. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  97. mPartSourcep = NULL;
  99. --LLViewerPartSim::sParticleCount2 ;
  100. }
  102. void LLViewerPart::init(LLPointer<LLViewerPartSource> sourcep, LLViewerTexture *imagep, LLVPCallback cb)
  103. {
  104. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  105. mPartID = LLViewerPart::sNextPartID;
  106. LLViewerPart::sNextPartID++;
  107. mFlags = 0x00f;
  108. mLastUpdateTime = 0.f;
  109. mMaxAge = 10.f;
  110. mSkipOffset = 0.0f;
  112. mVPCallback = cb;
  113. mPartSourcep = sourcep;
  115. mImagep = imagep;
  116. }
  119. /////////////////////////////
  120. //
  121. // LLViewerPartGroup implementation
  122. //
  123. //
  126. LLViewerPartGroup::LLViewerPartGroup(const LLVector3 &center_agent, const F32 box_side, bool hud)
  127.  : mHud(hud)
  128. {
  129. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  130. mVOPartGroupp = NULL;
  131. mUniformParticles = TRUE;
  133. mRegionp = LLWorld::getInstance()->getRegionFromPosAgent(center_agent);
  134. llassert_always(center_agent.isFinite());
  136. if (!mRegionp)
  137. {
  138. //llwarns << "No region at position, using agent region!" << llendl;
  139. mRegionp = gAgent.getRegion();
  140. }
  141. mCenterAgent = center_agent;
  142. mBoxRadius = F_SQRT3*box_side*0.5f;
  144. if (mHud)
  145. {
  146. mVOPartGroupp = (LLVOPartGroup *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_HUD_PART_GROUP, getRegion());
  147. }
  148. else
  149. {
  150. mVOPartGroupp = (LLVOPartGroup *)gObjectList.createObjectViewer(LLViewerObject::LL_VO_PART_GROUP, getRegion());
  151. }
  152. mVOPartGroupp->setViewerPartGroup(this);
  153. mVOPartGroupp->setPositionAgent(getCenterAgent());
  154. F32 scale = box_side * 0.5f;
  155. mVOPartGroupp->setScale(LLVector3(scale,scale,scale));
  157. //gPipeline.addObject(mVOPartGroupp);
  158. gPipeline.createObject(mVOPartGroupp);
  160. LLSpatialGroup* group = mVOPartGroupp->mDrawable->getSpatialGroup();
  162. if (group != NULL)
  163. {
  164. LLVector3 center(group->mOctreeNode->getCenter());
  165. LLVector3 size(group->mOctreeNode->getSize());
  166. size += LLVector3(0.01f, 0.01f, 0.01f);
  167. mMinObjPos = center - size;
  168. mMaxObjPos = center + size;
  169. }
  170. else 
  171. {
  172. // Not sure what else to set the obj bounds to when the drawable has no spatial group.
  173. LLVector3 extents(mBoxRadius, mBoxRadius, mBoxRadius);
  174. mMinObjPos = center_agent - extents;
  175. mMaxObjPos = center_agent + extents;
  176. }
  178. mSkippedTime = 0.f;
  180. static U32 id_seed = 0;
  181. mID = ++id_seed;
  182. }
  184. LLViewerPartGroup::~LLViewerPartGroup()
  185. {
  186. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  187. cleanup();
  189. S32 count = (S32) mParticles.size();
  190. for(S32 i = 0 ; i < count ; i++)
  191. {
  192. delete mParticles[i] ;
  193. }
  194. mParticles.clear();
  196. LLViewerPartSim::decPartCount(count);
  197. }
  199. void LLViewerPartGroup::cleanup()
  200. {
  201. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  202. if (mVOPartGroupp)
  203. {
  204. if (!mVOPartGroupp->isDead())
  205. {
  206. gObjectList.killObject(mVOPartGroupp);
  207. }
  208. mVOPartGroupp = NULL;
  209. }
  210. }
  212. BOOL LLViewerPartGroup::posInGroup(const LLVector3 &pos, const F32 desired_size)
  213. {
  214. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  215. if ((pos.mV[VX] < mMinObjPos.mV[VX])
  216. || (pos.mV[VY] < mMinObjPos.mV[VY])
  217. || (pos.mV[VZ] < mMinObjPos.mV[VZ]))
  218. {
  219. return FALSE;
  220. }
  222. if ((pos.mV[VX] > mMaxObjPos.mV[VX])
  223. || (pos.mV[VY] > mMaxObjPos.mV[VY])
  224. || (pos.mV[VZ] > mMaxObjPos.mV[VZ]))
  225. {
  226. return FALSE;
  227. }
  229. if (desired_size > 0 && 
  230. (desired_size < mBoxRadius*0.5f ||
  231. desired_size > mBoxRadius*2.f))
  232. {
  233. return FALSE;
  234. }
  236. return TRUE;
  237. }
  240. BOOL LLViewerPartGroup::addPart(LLViewerPart* part, F32 desired_size)
  241. {
  242. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  244. if (part->mFlags & LLPartData::LL_PART_HUD && !mHud)
  245. {
  246. return FALSE;
  247. }
  249. BOOL uniform_part = part->mScale.mV[0] == part->mScale.mV[1] && 
  250. !(part->mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK);
  252. if (!posInGroup(part->mPosAgent, desired_size) ||
  253. (mUniformParticles && !uniform_part) ||
  254. (!mUniformParticles && uniform_part))
  255. {
  256. return FALSE;
  257. }
  259. gPipeline.markRebuild(mVOPartGroupp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  261. mParticles.push_back(part);
  262. part->mSkipOffset=mSkippedTime;
  263. LLViewerPartSim::incPartCount(1);
  264. return TRUE;
  265. }
  268. void LLViewerPartGroup::updateParticles(const F32 lastdt)
  269. {
  270. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  271. F32 dt;
  273. LLVector3 gravity(0.f, 0.f, GRAVITY);
  275. LLViewerPartSim::checkParticleCount(mParticles.size());
  277. LLViewerCamera* camera = LLViewerCamera::getInstance();
  278. LLViewerRegion *regionp = getRegion();
  279. S32 end = (S32) mParticles.size();
  280. for (S32 i = 0 ; i < (S32)mParticles.size();)
  281. {
  282. LLVector3 a(0.f, 0.f, 0.f);
  283. LLViewerPart* part = mParticles[i] ;
  285. dt = lastdt + mSkippedTime - part->mSkipOffset;
  286. part->mSkipOffset = 0.f;
  288. // Update current time
  289. const F32 cur_time = part->mLastUpdateTime + dt;
  290. const F32 frac = cur_time / part->mMaxAge;
  292. // "Drift" the object based on the source object
  293. if (part->mFlags & LLPartData::LL_PART_FOLLOW_SRC_MASK)
  294. {
  295. part->mPosAgent = part->mPartSourcep->mPosAgent;
  296. part->mPosAgent += part->mPosOffset;
  297. }
  299. // Do a custom callback if we have one...
  300. if (part->mVPCallback)
  301. {
  302. (*part->mVPCallback)(*part, dt);
  303. }
  305. if (part->mFlags & LLPartData::LL_PART_WIND_MASK)
  306. {
  307. LLVector3 tempVel(part->mVelocity);
  308. part->mVelocity *= 1.f - 0.1f*dt;
  309. part->mVelocity += 0.1f*dt*regionp->mWind.getVelocity(regionp->getPosRegionFromAgent(part->mPosAgent));
  310. }
  312. // Now do interpolation towards a target
  313. if (part->mFlags & LLPartData::LL_PART_TARGET_POS_MASK)
  314. {
  315. F32 remaining = part->mMaxAge - part->mLastUpdateTime;
  316. F32 step = dt / remaining;
  318. step = llclamp(step, 0.f, 0.1f);
  319. step *= 5.f;
  320. // we want a velocity that will result in reaching the target in the 
  321. // Interpolate towards the target.
  322. LLVector3 delta_pos = part->mPartSourcep->mTargetPosAgent - part->mPosAgent;
  324. delta_pos /= remaining;
  326. part->mVelocity *= (1.f - step);
  327. part->mVelocity += step*delta_pos;
  328. }
  331. if (part->mFlags & LLPartData::LL_PART_TARGET_LINEAR_MASK)
  332. {
  333. LLVector3 delta_pos = part->mPartSourcep->mTargetPosAgent - part->mPartSourcep->mPosAgent;
  334. part->mPosAgent = part->mPartSourcep->mPosAgent;
  335. part->mPosAgent += frac*delta_pos;
  336. part->mVelocity = delta_pos;
  337. }
  338. else
  339. {
  340. // Do velocity interpolation
  341. part->mPosAgent += dt*part->mVelocity;
  342. part->mPosAgent += 0.5f*dt*dt*part->mAccel;
  343. part->mVelocity += part->mAccel*dt;
  344. }
  346. // Do a bounce test
  347. if (part->mFlags & LLPartData::LL_PART_BOUNCE_MASK)
  348. {
  349. // Need to do point vs. plane check...
  350. // For now, just check relative to object height...
  351. F32 dz = part->mPosAgent.mV[VZ] - part->mPartSourcep->mPosAgent.mV[VZ];
  352. if (dz < 0)
  353. {
  354. part->mPosAgent.mV[VZ] += -2.f*dz;
  355. part->mVelocity.mV[VZ] *= -0.75f;
  356. }
  357. }
  360. // Reset the offset from the source position
  361. if (part->mFlags & LLPartData::LL_PART_FOLLOW_SRC_MASK)
  362. {
  363. part->mPosOffset = part->mPosAgent;
  364. part->mPosOffset -= part->mPartSourcep->mPosAgent;
  365. }
  367. // Do color interpolation
  368. if (part->mFlags & LLPartData::LL_PART_INTERP_COLOR_MASK)
  369. {
  370. part->mColor.setVec(part->mStartColor);
  371. // note: LLColor4's v%k means multiply-alpha-only,
  372. //       LLColor4's v*k means multiply-rgb-only
  373. part->mColor *= 1.f - frac; // rgb*k
  374. part->mColor %= 1.f - frac; // alpha*k
  375. part->mColor += frac%(frac*part->mEndColor); // rgb,alpha
  376. }
  378. // Do scale interpolation
  379. if (part->mFlags & LLPartData::LL_PART_INTERP_SCALE_MASK)
  380. {
  381. part->mScale.setVec(part->mStartScale);
  382. part->mScale *= 1.f - frac;
  383. part->mScale += frac*part->mEndScale;
  384. }
  386. // Set the last update time to now.
  387. part->mLastUpdateTime = cur_time;
  390. // Kill dead particles (either flagged dead, or too old)
  391. if ((part->mLastUpdateTime > part->mMaxAge) || (LLViewerPart::LL_PART_DEAD_MASK == part->mFlags))
  392. {
  393. mParticles[i] = mParticles.back() ;
  394. mParticles.pop_back() ;
  395. delete part ;
  396. }
  397. else 
  398. {
  399. F32 desired_size = calc_desired_size(camera, part->mPosAgent, part->mScale);
  400. if (!posInGroup(part->mPosAgent, desired_size))
  401. {
  402. // Transfer particles between groups
  403. LLViewerPartSim::getInstance()->put(part) ;
  404. mParticles[i] = mParticles.back() ;
  405. mParticles.pop_back() ;
  406. }
  407. else
  408. {
  409. i++ ;
  410. }
  411. }
  412. }
  414. S32 removed = end - (S32)mParticles.size();
  415. if (removed > 0)
  416. {
  417. // we removed one or more particles, so flag this group for update
  418. if (mVOPartGroupp.notNull())
  419. {
  420. gPipeline.markRebuild(mVOPartGroupp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  421. }
  422. LLViewerPartSim::decPartCount(removed);
  423. }
  425. // Kill the viewer object if this particle group is empty
  426. if (mParticles.empty())
  427. {
  428. gObjectList.killObject(mVOPartGroupp);
  429. mVOPartGroupp = NULL;
  430. }
  432. LLViewerPartSim::checkParticleCount() ;
  433. }
  436. void LLViewerPartGroup::shift(const LLVector3 &offset)
  437. {
  438. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  439. mCenterAgent += offset;
  440. mMinObjPos += offset;
  441. mMaxObjPos += offset;
  443. for (S32 i = 0 ; i < (S32)mParticles.size(); i++)
  444. {
  445. mParticles[i]->mPosAgent += offset;
  446. }
  447. }
  449. void LLViewerPartGroup::removeParticlesByID(const U32 source_id)
  450. {
  451. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  453. for (S32 i = 0; i < (S32)mParticles.size(); i++)
  454. {
  455. if(mParticles[i]->mPartSourcep->getID() == source_id)
  456. {
  457. mParticles[i]->mFlags = LLViewerPart::LL_PART_DEAD_MASK;
  458. }
  459. }
  460. }
  462. //////////////////////////////////
  463. //
  464. // LLViewerPartSim implementation
  465. //
  466. //
  468. //static
  469. void LLViewerPartSim::checkParticleCount(U32 size)
  470. {
  471. if(LLViewerPartSim::sParticleCount2 != LLViewerPartSim::sParticleCount)
  472. {
  473. llerrs << "sParticleCount: " << LLViewerPartSim::sParticleCount << " ; sParticleCount2: " << LLViewerPartSim::sParticleCount2 << llendl ;
  474. }
  476. if(size > (U32)LLViewerPartSim::sParticleCount2)
  477. {
  478. llerrs << "curren particle size: " << LLViewerPartSim::sParticleCount2 << " array size: " << size << llendl ;
  479. }
  480. }
  482. LLViewerPartSim::LLViewerPartSim()
  483. {
  484. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  485. sMaxParticleCount = gSavedSettings.getS32("RenderMaxPartCount");
  486. static U32 id_seed = 0;
  487. mID = ++id_seed;
  488. }
  491. void LLViewerPartSim::destroyClass()
  492. {
  493. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  494. S32 i;
  495. S32 count;
  497. // Kill all of the groups (and particles)
  498. count = (S32) mViewerPartGroups.size();
  499. for (i = 0; i < count; i++)
  500. {
  501. delete mViewerPartGroups[i];
  502. }
  503. mViewerPartGroups.clear();
  505. // Kill all of the sources 
  506. mViewerPartSources.clear();
  507. }
  509. BOOL LLViewerPartSim::shouldAddPart()
  510. {
  511. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  512. if (sParticleCount > PART_THROTTLE_THRESHOLD*sMaxParticleCount)
  513. {
  515. F32 frac = (F32)sParticleCount/(F32)sMaxParticleCount;
  516. frac -= PART_THROTTLE_THRESHOLD;
  517. frac *= PART_THROTTLE_RESCALE;
  518. if (ll_frand() < frac)
  519. {
  520. // Skip...
  521. return FALSE;
  522. }
  523. }
  524. if (sParticleCount >= MAX_PART_COUNT)
  525. {
  526. return FALSE;
  527. }
  529. return TRUE;
  530. }
  532. void LLViewerPartSim::addPart(LLViewerPart* part)
  533. {
  534. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  535. if (sParticleCount < MAX_PART_COUNT)
  536. {
  537. put(part);
  538. }
  539. else
  540. {
  541. //delete the particle if can not add it in
  542. delete part ;
  543. part = NULL ;
  544. }
  545. }
  548. LLViewerPartGroup *LLViewerPartSim::put(LLViewerPart* part)
  549. {
  550. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  551. const F32 MAX_MAG = 1000000.f*1000000.f; // 1 million
  552. LLViewerPartGroup *return_group = NULL ;
  553. if (part->mPosAgent.magVecSquared() > MAX_MAG || !part->mPosAgent.isFinite())
  554. {
  555. #if 0 && !LL_RELEASE_FOR_DOWNLOAD
  556. llwarns << "LLViewerPartSim::put Part out of range!" << llendl;
  557. llwarns << part->mPosAgent << llendl;
  558. #endif
  559. }
  560. else
  561. {
  562. LLViewerCamera* camera = LLViewerCamera::getInstance();
  563. F32 desired_size = calc_desired_size(camera, part->mPosAgent, part->mScale);
  565. S32 count = (S32) mViewerPartGroups.size();
  566. for (S32 i = 0; i < count; i++)
  567. {
  568. if (mViewerPartGroups[i]->addPart(part, desired_size))
  569. {
  570. // We found a spatial group that we fit into, add us and exit
  571. return_group = mViewerPartGroups[i];
  572. break ;
  573. }
  574. }
  576. // Hmm, we didn't fit in any of the existing spatial groups
  577. // Create a new one...
  578. if(!return_group)
  579. {
  580. llassert_always(part->mPosAgent.isFinite());
  581. LLViewerPartGroup *groupp = createViewerPartGroup(part->mPosAgent, desired_size, part->mFlags & LLPartData::LL_PART_HUD);
  582. groupp->mUniformParticles = (part->mScale.mV[0] == part->mScale.mV[1] && 
  583. !(part->mFlags & LLPartData::LL_PART_FOLLOW_VELOCITY_MASK));
  584. if (!groupp->addPart(part))
  585. {
  586. llwarns << "LLViewerPartSim::put - Particle didn't go into its box!" << llendl;
  587. llinfos << groupp->getCenterAgent() << llendl;
  588. llinfos << part->mPosAgent << llendl;
  589. mViewerPartGroups.pop_back() ;
  590. delete groupp;
  591. groupp = NULL ;
  592. }
  593. return_group = groupp;
  594. }
  595. }
  597. if(!return_group) //failed to insert the particle
  598. {
  599. delete part ;
  600. part = NULL ;
  601. }
  603. return return_group ;
  604. }
  606. LLViewerPartGroup *LLViewerPartSim::createViewerPartGroup(const LLVector3 &pos_agent, const F32 desired_size, bool hud)
  607. {
  608. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  609. //find a box that has a center position divisible by PART_SIM_BOX_SIDE that encompasses
  610. //pos_agent
  611. LLViewerPartGroup *groupp = new LLViewerPartGroup(pos_agent, desired_size, hud);
  612. mViewerPartGroups.push_back(groupp);
  613. return groupp;
  614. }
  617. void LLViewerPartSim::shift(const LLVector3 &offset)
  618. {
  619. S32 i;
  620. S32 count;
  622. count = (S32) mViewerPartSources.size();
  623. for (i = 0; i < count; i++)
  624. {
  625. mViewerPartSources[i]->mPosAgent += offset;
  626. mViewerPartSources[i]->mTargetPosAgent += offset;
  627. mViewerPartSources[i]->mLastUpdatePosAgent += offset;
  628. }
  630. count = (S32) mViewerPartGroups.size();
  631. for (i = 0; i < count; i++)
  632. {
  633. mViewerPartGroups[i]->shift(offset);
  634. }
  635. }
  637. static LLFastTimer::DeclareTimer FTM_SIMULATE_PARTICLES("Simulate Particles");
  639. void LLViewerPartSim::updateSimulation()
  640. {
  641. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  643. static LLFrameTimer update_timer;
  645. const F32 dt = llmin(update_timer.getElapsedTimeAndResetF32(), 0.1f);
  647.   if (!(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_PARTICLES)))
  648. {
  649. return;
  650. }
  652. LLFastTimer ftm(FTM_SIMULATE_PARTICLES);
  654. // Start at a random particle system so the same
  655. // particle system doesn't always get first pick at the
  656. // particles.  Theoretically we'd want to do this in distance
  657. // order or something, but sorting particle sources will be a big
  658. // pain.
  659. S32 i;
  660. S32 count = (S32) mViewerPartSources.size();
  661. S32 start = (S32)ll_frand((F32)count);
  662. S32 dir = 1;
  663. S32 deldir = 0;
  664. if (ll_frand() > 0.5f)
  665. {
  666. dir = -1;
  667. deldir = -1;
  668. }
  670. S32 num_updates = 0;
  671. for (i = start; num_updates < count;)
  672. {
  673. if (i >= count)
  674. {
  675. i = 0;
  676. }
  677. if (i < 0)
  678. {
  679. i = count - 1;
  680. }
  682. if (!mViewerPartSources[i]->isDead())
  683. {
  684. BOOL upd = TRUE;
  685. if (!LLPipeline::sRenderAttachedParticles)
  686. {
  687. LLViewerObject* vobj = mViewerPartSources[i]->mSourceObjectp;
  688. if (vobj && (vobj->getPCode() == LL_PCODE_VOLUME))
  689. {
  690. LLVOVolume* vvo = (LLVOVolume *)vobj;
  691. if (vvo && vvo->isAttachment())
  692. {
  693. upd = FALSE;
  694. }
  695. }
  696. }
  698. if (upd) 
  699. {
  700. mViewerPartSources[i]->update(dt);
  701. }
  702. }
  704. if (mViewerPartSources[i]->isDead())
  705. {
  706. mViewerPartSources.erase(mViewerPartSources.begin() + i);
  707. count--;
  708. i+=deldir;
  709. }
  710. else
  711.         {
  712.  i += dir;
  713.         }
  714. num_updates++;
  715. }
  717. count = (S32) mViewerPartGroups.size();
  718. for (i = 0; i < count; i++)
  719. {
  720. LLViewerObject* vobj = mViewerPartGroups[i]->mVOPartGroupp;
  722. S32 visirate = 1;
  723. if (vobj)
  724. {
  725. LLSpatialGroup* group = vobj->mDrawable->getSpatialGroup();
  726. if (group && !group->isVisible()) // && !group->isState(LLSpatialGroup::OBJECT_DIRTY))
  727. {
  728. visirate = 8;
  729. }
  730. }
  732. if ((LLDrawable::getCurrentFrame()+mViewerPartGroups[i]->mID)%visirate == 0)
  733. {
  734. if (vobj)
  735. {
  736. gPipeline.markRebuild(vobj->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  737. }
  738. mViewerPartGroups[i]->updateParticles(dt * visirate);
  739. mViewerPartGroups[i]->mSkippedTime=0.0f;
  740. if (!mViewerPartGroups[i]->getCount())
  741. {
  742. delete mViewerPartGroups[i];
  743. mViewerPartGroups.erase(mViewerPartGroups.begin() + i);
  744. i--;
  745. count--;
  746. }
  747. }
  748. else
  749. {
  750. mViewerPartGroups[i]->mSkippedTime+=dt;
  751. }
  753. }
  754. if (LLDrawable::getCurrentFrame()%16==0)
  755. {
  756. if (sParticleCount > sMaxParticleCount * 0.875f
  757.     && sParticleAdaptiveRate < 2.0f)
  758. {
  759. sParticleAdaptiveRate *= PART_ADAPT_RATE_MULT;
  760. }
  761. else
  762. {
  763. if (sParticleCount < sMaxParticleCount * 0.5f
  764.     && sParticleAdaptiveRate > 0.03125f)
  765. {
  766. sParticleAdaptiveRate *= PART_ADAPT_RATE_MULT_RECIP;
  767. }
  768. }
  769. }
  771. updatePartBurstRate() ;
  773. //llinfos << "Particles: " << sParticleCount << " Adaptive Rate: " << sParticleAdaptiveRate << llendl;
  774. }
  776. void LLViewerPartSim::updatePartBurstRate()
  777. {
  778. if (!(LLDrawable::getCurrentFrame() & 0xf))
  779. {
  780. if (sParticleCount >= MAX_PART_COUNT) //set rate to zero
  781. {
  782. sParticleBurstRate = 0.0f ;
  783. }
  784. else if(sParticleCount > 0)
  785. {
  786. if(sParticleBurstRate > 0.0000001f)
  787. {
  788. F32 total_particles = sParticleCount / sParticleBurstRate ; //estimated
  789. F32 new_rate = llclamp(0.9f * sMaxParticleCount / total_particles, 0.0f, 1.0f) ;
  790. F32 delta_rate_threshold = llmin(0.1f * llmax(new_rate, sParticleBurstRate), 0.1f) ;
  791. F32 delta_rate = llclamp(new_rate - sParticleBurstRate, -1.0f * delta_rate_threshold, delta_rate_threshold) ;
  793. sParticleBurstRate = llclamp(sParticleBurstRate + 0.5f * delta_rate, 0.0f, 1.0f) ;
  794. }
  795. else
  796. {
  797. sParticleBurstRate += 0.0000001f ;
  798. }
  799. }
  800. else
  801. {
  802. sParticleBurstRate += 0.00125f ;
  803. }
  804. }
  805. }
  807. void LLViewerPartSim::addPartSource(LLPointer<LLViewerPartSource> sourcep)
  808. {
  809. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  810. if (!sourcep)
  811. {
  812. llwarns << "Null part source!" << llendl;
  813. return;
  814. }
  815. sourcep->setStart() ;
  816. mViewerPartSources.push_back(sourcep);
  817. }
  819. void LLViewerPartSim::removeLastCreatedSource()
  820. {
  821. mViewerPartSources.pop_back();
  822. }
  824. void LLViewerPartSim::cleanupRegion(LLViewerRegion *regionp)
  825. {
  826. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  827. for (group_list_t::iterator i = mViewerPartGroups.begin(); i != mViewerPartGroups.end(); )
  828. {
  829. group_list_t::iterator iter = i++;
  831. if ((*iter)->getRegion() == regionp)
  832. {
  833. delete *iter;
  834. i = mViewerPartGroups.erase(iter);
  835. }
  836. }
  837. }
  839. void LLViewerPartSim::clearParticlesByID(const U32 system_id)
  840. {
  841. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  842. for (group_list_t::iterator g = mViewerPartGroups.begin(); g != mViewerPartGroups.end(); ++g)
  843. {
  844. (*g)->removeParticlesByID(system_id);
  845. }
  846. for (source_list_t::iterator i = mViewerPartSources.begin(); i != mViewerPartSources.end(); ++i)
  847. {
  848. if ((*i)->getID() == system_id)
  849. {
  850. (*i)->setDead();
  851. break;
  852. }
  853. }
  855. }
  857. void LLViewerPartSim::clearParticlesByOwnerID(const LLUUID& task_id)
  858. {
  859. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  860. for (source_list_t::iterator iter = mViewerPartSources.begin(); iter != mViewerPartSources.end(); ++iter)
  861. {
  862. if ((*iter)->getOwnerUUID() == task_id)
  863. {
  864. clearParticlesByID((*iter)->getID());
  865. }
  866. }
  867. }