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

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

游戏引擎

开发平台：

C++ Builder

lldrawable.cpp：源码内容
  1. /** 
  2.  * @file lldrawable.cpp
  3.  * @brief LLDrawable class implementation
  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 "lldrawable.h"
  37. // library includes
  38. #include "material_codes.h"
  40. // viewer includes
  41. #include "llcriticaldamp.h"
  42. #include "llface.h"
  43. #include "lllightconstants.h"
  44. #include "llsky.h"
  45. #include "llsurfacepatch.h"
  46. #include "llviewercamera.h"
  47. #include "llviewerregion.h"
  48. #include "llvolume.h"
  49. #include "llvoavatar.h"
  50. #include "llvovolume.h"
  51. #include "llvosurfacepatch.h" // for debugging
  52. #include "llworld.h"
  53. #include "pipeline.h"
  54. #include "llspatialpartition.h"
  55. #include "llviewerobjectlist.h"
  56. #include "llviewerwindow.h"
  58. const F32 MIN_INTERPOLATE_DISTANCE_SQUARED = 0.001f * 0.001f;
  59. const F32 MAX_INTERPOLATE_DISTANCE_SQUARED = 10.f * 10.f;
  60. const F32 OBJECT_DAMPING_TIME_CONSTANT = 0.06f;
  61. const F32 MIN_SHADOW_CASTER_RADIUS = 2.0f;
  63. static LLFastTimer::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
  66. ////////////////////////
  67. //
  68. // Inline implementations.
  69. //
  70. //
  74. //////////////////////////////
  75. //
  76. // Drawable code
  77. //
  78. //
  80. // static
  81. U32 LLDrawable::sCurVisible = 0;
  82. U32 LLDrawable::sNumZombieDrawables = 0;
  83. F32 LLDrawable::sCurPixelAngle = 0;
  84. LLDynamicArrayPtr<LLPointer<LLDrawable> > LLDrawable::sDeadList;
  86. #define FORCE_INVISIBLE_AREA 16.f
  88. // static
  89. void LLDrawable::incrementVisible() 
  90. {
  91. sCurVisible++;
  92. sCurPixelAngle = (F32) gViewerWindow->getWindowHeightRaw()/LLViewerCamera::getInstance()->getView();
  93. }
  94. void LLDrawable::init()
  95. {
  96. // mXform
  97. mParent = NULL;
  98. mRenderType = 0;
  99. mCurrentScale = LLVector3(1,1,1);
  100. mDistanceWRTCamera = 0.0f;
  102. mQuietCount = 0;
  104. mState     = 0;
  105. mVObjp   = NULL;
  106. // mFaces
  107. mSpatialGroupp = NULL;
  108. mVisible = sCurVisible - 2;//invisible for the current frame and the last frame.
  109. mRadius = 0.f;
  111. mGeneration = -1;
  112. mBinRadius = 1.f;
  113. mSpatialBridge = NULL;
  114. }
  116. // static
  117. void LLDrawable::initClass()
  118. {
  119. }
  122. void LLDrawable::destroy()
  123. {
  124. if (isDead())
  125. {
  126. sNumZombieDrawables--;
  127. }
  129. if (LLSpatialGroup::sNoDelete)
  130. {
  131. llerrs << "Illegal deletion of LLDrawable!" << llendl;
  132. }
  134. std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());
  135. mFaces.clear();
  138. /*if (!(sNumZombieDrawables % 10))
  139. {
  140. llinfos << "- Zombie drawables: " << sNumZombieDrawables << llendl;
  141. }*/
  142. }
  144. void LLDrawable::markDead()
  145. {
  146. if (isDead())
  147. {
  148. llwarns << "Warning!  Marking dead multiple times!" << llendl;
  149. return;
  150. }
  152. if (mSpatialBridge)
  153. {
  154. mSpatialBridge->markDead();
  155. mSpatialBridge = NULL;
  156. }
  158. sNumZombieDrawables++;
  160. // We're dead.  Free up all of our references to other objects
  161. setState(DEAD);
  162. cleanupReferences();
  163. // sDeadList.put(this);
  164. }
  166. LLVOVolume* LLDrawable::getVOVolume() const
  167. {
  168. LLViewerObject* objectp = mVObjp;
  169. if ( !isDead() && objectp && (objectp->getPCode() == LL_PCODE_VOLUME))
  170. {
  171. return ((LLVOVolume*)objectp);
  172. }
  173. else
  174. {
  175. return NULL;
  176. }
  177. }
  179. BOOL LLDrawable::isLight() const
  180. {
  181. LLViewerObject* objectp = mVObjp;
  182. if ( objectp && (objectp->getPCode() == LL_PCODE_VOLUME) && !isDead())
  183. {
  184. return ((LLVOVolume*)objectp)->getIsLight();
  185. }
  186. else
  187. {
  188. return FALSE;
  189. }
  190. }
  192. void LLDrawable::cleanupReferences()
  193. {
  194. LLFastTimer t(FTM_PIPELINE);
  196. std::for_each(mFaces.begin(), mFaces.end(), DeletePointer());
  197. mFaces.clear();
  199. gObjectList.removeDrawable(this);
  201. gPipeline.unlinkDrawable(this);
  203. // Cleanup references to other objects
  204. mVObjp = NULL;
  205. mParent = NULL;
  206. }
  208. void LLDrawable::cleanupDeadDrawables()
  209. {
  210. /*
  211. S32 i;
  212. for (i = 0; i < sDeadList.count(); i++)
  213. {
  214. if (sDeadList[i]->getNumRefs() > 1)
  215. {
  216. llwarns << "Dead drawable has " << sDeadList[i]->getNumRefs() << " remaining refs" << llendl;
  217. gPipeline.findReferences(sDeadList[i]);
  218. }
  219. }
  220. */
  221. sDeadList.reset();
  222. }
  224. S32 LLDrawable::findReferences(LLDrawable *drawablep)
  225. {
  226. S32 count = 0;
  227. if (mParent == drawablep)
  228. {
  229. llinfos << this << ": parent reference" << llendl;
  230. count++;
  231. }
  232. return count;
  233. }
  235. LLFace* LLDrawable::addFace(LLFacePool *poolp, LLViewerTexture *texturep)
  236. {
  237. LLMemType mt(LLMemType::MTYPE_DRAWABLE);
  239. LLFace *face = new LLFace(this, mVObjp);
  240. if (!face) llerrs << "Allocating new Face: " << mFaces.size() << llendl;
  242. if (face)
  243. {
  244. mFaces.push_back(face);
  246. if (poolp)
  247. {
  248. face->setPool(poolp, texturep);
  249. }
  251. if (isState(UNLIT))
  252. {
  253. face->setState(LLFace::FULLBRIGHT);
  254. }
  255. }
  256. return face;
  257. }
  259. LLFace* LLDrawable::addFace(const LLTextureEntry *te, LLViewerTexture *texturep)
  260. {
  261. LLMemType mt(LLMemType::MTYPE_DRAWABLE);
  263. LLFace *face;
  264. face = new LLFace(this, mVObjp);
  266. face->setTEOffset(mFaces.size());
  267. face->setTexture(texturep);
  268. face->setPoolType(gPipeline.getPoolTypeFromTE(te, texturep));
  270. mFaces.push_back(face);
  272. if (isState(UNLIT))
  273. {
  274. face->setState(LLFace::FULLBRIGHT);
  275. }
  277. return face;
  279. }
  281. void LLDrawable::setNumFaces(const S32 newFaces, LLFacePool *poolp, LLViewerTexture *texturep)
  282. {
  283. if (newFaces == (S32)mFaces.size())
  284. {
  285. return;
  286. }
  287. else if (newFaces < (S32)mFaces.size())
  288. {
  289. std::for_each(mFaces.begin() + newFaces, mFaces.end(), DeletePointer());
  290. mFaces.erase(mFaces.begin() + newFaces, mFaces.end());
  291. }
  292. else // (newFaces > mFaces.size())
  293. {
  294. mFaces.reserve(newFaces);
  295. for (int i = mFaces.size(); i<newFaces; i++)
  296. {
  297. addFace(poolp, texturep);
  298. }
  299. }
  301. llassert_always(mFaces.size() == newFaces);
  302. }
  304. void LLDrawable::setNumFacesFast(const S32 newFaces, LLFacePool *poolp, LLViewerTexture *texturep)
  305. {
  306. if (newFaces <= (S32)mFaces.size() && newFaces >= (S32)mFaces.size()/2)
  307. {
  308. return;
  309. }
  310. else if (newFaces < (S32)mFaces.size())
  311. {
  312. std::for_each(mFaces.begin() + newFaces, mFaces.end(), DeletePointer());
  313. mFaces.erase(mFaces.begin() + newFaces, mFaces.end());
  314. }
  315. else // (newFaces > mFaces.size())
  316. {
  317. mFaces.reserve(newFaces);
  318. for (int i = mFaces.size(); i<newFaces; i++)
  319. {
  320. addFace(poolp, texturep);
  321. }
  322. }
  324. llassert_always(mFaces.size() == newFaces) ;
  325. }
  327. void LLDrawable::mergeFaces(LLDrawable* src)
  328. {
  329. U32 face_count = mFaces.size() + src->mFaces.size();
  331. mFaces.reserve(face_count);
  332. for (U32 i = 0; i < src->mFaces.size(); i++)
  333. {
  334. LLFace* facep = src->mFaces[i];
  335. facep->setDrawable(this);
  336. mFaces.push_back(facep);
  337. }
  338. src->mFaces.clear();
  339. }
  341. void LLDrawable::deleteFaces(S32 offset, S32 count)
  342. {
  343. face_list_t::iterator face_begin = mFaces.begin() + offset;
  344. face_list_t::iterator face_end = face_begin + count;
  346. std::for_each(face_begin, face_end, DeletePointer());
  347. mFaces.erase(face_begin, face_end);
  348. }
  350. void LLDrawable::update()
  351. {
  352. llerrs << "Shouldn't be called!" << llendl;
  353. }
  356. void LLDrawable::updateMaterial()
  357. {
  358. }
  360. void LLDrawable::makeActive()
  361. {
  362. #if !LL_RELEASE_FOR_DOWNLOAD
  363. if (mVObjp.notNull())
  364. {
  365. U32 pcode = mVObjp->getPCode();
  366. if (pcode == LLViewerObject::LL_VO_WATER ||
  367. pcode == LLViewerObject::LL_VO_SURFACE_PATCH ||
  368. pcode == LLViewerObject::LL_VO_PART_GROUP ||
  369. pcode == LLViewerObject::LL_VO_HUD_PART_GROUP ||
  370. pcode == LLViewerObject::LL_VO_CLOUDS ||
  371. pcode == LLViewerObject::LL_VO_GROUND ||
  372. pcode == LLViewerObject::LL_VO_SKY)
  373. {
  374. llerrs << "Static viewer object has active drawable!" << llendl;
  375. }
  376. }
  377. #endif
  379. if (!isState(ACTIVE)) // && mGeneration > 0)
  380. {
  381. setState(ACTIVE);
  383. //parent must be made active first
  384. if (!isRoot() && !mParent->isActive())
  385. {
  386. mParent->makeActive();
  387. }
  389. gPipeline.setActive(this, TRUE);
  391. //all child objects must also be active
  392. llassert_always(mVObjp);
  394. LLViewerObject::const_child_list_t& child_list = mVObjp->getChildren();
  395. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  396.  iter != child_list.end(); iter++)
  397. {
  398. LLViewerObject* child = *iter;
  399. LLDrawable* drawable = child->mDrawable;
  400. if (drawable)
  401. {
  402. drawable->makeActive();
  403. }
  404. }
  406. if (mVObjp->getPCode() == LL_PCODE_VOLUME)
  407. {
  408. if (mVObjp->isFlexible())
  409. {
  410. return;
  411. }
  412. }
  414. if (mVObjp->getPCode() == LL_PCODE_VOLUME)
  415. {
  416. gPipeline.markRebuild(this, LLDrawable::REBUILD_VOLUME, TRUE);
  417. }
  418. updatePartition();
  419. }
  421. if (isRoot())
  422. {
  423. mQuietCount = 0;
  424. }
  425. else
  426. {
  427. getParent()->mQuietCount = 0;
  428. }
  429. }
  432. void LLDrawable::makeStatic(BOOL warning_enabled)
  433. {
  434. if (isState(ACTIVE))
  435. {
  436. clearState(ACTIVE);
  437. gPipeline.setActive(this, FALSE);
  439. if (mParent.notNull() && mParent->isActive() && warning_enabled)
  440. {
  441. LL_WARNS_ONCE("Drawable") << "Drawable becomes static with active parent!" << LL_ENDL;
  442. }
  444. LLViewerObject::const_child_list_t& child_list = mVObjp->getChildren();
  445. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  446.  iter != child_list.end(); iter++)
  447. {
  448. LLViewerObject* child = *iter;
  449. LLDrawable* child_drawable = child->mDrawable;
  450. if (child_drawable)
  451. {
  452. if (child_drawable->getParent() != this)
  453. {
  454. llwarns << "Child drawable has unknown parent." << llendl;
  455. }
  456. child_drawable->makeStatic(warning_enabled);
  457. }
  458. }
  460. if (mVObjp->getPCode() == LL_PCODE_VOLUME)
  461. {
  462. gPipeline.markRebuild(this, LLDrawable::REBUILD_VOLUME, TRUE);
  463. }
  465. if (mSpatialBridge)
  466. {
  467. mSpatialBridge->markDead();
  468. setSpatialBridge(NULL);
  469. }
  470. }
  471. updatePartition();
  472. }
  474. // Returns "distance" between target destination and resulting xfrom
  475. F32 LLDrawable::updateXform(BOOL undamped)
  476. {
  477. BOOL damped = !undamped;
  479. // Position
  480. LLVector3 old_pos(mXform.getPosition());
  481. LLVector3 target_pos;
  482. if (mXform.isRoot())
  483. {
  484. // get root position in your agent's region
  485. target_pos = mVObjp->getPositionAgent();
  486. }
  487. else
  488. {
  489. // parent-relative position
  490. target_pos = mVObjp->getPosition();
  491. }
  493. // Rotation
  494. LLQuaternion old_rot(mXform.getRotation());
  495. LLQuaternion target_rot = mVObjp->getRotation();
  496. //scaling
  497. LLVector3 target_scale = mVObjp->getScale();
  498. LLVector3 old_scale = mCurrentScale;
  499. LLVector3 dest_scale = target_scale;
  501. // Damping
  502. F32 dist_squared = 0.f;
  503. F32 camdist2 = (mDistanceWRTCamera * mDistanceWRTCamera);
  505. if (damped && isVisible())
  506. {
  507. F32 lerp_amt = llclamp(LLCriticalDamp::getInterpolant(OBJECT_DAMPING_TIME_CONSTANT), 0.f, 1.f);
  508. LLVector3 new_pos = lerp(old_pos, target_pos, lerp_amt);
  509. dist_squared = dist_vec_squared(new_pos, target_pos);
  511. LLQuaternion new_rot = nlerp(lerp_amt, old_rot, target_rot);
  512. dist_squared += (1.f - dot(new_rot, target_rot)) * 10.f;
  514. LLVector3 new_scale = lerp(old_scale, target_scale, lerp_amt);
  515. dist_squared += dist_vec_squared(new_scale, target_scale);
  517. if ((dist_squared >= MIN_INTERPOLATE_DISTANCE_SQUARED * camdist2) &&
  518. (dist_squared <= MAX_INTERPOLATE_DISTANCE_SQUARED))
  519. {
  520. // interpolate
  521. target_pos = new_pos;
  522. target_rot = new_rot;
  523. target_scale = new_scale;
  524. }
  525. else
  526. {
  527. // snap to final position
  528. dist_squared = 0.0f;
  529. if (!isRoot())
  530. { //child prim snapping to some position, needs a rebuild
  531. gPipeline.markRebuild(this, LLDrawable::REBUILD_POSITION, TRUE);
  532. }
  533. }
  534. }
  536. if ((mCurrentScale != target_scale) ||
  537. (!isRoot() && 
  538.  (dist_squared >= MIN_INTERPOLATE_DISTANCE_SQUARED || 
  539.  !mVObjp->getAngularVelocity().isExactlyZero() ||
  540.  target_pos != mXform.getPosition() ||
  541.  target_rot != mXform.getRotation())))
  542. { //child prim moving or scale change requires immediate rebuild
  543. gPipeline.markRebuild(this, LLDrawable::REBUILD_POSITION, TRUE);
  544. }
  545. else if (!getVOVolume() && !isAvatar())
  546. {
  547. movePartition();
  548. }
  550. // Update
  551. mXform.setPosition(target_pos);
  552. mXform.setRotation(target_rot);
  553. mXform.setScale(LLVector3(1,1,1)); //no scale in drawable transforms (IT'S A RULE!)
  554. mXform.updateMatrix();
  556. mCurrentScale = target_scale;
  558. if (mSpatialBridge)
  559. {
  560. gPipeline.markMoved(mSpatialBridge, FALSE);
  561. }
  562. return dist_squared;
  563. }
  565. void LLDrawable::setRadius(F32 radius)
  566. {
  567. if (mRadius != radius)
  568. {
  569. mRadius = radius;
  570. }
  571. }
  573. void LLDrawable::moveUpdatePipeline(BOOL moved)
  574. {
  575. makeActive();
  577. // Update the face centers.
  578. for (S32 i = 0; i < getNumFaces(); i++)
  579. {
  580. getFace(i)->updateCenterAgent();
  581. }
  582. }
  584. void LLDrawable::movePartition()
  585. {
  586. LLSpatialPartition* part = getSpatialPartition();
  587. if (part)
  588. {
  589. part->move(this, getSpatialGroup());
  590. }
  591. }
  593. BOOL LLDrawable::updateMove()
  594. {
  595. if (isDead())
  596. {
  597. llwarns << "Update move on dead drawable!" << llendl;
  598. return TRUE;
  599. }
  601. if (mVObjp.isNull())
  602. {
  603. return FALSE;
  604. }
  606. makeActive();
  608. BOOL done;
  610. if (isState(MOVE_UNDAMPED))
  611. {
  612. done = updateMoveUndamped();
  613. }
  614. else
  615. {
  616. done = updateMoveDamped();
  617. }
  618. return done;
  619. }
  621. BOOL LLDrawable::updateMoveUndamped()
  622. {
  623. F32 dist_squared = updateXform(TRUE);
  625. mGeneration++;
  627. if (!isState(LLDrawable::INVISIBLE))
  628. {
  629. BOOL moved = (dist_squared > 0.001f && dist_squared < 255.99f);
  630. moveUpdatePipeline(moved);
  631. mVObjp->updateText();
  632. }
  634. mVObjp->clearChanged(LLXform::MOVED);
  636. return TRUE;
  637. }
  639. void LLDrawable::updatePartition()
  640. {
  641. if (!getVOVolume())
  642. {
  643. movePartition();
  644. }
  645. else if (mSpatialBridge)
  646. {
  647. gPipeline.markMoved(mSpatialBridge, FALSE);
  648. }
  649. else
  650. {
  651. //a child prim moved and needs its verts regenerated
  652. gPipeline.markRebuild(this, LLDrawable::REBUILD_POSITION, TRUE);
  653. }
  654. }
  656. BOOL LLDrawable::updateMoveDamped()
  657. {
  658. F32 dist_squared = updateXform(FALSE);
  660. mGeneration++;
  662. if (!isState(LLDrawable::INVISIBLE))
  663. {
  664. BOOL moved = (dist_squared > 0.001f && dist_squared < 128.0f);
  665. moveUpdatePipeline(moved);
  666. mVObjp->updateText();
  667. }
  669. BOOL done_moving = (dist_squared == 0.0f) ? TRUE : FALSE;
  671. if (done_moving)
  672. {
  673. mVObjp->clearChanged(LLXform::MOVED);
  674. }
  676. return done_moving;
  677. }
  679. void LLDrawable::updateDistance(LLCamera& camera, bool force_update)
  680. {
  681. if (LLViewerCamera::sCurCameraID != LLViewerCamera::CAMERA_WORLD)
  682. {
  683. llerrs << "WTF?" << llendl;
  684. }
  686. //switch LOD with the spatial group to avoid artifacts
  687. //LLSpatialGroup* sg = getSpatialGroup();
  689. LLVector3 pos;
  691. //if (!sg || sg->changeLOD())
  692. {
  693. LLVOVolume* volume = getVOVolume();
  694. if (volume)
  695. {
  696. volume->updateRelativeXform();
  697. pos = volume->getRelativeXform().getTranslation();
  698. if (isStatic())
  699. {
  700. pos += volume->getRegion()->getOriginAgent();
  701. }
  703. if (isState(LLDrawable::HAS_ALPHA))
  704. {
  705. for (S32 i = 0; i < getNumFaces(); i++)
  706. {
  707. LLFace* facep = getFace(i);
  708. if (force_update || facep->getPoolType() == LLDrawPool::POOL_ALPHA)
  709. {
  710. LLVector3 box = (facep->mExtents[1] - facep->mExtents[0]) * 0.25f;
  711. LLVector3 v = (facep->mCenterLocal-camera.getOrigin());
  712. const LLVector3& at = camera.getAtAxis();
  713. for (U32 j = 0; j < 3; j++)
  714. {
  715. v.mV[j] -= box.mV[j] * at.mV[j];
  716. }
  717. facep->mDistance = v * camera.getAtAxis();
  718. }
  719. }
  720. }
  721. }
  722. else
  723. {
  724. pos = LLVector3(getPositionGroup());
  725. }
  727. pos -= camera.getOrigin();
  728. mDistanceWRTCamera = llround(pos.magVec(), 0.01f);
  729. mVObjp->updateLOD();
  730. }
  731. }
  733. void LLDrawable::updateTexture()
  734. {
  735. LLMemType mt(LLMemType::MTYPE_DRAWABLE);
  737. if (isDead())
  738. {
  739. llwarns << "Dead drawable updating texture!" << llendl;
  740. return;
  741. }
  743. if (getNumFaces() != mVObjp->getNumTEs())
  744. { //drawable is transitioning its face count
  745. return;
  746. }
  748. if (getVOVolume())
  749. {
  750. if (isActive())
  751. {
  752. if (isRoot())
  753. {
  754. mQuietCount = 0;
  755. }
  756. else
  757. {
  758. getParent()->mQuietCount = 0;
  759. }
  760. }
  762. gPipeline.markRebuild(this, LLDrawable::REBUILD_MATERIAL, TRUE);
  763. }
  764. }
  766. BOOL LLDrawable::updateGeometry(BOOL priority)
  767. {
  768. llassert(mVObjp.notNull());
  769. BOOL res = mVObjp->updateGeometry(this);
  770. return res;
  771. }
  773. void LLDrawable::shiftPos(const LLVector3 &shift_vector)
  774. {
  775. if (isDead())
  776. {
  777. llwarns << "Shifting dead drawable" << llendl;
  778. return;
  779. }
  781. if (mParent)
  782. {
  783. mXform.setPosition(mVObjp->getPosition());
  784. }
  785. else
  786. {
  787. mXform.setPosition(mVObjp->getPositionAgent());
  788. }
  790. mXform.setRotation(mVObjp->getRotation());
  791. mXform.setScale(1,1,1);
  792. mXform.updateMatrix();
  794. if (isStatic())
  795. {
  796. LLVOVolume* volume = getVOVolume();
  797. if (!volume)
  798. {
  799. gPipeline.markRebuild(this, LLDrawable::REBUILD_ALL, TRUE);
  800. }
  802. for (S32 i = 0; i < getNumFaces(); i++)
  803. {
  804. LLFace *facep = getFace(i);
  805. facep->mCenterAgent += shift_vector;
  806. facep->mExtents[0] += shift_vector;
  807. facep->mExtents[1] += shift_vector;
  809. if (!volume && facep->hasGeometry())
  810. {
  811. facep->mVertexBuffer = NULL;
  812. facep->mLastVertexBuffer = NULL;
  813. }
  814. }
  816. mExtents[0] += shift_vector;
  817. mExtents[1] += shift_vector;
  818. mPositionGroup += LLVector3d(shift_vector);
  819. }
  820. else if (mSpatialBridge)
  821. {
  822. mSpatialBridge->shiftPos(shift_vector);
  823. }
  824. else if (isAvatar())
  825. {
  826. mExtents[0] += shift_vector;
  827. mExtents[1] += shift_vector;
  828. mPositionGroup += LLVector3d(shift_vector);
  829. }
  831. mVObjp->onShift(shift_vector);
  832. }
  834. const LLVector3& LLDrawable::getBounds(LLVector3& min, LLVector3& max) const
  835. {
  836. mXform.getMinMax(min,max);
  837. return mXform.getPositionW();
  838. }
  840. const LLVector3* LLDrawable::getSpatialExtents() const
  841. {
  842. return mExtents;
  843. }
  845. void LLDrawable::setSpatialExtents(LLVector3 min, LLVector3 max)
  846. { 
  847. LLVector3 size = max - min;
  848. mExtents[0] = min; 
  849. mExtents[1] = max; 
  850. }
  852. void LLDrawable::setPositionGroup(const LLVector3d& pos)
  853. {
  854. mPositionGroup.setVec(pos);
  855. }
  857. void LLDrawable::updateSpatialExtents()
  858. {
  859. if (mVObjp)
  860. {
  861. mVObjp->updateSpatialExtents(mExtents[0], mExtents[1]);
  862. }
  864. updateBinRadius();
  866. if (mSpatialBridge.notNull())
  867. {
  868. mPositionGroup.setVec(0,0,0);
  869. }
  870. }
  873. void LLDrawable::updateBinRadius()
  874. {
  875. if (mVObjp.notNull())
  876. {
  877. mBinRadius = llmin(mVObjp->getBinRadius(), 256.f);
  878. }
  879. else
  880. {
  881. mBinRadius = llmin(getRadius()*4.f, 256.f);
  882. }
  883. }
  885. void LLDrawable::updateSpecialHoverCursor(BOOL enabled)
  886. {
  887. // TODO: maintain a list of objects that have special
  888. // hover cursors, then use that list for per-frame
  889. // hover cursor selection. JC
  890. }
  892. F32 LLDrawable::getVisibilityRadius() const
  893. {
  894. if (isDead())
  895. {
  896. return 0.f;
  897. }
  898. else if (isLight())
  899. {
  900. const LLVOVolume *vov = getVOVolume();
  901. if (vov)
  902. {
  903. return llmax(getRadius(), vov->getLightRadius());
  904. } else {
  905. // llwarns ?
  906. }
  907. }
  908. return getRadius();
  909. }
  911. void LLDrawable::updateUVMinMax()
  912. {
  913. }
  915. void LLDrawable::setSpatialGroup(LLSpatialGroup *groupp)
  916. {
  917. /*if (mSpatialGroupp && (groupp != mSpatialGroupp))
  918. {
  919. mSpatialGroupp->setState(LLSpatialGroup::GEOM_DIRTY);
  920. }*/
  921. mSpatialGroupp = groupp;
  922. }
  924. LLSpatialPartition* LLDrawable::getSpatialPartition()
  925. { 
  926. LLSpatialPartition* retval = NULL;
  928. if (!mVObjp || 
  929. !getVOVolume() ||
  930. isStatic())
  931. {
  932. retval = gPipeline.getSpatialPartition((LLViewerObject*) mVObjp);
  933. }
  934. else if (isRoot())
  935. { //must be an active volume
  936. if (!mSpatialBridge)
  937. {
  938. if (mVObjp->isHUDAttachment())
  939. {
  940. setSpatialBridge(new LLHUDBridge(this));
  941. }
  942. else
  943. {
  944. setSpatialBridge(new LLVolumeBridge(this));
  945. }
  946. }
  947. return mSpatialBridge->asPartition();
  948. }
  949. else 
  950. {
  951. retval = getParent()->getSpatialPartition();
  952. }
  954. if (retval && mSpatialBridge.notNull())
  955. {
  956. mSpatialBridge->markDead();
  957. setSpatialBridge(NULL);
  958. }
  960. return retval;
  961. }
  963. const S32 MIN_VIS_FRAME_RANGE = 2 ; //two frames:the current one and the last one.
  964. //static 
  965. S32 LLDrawable::getMinVisFrameRange()
  966. {
  967. return MIN_VIS_FRAME_RANGE ;
  968. }
  970. BOOL LLDrawable::isRecentlyVisible() const
  971. {
  972. //currently visible or visible in the previous frame.
  973. BOOL vis = isVisible() || (sCurVisible - mVisible < MIN_VIS_FRAME_RANGE)  ;
  975. if(!vis)
  976. {
  977. LLSpatialGroup* group = getSpatialGroup();
  978. if (group && group->isRecentlyVisible())
  979. {
  980. mVisible = sCurVisible;
  981. vis = TRUE ;
  982. }
  983. }
  985. return vis ;
  986. }
  988. BOOL LLDrawable::isVisible() const
  989. {
  990. if (mVisible == sCurVisible)
  991. {
  992. return TRUE;
  993. }
  995. #if 0
  996. //disabling this code fixes DEV-20105.  Leaving in place in case some other bug pops up as a a result.
  997. //should be safe to just always ask the spatial group for visibility.
  998. if (isActive())
  999. {
  1000. if (isRoot())
  1001. {
  1002. LLSpatialGroup* group = mSpatialBridge.notNull() ? mSpatialBridge->getSpatialGroup() :
  1003. getSpatialGroup();
  1004. if (group && group->isVisible())
  1005. {
  1006. mVisible = sCurVisible;
  1007. return TRUE;
  1008. }
  1009. }
  1010. else
  1011. {
  1012. if (getParent()->isVisible())
  1013. {
  1014. mVisible = sCurVisible;
  1015. return TRUE;
  1016. }
  1017. }
  1018. }
  1019. else
  1020. #endif
  1021. {
  1022. LLSpatialGroup* group = getSpatialGroup();
  1023. if (group && group->isVisible())
  1024. {
  1025. mVisible = sCurVisible;
  1026. return TRUE;
  1027. }
  1028. }
  1030. return FALSE;
  1031. }
  1033. //=======================================
  1034. // Spatial Partition Bridging Drawable
  1035. //=======================================
  1037. LLSpatialBridge::LLSpatialBridge(LLDrawable* root, BOOL render_by_group, U32 data_mask)
  1038. : LLSpatialPartition(data_mask, render_by_group, FALSE)
  1039. {
  1040. mDrawable = root;
  1041. root->setSpatialBridge(this);
  1043. mRenderType = mDrawable->mRenderType;
  1044. mDrawableType = mDrawable->mRenderType;
  1046. mPartitionType = LLViewerRegion::PARTITION_VOLUME;
  1048. mOctree->balance();
  1050. llassert(mDrawable);
  1051. llassert(mDrawable->getRegion());
  1052. LLSpatialPartition *part = mDrawable->getRegion()->getSpatialPartition(mPartitionType);
  1053. llassert(part);
  1055. if (part)
  1056. {
  1057. part->put(this);
  1058. }
  1059. }
  1061. LLSpatialBridge::~LLSpatialBridge()
  1062. {
  1063. LLSpatialGroup* group = getSpatialGroup();
  1064. if (group)
  1065. {
  1066. group->mSpatialPartition->remove(this, group);
  1067. }
  1068. }
  1070. void LLSpatialBridge::updateSpatialExtents()
  1071. {
  1072. LLSpatialGroup* root = (LLSpatialGroup*) mOctree->getListener(0);
  1074. {
  1075. LLFastTimer ftm(FTM_CULL_REBOUND);
  1076. root->rebound();
  1077. }
  1079. LLXformMatrix* mat = mDrawable->getXform();
  1081. LLVector3 offset = root->mBounds[0];
  1082. LLVector3 size = root->mBounds[1];
  1084. LLVector3 center = LLVector3(0,0,0) * mat->getWorldMatrix();
  1085. LLQuaternion rotation = LLQuaternion(mat->getWorldMatrix());
  1087. offset *= rotation;
  1088. center += offset;
  1090. LLVector3 v[4];
  1091. //get 4 corners of bounding box
  1092. v[0] = (size * rotation);
  1093. v[1] = (LLVector3(-size.mV[0], -size.mV[1], size.mV[2]) * rotation);
  1094. v[2] = (LLVector3(size.mV[0], -size.mV[1], -size.mV[2]) * rotation);
  1095. v[3] = (LLVector3(-size.mV[0], size.mV[1], -size.mV[2]) * rotation);
  1097. LLVector3& newMin = mExtents[0];
  1098. LLVector3& newMax = mExtents[1];
  1100. newMin = newMax = center;
  1102. for (U32 i = 0; i < 4; i++)
  1103. {
  1104. for (U32 j = 0; j < 3; j++)
  1105. {
  1106. F32 delta = fabsf(v[i].mV[j]);
  1107. F32 min = center.mV[j] - delta;
  1108. F32 max = center.mV[j] + delta;
  1110. if (min < newMin.mV[j])
  1111. {
  1112. newMin.mV[j] = min;
  1113. }
  1115. if (max > newMax.mV[j])
  1116. {
  1117. newMax.mV[j] = max;
  1118. }
  1119. }
  1120. }
  1122. LLVector3 diagonal = newMax - newMin;
  1123. mRadius = diagonal.magVec() * 0.5f;
  1125. mPositionGroup.setVec((newMin + newMax) * 0.5f);
  1126. updateBinRadius();
  1127. }
  1129. void LLSpatialBridge::updateBinRadius()
  1130. {
  1131. mBinRadius = llmin((F32) mOctree->getSize().mdV[0]*0.5f, 256.f);
  1132. }
  1134. LLCamera LLSpatialBridge::transformCamera(LLCamera& camera)
  1135. {
  1136. LLCamera ret = camera;
  1137. LLXformMatrix* mat = mDrawable->getXform();
  1138. LLVector3 center = LLVector3(0,0,0) * mat->getWorldMatrix();
  1139. LLQuaternion rotation = LLQuaternion(mat->getWorldMatrix());
  1141. LLVector3 delta = ret.getOrigin() - center;
  1142. LLQuaternion rot = ~mat->getRotation();
  1144. delta *= rot;
  1145. LLVector3 lookAt = ret.getAtAxis();
  1146. LLVector3 up_axis = ret.getUpAxis();
  1147. LLVector3 left_axis = ret.getLeftAxis();
  1149. lookAt *= rot;
  1150. up_axis *= rot;
  1151. left_axis *= rot;
  1153. if (!delta.isFinite())
  1154. {
  1155. delta.clearVec();
  1156. }
  1158. ret.setOrigin(delta);
  1159. ret.setAxes(lookAt, left_axis, up_axis);
  1161. return ret;
  1162. }
  1164. void LLDrawable::setVisible(LLCamera& camera, std::vector<LLDrawable*>* results, BOOL for_select)
  1165. {
  1166. mVisible = sCurVisible;
  1168. #if 0 && !LL_RELEASE_FOR_DOWNLOAD
  1169. //crazy paranoid rules checking
  1170. if (getVOVolume())
  1171. {
  1172. if (!isRoot())
  1173. {
  1174. if (isActive() && !mParent->isActive())
  1175. {
  1176. llerrs << "Active drawable has static parent!" << llendl;
  1177. }
  1179. if (isStatic() && !mParent->isStatic())
  1180. {
  1181. llerrs << "Static drawable has active parent!" << llendl;
  1182. }
  1184. if (mSpatialBridge)
  1185. {
  1186. llerrs << "Child drawable has spatial bridge!" << llendl;
  1187. }
  1188. }
  1189. else if (isActive() && !mSpatialBridge)
  1190. {
  1191. llerrs << "Active root drawable has no spatial bridge!" << llendl;
  1192. }
  1193. else if (isStatic() && mSpatialBridge.notNull())
  1194. {
  1195. llerrs << "Static drawable has spatial bridge!" << llendl;
  1196. }
  1197. }
  1198. #endif
  1199. }
  1201. class LLOctreeMarkNotCulled: public LLOctreeTraveler<LLDrawable>
  1202. {
  1203. public:
  1204. LLCamera* mCamera;
  1206. LLOctreeMarkNotCulled(LLCamera* camera_in) : mCamera(camera_in) { }
  1208. virtual void traverse(const LLOctreeNode<LLDrawable>* node)
  1209. {
  1210. LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
  1211. group->setVisible();
  1212. LLOctreeTraveler<LLDrawable>::traverse(node);
  1213. }
  1215. void visit(const LLOctreeNode<LLDrawable>* branch)
  1216. {
  1217. gPipeline.markNotCulled((LLSpatialGroup*) branch->getListener(0), *mCamera);
  1218. }
  1219. };
  1221. void LLSpatialBridge::setVisible(LLCamera& camera_in, std::vector<LLDrawable*>* results, BOOL for_select)
  1222. {
  1223. if (!gPipeline.hasRenderType(mDrawableType))
  1224. {
  1225. return;
  1226. }
  1229. //HACK don't draw attachments for avatars that haven't been visible in more than a frame
  1230. LLViewerObject *vobj = mDrawable->getVObj();
  1231. if (vobj && vobj->isAttachment() && !vobj->isHUDAttachment())
  1232. {
  1233. LLDrawable* av;
  1234. LLDrawable* parent = mDrawable->getParent();
  1236. if (parent)
  1237. {
  1238. LLViewerObject* objparent = parent->getVObj();
  1239. av = objparent->mDrawable;
  1240. LLSpatialGroup* group = av->getSpatialGroup();
  1242. BOOL impostor = FALSE;
  1243. BOOL loaded = FALSE;
  1244. if (objparent->isAvatar())
  1245. {
  1246. LLVOAvatar* avatarp = (LLVOAvatar*) objparent;
  1247. if (avatarp->isVisible())
  1248. {
  1249. impostor = objparent->isAvatar() && ((LLVOAvatar*) objparent)->isImpostor();
  1250. loaded   = objparent->isAvatar() && ((LLVOAvatar*) objparent)->isFullyLoaded();
  1251. }
  1252. else
  1253. {
  1254. return;
  1255. }
  1256. }
  1258. if (!group ||
  1259. LLDrawable::getCurrentFrame() - av->mVisible > 1 ||
  1260. impostor ||
  1261. !loaded)
  1262. {
  1263. return;
  1264. }
  1265. }
  1266. }
  1269. LLSpatialGroup* group = (LLSpatialGroup*) mOctree->getListener(0);
  1270. group->rebound();
  1272. LLVector3 center = (mExtents[0] + mExtents[1]) * 0.5f;
  1273. LLVector3 size = (mExtents[1]-mExtents[0]) * 0.5f;
  1275. if ((LLPipeline::sShadowRender && camera_in.AABBInFrustum(center, size)) ||
  1276. LLPipeline::sImpostorRender ||
  1277. (camera_in.AABBInFrustumNoFarClip(center, size) && 
  1278. AABBSphereIntersect(mExtents[0], mExtents[1], camera_in.getOrigin(), camera_in.mFrustumCornerDist)))
  1279. {
  1280. if (!LLPipeline::sImpostorRender &&
  1281. !LLPipeline::sShadowRender && 
  1282. LLPipeline::calcPixelArea(center, size, camera_in) < FORCE_INVISIBLE_AREA)
  1283. {
  1284. return;
  1285. }
  1287. LLDrawable::setVisible(camera_in);
  1289. if (for_select)
  1290. {
  1291. results->push_back(mDrawable);
  1292. if (mDrawable->getVObj())
  1293. {
  1294. LLViewerObject::const_child_list_t& child_list = mDrawable->getVObj()->getChildren();
  1295. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1296.  iter != child_list.end(); iter++)
  1297. {
  1298. LLViewerObject* child = *iter;
  1299. LLDrawable* drawable = child->mDrawable;
  1300. results->push_back(drawable);
  1301. }
  1302. }
  1303. }
  1304. else 
  1305. {
  1306. LLCamera trans_camera = transformCamera(camera_in);
  1307. LLOctreeMarkNotCulled culler(&trans_camera);
  1308. culler.traverse(mOctree);
  1309. }
  1310. }
  1311. }
  1313. void LLSpatialBridge::updateDistance(LLCamera& camera_in, bool force_update)
  1314. {
  1315. if (mDrawable == NULL)
  1316. {
  1317. markDead();
  1318. return;
  1319. }
  1321. if (mDrawable->getVObj())
  1322. {
  1323. if (mDrawable->getVObj()->isAttachment())
  1324. {
  1325. LLDrawable* parent = mDrawable->getParent();
  1326. if (parent && parent->getVObj())
  1327. {
  1328. LLVOAvatar* av = parent->getVObj()->asAvatar();
  1329. if (av && av->isImpostor())
  1330. {
  1331. return;
  1332. }
  1333. }
  1334. }
  1336. LLCamera camera = transformCamera(camera_in);
  1338. mDrawable->updateDistance(camera, force_update);
  1340. LLViewerObject::const_child_list_t& child_list = mDrawable->getVObj()->getChildren();
  1341. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1342.  iter != child_list.end(); iter++)
  1343. {
  1344. LLViewerObject* child = *iter;
  1345. LLDrawable* drawable = child->mDrawable;
  1346. if (!drawable)
  1347. {
  1348. continue;
  1349. }
  1351. if (!drawable->isAvatar())
  1352. {
  1353. drawable->updateDistance(camera, force_update);
  1354. }
  1355. }
  1356. }
  1357. }
  1359. void LLSpatialBridge::makeActive()
  1360. { //it is an error to make a spatial bridge active (it's already active)
  1361. llerrs << "makeActive called on spatial bridge" << llendl;
  1362. }
  1364. void LLSpatialBridge::move(LLDrawable *drawablep, LLSpatialGroup *curp, BOOL immediate)
  1365. {
  1366. LLSpatialPartition::move(drawablep, curp, immediate);
  1367. gPipeline.markMoved(this, FALSE);
  1368. }
  1370. BOOL LLSpatialBridge::updateMove()
  1371. {
  1372. llassert(mDrawable);
  1373. llassert(mDrawable->getRegion());
  1374. LLSpatialPartition* part = mDrawable->getRegion()->getSpatialPartition(mPartitionType);
  1375. llassert(part);
  1377. mOctree->balance();
  1378. if (part)
  1379. {
  1380. part->move(this, getSpatialGroup(), TRUE);
  1381. }
  1382. return TRUE;
  1383. }
  1385. void LLSpatialBridge::shiftPos(const LLVector3& vec)
  1386. {
  1387. mExtents[0] += vec;
  1388. mExtents[1] += vec;
  1389. mPositionGroup += LLVector3d(vec);
  1390. }
  1392. void LLSpatialBridge::cleanupReferences()
  1393. {
  1394. LLDrawable::cleanupReferences();
  1395. if (mDrawable)
  1396. {
  1397. mDrawable->setSpatialGroup(NULL);
  1398. if (mDrawable->getVObj())
  1399. {
  1400. LLViewerObject::const_child_list_t& child_list = mDrawable->getVObj()->getChildren();
  1401. for (LLViewerObject::child_list_t::const_iterator iter = child_list.begin();
  1402.  iter != child_list.end(); iter++)
  1403. {
  1404. LLViewerObject* child = *iter;
  1405. LLDrawable* drawable = child->mDrawable;
  1406. if (drawable)
  1407. {
  1408. drawable->setSpatialGroup(NULL);
  1409. }
  1410. }
  1411. }
  1413. LLDrawable* drawablep = mDrawable;
  1414. mDrawable = NULL;
  1415. drawablep->setSpatialBridge(NULL);
  1416. }
  1417. }
  1419. const LLVector3 LLDrawable::getPositionAgent() const
  1420. {
  1421. if (getVOVolume())
  1422. {
  1423. if (isActive())
  1424. {
  1425. LLVector3 pos(0,0,0);
  1426. if (!isRoot())
  1427. {
  1428. pos = mVObjp->getPosition();
  1429. }
  1430. return pos * getRenderMatrix();
  1431. }
  1432. else
  1433. {
  1434. return mVObjp->getPositionAgent();
  1435. }
  1436. }
  1437. else
  1438. {
  1439. return getWorldPosition();
  1440. }
  1441. }
  1443. BOOL LLDrawable::isAnimating() const
  1444. {
  1445. if (!getVObj())
  1446. {
  1447. return TRUE;
  1448. }
  1450. if (getScale() != mVObjp->getScale())
  1451. {
  1452. return TRUE;
  1453. }
  1455. if (mVObjp->getPCode() == LLViewerObject::LL_VO_PART_GROUP)
  1456. {
  1457. return TRUE;
  1458. }
  1459. if (mVObjp->getPCode() == LLViewerObject::LL_VO_HUD_PART_GROUP)
  1460. {
  1461. return TRUE;
  1462. }
  1463. if (mVObjp->getPCode() == LLViewerObject::LL_VO_CLOUDS)
  1464. {
  1465. return TRUE;
  1466. }
  1468. if (!isRoot() && !mVObjp->getAngularVelocity().isExactlyZero())
  1469. {
  1470. return TRUE;
  1471. }
  1473. return FALSE;
  1474. }
  1476. void LLDrawable::updateFaceSize(S32 idx)
  1477. {
  1478. if (mVObjp.notNull())
  1479. {
  1480. mVObjp->updateFaceSize(idx);
  1481. }
  1482. }
  1484. LLBridgePartition::LLBridgePartition()
  1485. : LLSpatialPartition(0, FALSE, 0) 
  1486. { 
  1487. mDrawableType = LLPipeline::RENDER_TYPE_AVATAR; 
  1488. mPartitionType = LLViewerRegion::PARTITION_BRIDGE;
  1489. mLODPeriod = 16;
  1490. mSlopRatio = 0.25f;
  1491. }
  1493. LLHUDBridge::LLHUDBridge(LLDrawable* drawablep)
  1494. : LLVolumeBridge(drawablep)
  1495. {
  1496. mDrawableType = LLPipeline::RENDER_TYPE_HUD;
  1497. mPartitionType = LLViewerRegion::PARTITION_HUD;
  1498. mSlopRatio = 0.0f;
  1499. }
  1501. F32 LLHUDBridge::calcPixelArea(LLSpatialGroup* group, LLCamera& camera)
  1502. {
  1503. return 1024.f;
  1504. }
  1507. void LLHUDBridge::shiftPos(const LLVector3& vec)
  1508. {
  1509. //don't shift hud bridges on region crossing
  1510. }