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

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

游戏引擎

开发平台：

C++ Builder

llviewerpartsource.cpp：源码内容
  1. /** 
  2.  * @file llviewerpartsource.cpp
  3.  * @brief LLViewerPartSource 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"
  34. #include "llviewerpartsource.h"
  36. #include "llviewercontrol.h"
  37. #include "llrender.h"
  39. #include "llagent.h"
  40. #include "lldrawable.h"
  41. #include "llviewercamera.h"
  42. #include "llviewertexturelist.h"
  43. #include "llviewerobject.h"
  44. #include "llviewerobjectlist.h"
  45. #include "llvoavatar.h"
  46. #include "llworld.h"
  47. #include "pipeline.h"
  49. LLViewerPartSource::LLViewerPartSource(const U32 type) :
  50. mType(type),
  51. mOwnerUUID(LLUUID::null),
  52. mPartFlags(0)
  53. {
  54. mLastUpdateTime = 0.f;
  55. mLastPartTime = 0.f;
  56. mIsDead = FALSE;
  57. mIsSuspended = FALSE;
  58. static U32 id_seed = 0;
  59. mID = ++id_seed;
  61. mDelay = 0 ;
  62. }
  64. void LLViewerPartSource::setDead()
  65. {
  66. mIsDead = TRUE;
  67. }
  70. void LLViewerPartSource::updatePart(LLViewerPart &part, const F32 dt)
  71. {
  72. }
  74. void LLViewerPartSource::update(const F32 dt) 
  75. {
  76. llerrs << "Creating default part source!" << llendl;
  77. }
  79. LLUUID LLViewerPartSource::getImageUUID() const
  80. {
  81. LLViewerTexture* imagep = mImagep;
  82. if(imagep)
  83. {
  84. return imagep->getID();
  85. }
  86. return LLUUID::null;
  87. }
  88. void LLViewerPartSource::setStart()
  89. {
  90. //cancel delaying to start a new added particle source, because some particle source just emits for a short time.
  91. //however, canceling this might cause overall particle emmitting fluctuate for a while because the new added source jumps to 
  92. //the current particle emmitting settings instantly. -->bao
  93. mDelay = 0 ; //99
  94. }
  96. LLViewerPartSourceScript::LLViewerPartSourceScript(LLViewerObject *source_objp) :
  97. LLViewerPartSource(LL_PART_SOURCE_SCRIPT)
  98. {
  99. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  100. llassert(source_objp);
  101. mSourceObjectp = source_objp;
  102. mPosAgent = mSourceObjectp->getPositionAgent();
  103. mImagep = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  105. mImagep->setAddressMode(LLTexUnit::TAM_CLAMP);
  106. }
  109. void LLViewerPartSourceScript::setDead()
  110. {
  111. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  112. mIsDead = TRUE;
  113. mSourceObjectp = NULL;
  114. mTargetObjectp = NULL;
  115. }
  117. void LLViewerPartSourceScript::update(const F32 dt)
  118. {
  119. if( mIsSuspended )
  120. return;
  122. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  123. F32 old_update_time = mLastUpdateTime;
  124. mLastUpdateTime += dt;
  126. F32 ref_rate_travelspeed = llmin(LLViewerPartSim::getInstance()->getRefRate(), 1.f);
  128. F32 dt_update = mLastUpdateTime - mLastPartTime;
  130. // Update this for objects which have the follow flag set...
  131. if (!mSourceObjectp.isNull())
  132. {
  133. if (mSourceObjectp->isDead())
  134. {
  135. mSourceObjectp = NULL;
  136. }
  137. else if (mSourceObjectp->mDrawable.notNull())
  138. {
  139. mPosAgent = mSourceObjectp->getRenderPosition();
  140. }
  141. }
  143. if (mTargetObjectp.isNull() 
  144. && mPartSysData.mTargetUUID.notNull())
  145. {
  146. //
  147. // Hmm, missing object, let's see if we can find it...
  148. //
  150. LLViewerObject *target_objp = gObjectList.findObject(mPartSysData.mTargetUUID);
  151. setTargetObject(target_objp);
  152. }
  154. if (!mTargetObjectp.isNull())
  155. {
  156. if (mTargetObjectp->isDead())
  157. {
  158. mTargetObjectp = NULL;
  159. }
  160. else if (mTargetObjectp->mDrawable.notNull())
  161. {
  162. mTargetPosAgent = mTargetObjectp->getRenderPosition();
  163. }
  164. }
  166. if (!mTargetObjectp)
  167. {
  168. mTargetPosAgent = mPosAgent;
  169. }
  171. if (mPartSysData.mMaxAge && ((mPartSysData.mStartAge + mLastUpdateTime + dt_update) > mPartSysData.mMaxAge))
  172. {
  173. // Kill particle source because it has outlived its max age...
  174. setDead();
  175. return;
  176. }
  179. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_PARTICLES))
  180. {
  181. if (mSourceObjectp.notNull())
  182. {
  183. std::ostringstream ostr;
  184. ostr << mPartSysData;
  185. mSourceObjectp->setDebugText(ostr.str());
  186. }
  187. }
  189. BOOL first_run = FALSE;
  190. if (old_update_time <= 0.f)
  191. {
  192. first_run = TRUE;
  193. }
  195. F32 max_time = llmax(1.f, 10.f*mPartSysData.mBurstRate);
  196. dt_update = llmin(max_time, dt_update);
  197. while ((dt_update > mPartSysData.mBurstRate) || first_run)
  198. {
  199. first_run = FALSE;
  201. // Update the rotation of the particle source by the angular velocity
  202. // First check to see if there is still an angular velocity.
  203. F32 angular_velocity_mag = mPartSysData.mAngularVelocity.magVec();
  204. if (angular_velocity_mag != 0.0f)
  205. {
  206. F32 av_angle = dt * angular_velocity_mag;
  207. LLQuaternion dquat(av_angle, mPartSysData.mAngularVelocity);
  208. mRotation *= dquat;
  209. }
  210. else
  211. {
  212. // No angular velocity.  Reset our rotation.
  213. mRotation.setQuat(0, 0, 0);
  214. }
  216. if (LLViewerPartSim::getInstance()->aboveParticleLimit())
  217. {
  218. // Don't bother doing any more updates if we're above the particle limit,
  219. // just give up.
  220. mLastPartTime = mLastUpdateTime;
  221.             break;
  223. }
  225. // find the greatest length that the shortest side of a system
  226. // particle is expected to have
  227. F32 max_short_side =
  228. llmax(
  229.       llmax(llmin(mPartSysData.mPartData.mStartScale[0],
  230.   mPartSysData.mPartData.mStartScale[1]),
  231.     llmin(mPartSysData.mPartData.mEndScale[0],
  232.   mPartSysData.mPartData.mEndScale[1])),
  233.       llmin((mPartSysData.mPartData.mStartScale[0]
  234.      + mPartSysData.mPartData.mEndScale[0])/2,
  235.     (mPartSysData.mPartData.mStartScale[1]
  236.      + mPartSysData.mPartData.mEndScale[1])/2));
  238. F32 pixel_meter_ratio = LLViewerCamera::getInstance()->getPixelMeterRatio();
  240. // Maximum distance at which spawned particles will be viewable
  241. F32 max_dist = max_short_side * pixel_meter_ratio; 
  243. if (max_dist < 0.25f)
  244. {
  245. // < 1 pixel wide at a distance of >=25cm.  Particles
  246. // this tiny are useless and mostly spawned by buggy
  247. // sources
  248. mLastPartTime = mLastUpdateTime;
  249. break;
  250. }
  252. // Distance from camera
  253. F32 dist = (mPosAgent - LLViewerCamera::getInstance()->getOrigin()).magVec();
  255. // Particle size vs distance vs maxage throttling
  257. F32 limited_rate=0.f;
  258. if (dist - max_dist > 0.f)
  259. {
  260. if((dist - max_dist) * ref_rate_travelspeed > mPartSysData.mPartData.mMaxAge - 0.2f )
  261. {
  262. // You need to travel faster than 1 divided by reference rate m/s directly towards these particles to see them at least 0.2s
  263. mLastPartTime = mLastUpdateTime;
  264. break;
  265. }
  266. limited_rate = ((dist - max_dist) * ref_rate_travelspeed) / mPartSysData.mPartData.mMaxAge;
  267. }
  269. if(mDelay)
  270. {
  271. limited_rate = llmax(limited_rate, 0.01f * mDelay--) ;
  272. }
  274. S32 i;
  275. for (i = 0; i < mPartSysData.mBurstPartCount; i++)
  276. {
  277. if (ll_frand() < llmax(1.0f - LLViewerPartSim::getInstance()->getBurstRate(), limited_rate))
  278. {
  279. // Limit particle generation
  280. continue;
  281. }
  283. LLViewerPart* part = new LLViewerPart();
  285. part->init(this, mImagep, NULL);
  286. part->mFlags = mPartSysData.mPartData.mFlags;
  287. if (!mSourceObjectp.isNull() && mSourceObjectp->isHUDAttachment())
  288. {
  289. part->mFlags |= LLPartData::LL_PART_HUD;
  290. }
  291. part->mMaxAge = mPartSysData.mPartData.mMaxAge;
  292. part->mStartColor = mPartSysData.mPartData.mStartColor;
  293. part->mEndColor = mPartSysData.mPartData.mEndColor;
  294. part->mColor = part->mStartColor;
  296. part->mStartScale = mPartSysData.mPartData.mStartScale;
  297. part->mEndScale = mPartSysData.mPartData.mEndScale;
  298. part->mScale = part->mStartScale;
  300. part->mAccel = mPartSysData.mPartAccel;
  302. if (mPartSysData.mPattern & LLPartSysData::LL_PART_SRC_PATTERN_DROP)
  303. {
  304. part->mPosAgent = mPosAgent;
  305. part->mVelocity.setVec(0.f, 0.f, 0.f);
  306. }
  307. else if (mPartSysData.mPattern & LLPartSysData::LL_PART_SRC_PATTERN_EXPLODE)
  308. {
  309. part->mPosAgent = mPosAgent;
  310. LLVector3 part_dir_vector;
  312. F32 mvs;
  313. do
  314. {
  315. part_dir_vector.mV[VX] = ll_frand(2.f) - 1.f;
  316. part_dir_vector.mV[VY] = ll_frand(2.f) - 1.f;
  317. part_dir_vector.mV[VZ] = ll_frand(2.f) - 1.f;
  318. mvs = part_dir_vector.magVecSquared();
  319. }
  320. while ((mvs > 1.f) || (mvs < 0.01f));
  322. part_dir_vector.normVec();
  323. part->mPosAgent += mPartSysData.mBurstRadius*part_dir_vector;
  324. part->mVelocity = part_dir_vector;
  325. F32 speed = mPartSysData.mBurstSpeedMin + ll_frand(mPartSysData.mBurstSpeedMax - mPartSysData.mBurstSpeedMin);
  326. part->mVelocity *= speed;
  327. }
  328. else if (mPartSysData.mPattern & LLPartSysData::LL_PART_SRC_PATTERN_ANGLE
  329. || mPartSysData.mPattern & LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE)
  330. {
  331. part->mPosAgent = mPosAgent;
  333. // original implemenetation for part_dir_vector was just:
  334. LLVector3 part_dir_vector(0.0, 0.0, 1.0);
  335. // params from the script...
  336. // outer = outer cone angle
  337. // inner = inner cone angle
  338. // between outer and inner there will be particles
  339. F32 innerAngle = mPartSysData.mInnerAngle;
  340. F32 outerAngle = mPartSysData.mOuterAngle;
  342. // generate a random angle within the given space...
  343. F32 angle = innerAngle + ll_frand(outerAngle - innerAngle);
  344. // split which side it will go on randomly...
  345. if (ll_frand() < 0.5) 
  346. {
  347. angle = -angle;
  348. }
  349. // Both patterns rotate around the x-axis first:
  350. part_dir_vector.rotVec(angle, 1.0, 0.0, 0.0);
  352. // If this is a cone pattern, rotate again to create the cone.
  353. if (mPartSysData.mPattern & LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE)
  354. {
  355. part_dir_vector.rotVec(ll_frand(4*F_PI), 0.0, 0.0, 1.0);
  356. }
  358. // Only apply this rotation if using the deprecated angles. 
  359. if (! (mPartSysData.mFlags & LLPartSysData::LL_PART_USE_NEW_ANGLE))
  360. {
  361. // Deprecated...
  362. part_dir_vector.rotVec(outerAngle, 1.0, 0.0, 0.0);
  363. }
  365. if (mSourceObjectp)
  366. {
  367. part_dir_vector = part_dir_vector * mSourceObjectp->getRenderRotation();
  368. }
  370. part_dir_vector = part_dir_vector * mRotation;
  372. part->mPosAgent += mPartSysData.mBurstRadius*part_dir_vector;
  374. part->mVelocity = part_dir_vector;
  376. F32 speed = mPartSysData.mBurstSpeedMin + ll_frand(mPartSysData.mBurstSpeedMax - mPartSysData.mBurstSpeedMin);
  377. part->mVelocity *= speed;
  378. }
  379. else
  380. {
  381. part->mPosAgent = mPosAgent;
  382. part->mVelocity.setVec(0.f, 0.f, 0.f);
  383. //llwarns << "Unknown source pattern " << (S32)mPartSysData.mPattern << llendl;
  384. }
  386. if (part->mFlags & LLPartData::LL_PART_FOLLOW_SRC_MASK || // SVC-193, VWR-717
  387. part->mFlags & LLPartData::LL_PART_TARGET_LINEAR_MASK) 
  388. {
  389. mPartSysData.mBurstRadius = 0; 
  390. }
  392. LLViewerPartSim::getInstance()->addPart(part);
  393. }
  395. mLastPartTime = mLastUpdateTime;
  396. dt_update -= mPartSysData.mBurstRate;
  397. }
  398. }
  400. // static
  401. LLPointer<LLViewerPartSourceScript> LLViewerPartSourceScript::unpackPSS(LLViewerObject *source_objp, LLPointer<LLViewerPartSourceScript> pssp, const S32 block_num)
  402. {
  403. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  404. if (!pssp)
  405. {
  406. if (LLPartSysData::isNullPS(block_num))
  407. {
  408. return NULL;
  409. }
  410. LLPointer<LLViewerPartSourceScript> new_pssp = new LLViewerPartSourceScript(source_objp);
  411. if (!new_pssp->mPartSysData.unpackBlock(block_num))
  412. {
  413. return NULL;
  414. }
  415. if (new_pssp->mPartSysData.mTargetUUID.notNull())
  416. {
  417. LLViewerObject *target_objp = gObjectList.findObject(new_pssp->mPartSysData.mTargetUUID);
  418. new_pssp->setTargetObject(target_objp);
  419. }
  420. return new_pssp;
  421. }
  422. else
  423. {
  424. if (LLPartSysData::isNullPS(block_num))
  425. {
  426. return NULL;
  427. }
  429. if (!pssp->mPartSysData.unpackBlock(block_num))
  430. {
  431. return NULL;
  432. }
  433. if (pssp->mPartSysData.mTargetUUID.notNull())
  434. {
  435. LLViewerObject *target_objp = gObjectList.findObject(pssp->mPartSysData.mTargetUUID);
  436. pssp->setTargetObject(target_objp);
  437. }
  438. return pssp;
  439. }
  440. }
  443. LLPointer<LLViewerPartSourceScript> LLViewerPartSourceScript::unpackPSS(LLViewerObject *source_objp, LLPointer<LLViewerPartSourceScript> pssp, LLDataPacker &dp)
  444. {
  445. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  446. if (!pssp)
  447. {
  448. LLPointer<LLViewerPartSourceScript> new_pssp = new LLViewerPartSourceScript(source_objp);
  449. if (!new_pssp->mPartSysData.unpack(dp))
  450. {
  451. return NULL;
  452. }
  453. if (new_pssp->mPartSysData.mTargetUUID.notNull())
  454. {
  455. LLViewerObject *target_objp = gObjectList.findObject(new_pssp->mPartSysData.mTargetUUID);
  456. new_pssp->setTargetObject(target_objp);
  457. }
  458. return new_pssp;
  459. }
  460. else
  461. {
  462. if (!pssp->mPartSysData.unpack(dp))
  463. {
  464. return NULL;
  465. }
  466. if (pssp->mPartSysData.mTargetUUID.notNull())
  467. {
  468. LLViewerObject *target_objp = gObjectList.findObject(pssp->mPartSysData.mTargetUUID);
  469. pssp->setTargetObject(target_objp);
  470. }
  471. return pssp;
  472. }
  473. }
  476. /* static */
  477. LLPointer<LLViewerPartSourceScript> LLViewerPartSourceScript::createPSS(LLViewerObject *source_objp, const LLPartSysData& particle_parameters)
  478. {
  479. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  481. LLPointer<LLViewerPartSourceScript> new_pssp = new LLViewerPartSourceScript(source_objp);
  483. new_pssp->mPartSysData = particle_parameters;
  485. if (new_pssp->mPartSysData.mTargetUUID.notNull())
  486. {
  487. LLViewerObject *target_objp = gObjectList.findObject(new_pssp->mPartSysData.mTargetUUID);
  488. new_pssp->setTargetObject(target_objp);
  489. }
  490. return new_pssp;
  491. }
  494. void LLViewerPartSourceScript::setImage(LLViewerTexture *imagep)
  495. {
  496. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  497. mImagep = imagep;
  498. }
  500. void LLViewerPartSourceScript::setTargetObject(LLViewerObject *objp)
  501. {
  502. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  503. mTargetObjectp = objp;
  504. }
  510. LLViewerPartSourceSpiral::LLViewerPartSourceSpiral(const LLVector3 &pos) :
  511. LLViewerPartSource(LL_PART_SOURCE_CHAT)
  512. {
  513. mPosAgent = pos;
  514. }
  516. void LLViewerPartSourceSpiral::setDead()
  517. {
  518. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  519. mIsDead = TRUE;
  520. mSourceObjectp = NULL;
  521. }
  524. void LLViewerPartSourceSpiral::updatePart(LLViewerPart &part, const F32 dt)
  525. {
  526. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  527. F32 frac = part.mLastUpdateTime/part.mMaxAge;
  529. LLVector3 center_pos;
  530. LLPointer<LLViewerPartSource>& ps = part.mPartSourcep;
  531. LLViewerPartSourceSpiral *pss = (LLViewerPartSourceSpiral *)ps.get();
  532. if (!pss->mSourceObjectp.isNull() && !pss->mSourceObjectp->mDrawable.isNull())
  533. {
  534. part.mPosAgent = pss->mSourceObjectp->getRenderPosition();
  535. }
  536. else
  537. {
  538. part.mPosAgent = pss->mPosAgent;
  539. }
  540. F32 x = sin(F_TWO_PI*frac + part.mParameter);
  541. F32 y = cos(F_TWO_PI*frac + part.mParameter);
  543. part.mPosAgent.mV[VX] += x;
  544. part.mPosAgent.mV[VY] += y;
  545. part.mPosAgent.mV[VZ] += -0.5f + frac;
  546. }
  549. void LLViewerPartSourceSpiral::update(const F32 dt)
  550. {
  551. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  552. if (!mImagep)
  553. {
  554. mImagep = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  555. }
  557. const F32 RATE = 0.025f;
  559. mLastUpdateTime += dt;
  561. F32 dt_update = mLastUpdateTime - mLastPartTime;
  562. F32 max_time = llmax(1.f, 10.f*RATE);
  563. dt_update = llmin(max_time, dt_update);
  565. if (dt_update > RATE)
  566. {
  567. mLastPartTime = mLastUpdateTime;
  568. if (!LLViewerPartSim::getInstance()->shouldAddPart())
  569. {
  570. // Particle simulation says we have too many particles, skip all this
  571. return;
  572. }
  574. if (!mSourceObjectp.isNull() && !mSourceObjectp->mDrawable.isNull())
  575. {
  576. mPosAgent = mSourceObjectp->getRenderPosition();
  577. }
  578. LLViewerPart* part = new LLViewerPart();
  579. part->init(this, mImagep, updatePart);
  580. part->mStartColor = mColor;
  581. part->mEndColor = mColor;
  582. part->mEndColor.mV[3] = 0.f;
  583. part->mPosAgent = mPosAgent;
  584. part->mMaxAge = 1.f;
  585. part->mFlags = LLViewerPart::LL_PART_INTERP_COLOR_MASK;
  586. part->mLastUpdateTime = 0.f;
  587. part->mScale.mV[0] = 0.25f;
  588. part->mScale.mV[1] = 0.25f;
  589. part->mParameter = ll_frand(F_TWO_PI);
  591. LLViewerPartSim::getInstance()->addPart(part);
  592. }
  593. }
  595. void LLViewerPartSourceSpiral::setSourceObject(LLViewerObject *objp)
  596. {
  597. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  598. mSourceObjectp = objp;
  599. }
  601. void LLViewerPartSourceSpiral::setColor(const LLColor4 &color)
  602. {
  603. mColor = color;
  604. }
  610. LLViewerPartSourceBeam::LLViewerPartSourceBeam() :
  611. LLViewerPartSource(LL_PART_SOURCE_BEAM)
  612. {
  613. }
  615. LLViewerPartSourceBeam::~LLViewerPartSourceBeam()
  616. {
  617. }
  619. void LLViewerPartSourceBeam::setDead()
  620. {
  621. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  622. mIsDead = TRUE;
  623. mSourceObjectp = NULL;
  624. mTargetObjectp = NULL;
  625. }
  627. void LLViewerPartSourceBeam::setColor(const LLColor4 &color)
  628. {
  629. mColor = color;
  630. }
  633. void LLViewerPartSourceBeam::updatePart(LLViewerPart &part, const F32 dt)
  634. {
  635. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  636. F32 frac = part.mLastUpdateTime/part.mMaxAge;
  638. LLViewerPartSource *ps = (LLViewerPartSource*)part.mPartSourcep;
  639. LLViewerPartSourceBeam *psb = (LLViewerPartSourceBeam *)ps;
  640. if (psb->mSourceObjectp.isNull())
  641. {
  642. part.mFlags = LLPartData::LL_PART_DEAD_MASK;
  643. return;
  644. }
  646. LLVector3 source_pos_agent;
  647. LLVector3 target_pos_agent;
  648. if (!psb->mSourceObjectp.isNull() && !psb->mSourceObjectp->mDrawable.isNull())
  649. {
  650. if (psb->mSourceObjectp->isAvatar())
  651. {
  652. LLViewerObject *objp = psb->mSourceObjectp;
  653. LLVOAvatar *avp = (LLVOAvatar *)objp;
  654. source_pos_agent = avp->mWristLeftp->getWorldPosition();
  655. }
  656. else
  657. {
  658. source_pos_agent = psb->mSourceObjectp->getRenderPosition();
  659. }
  660. }
  661. if (!psb->mTargetObjectp.isNull() && !psb->mTargetObjectp->mDrawable.isNull())
  662. {
  663. target_pos_agent = psb->mTargetObjectp->getRenderPosition();
  664. }
  666. part.mPosAgent = (1.f - frac) * source_pos_agent;
  667. if (psb->mTargetObjectp.isNull())
  668. {
  669. part.mPosAgent += frac * (gAgent.getPosAgentFromGlobal(psb->mLKGTargetPosGlobal));
  670. }
  671. else
  672. {
  673. part.mPosAgent += frac * target_pos_agent;
  674. }
  675. }
  678. void LLViewerPartSourceBeam::update(const F32 dt)
  679. {
  680. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  681. const F32 RATE = 0.025f;
  683. mLastUpdateTime += dt;
  685. if (!mSourceObjectp.isNull() && !mSourceObjectp->mDrawable.isNull())
  686. {
  687. if (mSourceObjectp->isAvatar())
  688. {
  689. LLViewerObject *objp = mSourceObjectp;
  690. LLVOAvatar *avp = (LLVOAvatar *)objp;
  691. mPosAgent = avp->mWristLeftp->getWorldPosition();
  692. }
  693. else
  694. {
  695. mPosAgent = mSourceObjectp->getRenderPosition();
  696. }
  697. }
  699. if (!mTargetObjectp.isNull() && !mTargetObjectp->mDrawable.isNull())
  700. {
  701. mTargetPosAgent = mTargetObjectp->getRenderPosition();
  702. }
  703. else if (!mLKGTargetPosGlobal.isExactlyZero())
  704. {
  705. mTargetPosAgent = gAgent.getPosAgentFromGlobal(mLKGTargetPosGlobal);
  706. }
  708. F32 dt_update = mLastUpdateTime - mLastPartTime;
  709. F32 max_time = llmax(1.f, 10.f*RATE);
  710. dt_update = llmin(max_time, dt_update);
  712. if (dt_update > RATE)
  713. {
  714. mLastPartTime = mLastUpdateTime;
  715. if (!LLViewerPartSim::getInstance()->shouldAddPart())
  716. {
  717. // Particle simulation says we have too many particles, skip all this
  718. return;
  719. }
  721. if (!mImagep)
  722. {
  723. mImagep = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  724. }
  726. LLViewerPart* part = new LLViewerPart();
  727. part->init(this, mImagep, NULL);
  729. part->mFlags = LLPartData::LL_PART_INTERP_COLOR_MASK |
  730. LLPartData::LL_PART_INTERP_SCALE_MASK |
  731. LLPartData::LL_PART_TARGET_POS_MASK |
  732. LLPartData::LL_PART_FOLLOW_VELOCITY_MASK;
  733. part->mMaxAge = 0.5f;
  734. part->mStartColor = mColor;
  735. part->mEndColor = part->mStartColor;
  736. part->mEndColor.mV[3] = 0.4f;
  737. part->mColor = part->mStartColor;
  739. part->mStartScale = LLVector2(0.1f, 0.1f);
  740. part->mEndScale = LLVector2(0.1f, 0.1f);
  741. part->mScale = part->mStartScale;
  743. part->mPosAgent = mPosAgent;
  744. part->mVelocity = mTargetPosAgent - mPosAgent;
  746. LLViewerPartSim::getInstance()->addPart(part);
  747. }
  748. }
  750. void LLViewerPartSourceBeam::setSourceObject(LLViewerObject* objp)
  751. {
  752. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  753. mSourceObjectp = objp;
  754. }
  756. void LLViewerPartSourceBeam::setTargetObject(LLViewerObject* objp)
  757. {
  758. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  759. mTargetObjectp = objp;
  760. }
  765. LLViewerPartSourceChat::LLViewerPartSourceChat(const LLVector3 &pos) :
  766. LLViewerPartSource(LL_PART_SOURCE_SPIRAL)
  767. {
  768. mPosAgent = pos;
  769. }
  771. void LLViewerPartSourceChat::setDead()
  772. {
  773. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  774. mIsDead = TRUE;
  775. mSourceObjectp = NULL;
  776. }
  779. void LLViewerPartSourceChat::updatePart(LLViewerPart &part, const F32 dt)
  780. {
  781. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  782. F32 frac = part.mLastUpdateTime/part.mMaxAge;
  784. LLVector3 center_pos;
  785. LLViewerPartSource *ps = (LLViewerPartSource*)part.mPartSourcep;
  786. LLViewerPartSourceChat *pss = (LLViewerPartSourceChat *)ps;
  787. if (!pss->mSourceObjectp.isNull() && !pss->mSourceObjectp->mDrawable.isNull())
  788. {
  789. part.mPosAgent = pss->mSourceObjectp->getRenderPosition();
  790. }
  791. else
  792. {
  793. part.mPosAgent = pss->mPosAgent;
  794. }
  795. F32 x = sin(F_TWO_PI*frac + part.mParameter);
  796. F32 y = cos(F_TWO_PI*frac + part.mParameter);
  798. part.mPosAgent.mV[VX] += x;
  799. part.mPosAgent.mV[VY] += y;
  800. part.mPosAgent.mV[VZ] += -0.5f + frac;
  801. }
  804. void LLViewerPartSourceChat::update(const F32 dt)
  805. {
  806. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  807. if (!mImagep)
  808. {
  809. mImagep = LLViewerTextureManager::getFetchedTextureFromFile("pixiesmall.j2c");
  810. }
  813. const F32 RATE = 0.025f;
  815. mLastUpdateTime += dt;
  817. if (mLastUpdateTime > 2.f)
  818. {
  819. // Kill particle source because it has outlived its max age...
  820. setDead();
  821. return;
  822. }
  824. F32 dt_update = mLastUpdateTime - mLastPartTime;
  826. // Clamp us to generating at most one second's worth of particles on a frame.
  827. F32 max_time = llmax(1.f, 10.f*RATE);
  828. dt_update = llmin(max_time, dt_update);
  830. if (dt_update > RATE)
  831. {
  832. mLastPartTime = mLastUpdateTime;
  833. if (!LLViewerPartSim::getInstance()->shouldAddPart())
  834. {
  835. // Particle simulation says we have too many particles, skip all this
  836. return;
  837. }
  839. if (!mSourceObjectp.isNull() && !mSourceObjectp->mDrawable.isNull())
  840. {
  841. mPosAgent = mSourceObjectp->getRenderPosition();
  842. }
  843. LLViewerPart* part = new LLViewerPart();
  844. part->init(this, mImagep, updatePart);
  845. part->mStartColor = mColor;
  846. part->mEndColor = mColor;
  847. part->mEndColor.mV[3] = 0.f;
  848. part->mPosAgent = mPosAgent;
  849. part->mMaxAge = 1.f;
  850. part->mFlags = LLViewerPart::LL_PART_INTERP_COLOR_MASK;
  851. part->mLastUpdateTime = 0.f;
  852. part->mScale.mV[0] = 0.25f;
  853. part->mScale.mV[1] = 0.25f;
  854. part->mParameter = ll_frand(F_TWO_PI);
  856. LLViewerPartSim::getInstance()->addPart(part);
  857. }
  858. }
  860. void LLViewerPartSourceChat::setSourceObject(LLViewerObject *objp)
  861. {
  862. LLMemType mt(LLMemType::MTYPE_PARTICLES);
  863. mSourceObjectp = objp;
  864. }
  866. void LLViewerPartSourceChat::setColor(const LLColor4 &color)
  867. {
  868. mColor = color;
  869. }