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

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

游戏引擎

开发平台：

C++ Builder

llspatialpartition.cpp：源码内容
  1. /** 
  2.  * @file llspatialpartition.cpp
  3.  * @brief LLSpatialGroup class implementation and supporting functions
  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 "llspatialpartition.h"
  37. #include "llviewerwindow.h"
  38. #include "llviewerobjectlist.h"
  39. #include "llvovolume.h"
  40. #include "llvolume.h"
  41. #include "llviewercamera.h"
  42. #include "llface.h"
  43. #include "llviewercontrol.h"
  44. #include "llviewerregion.h"
  45. #include "llcamera.h"
  46. #include "pipeline.h"
  47. #include "llrender.h"
  48. #include "lloctree.h"
  49. #include "llvoavatar.h"
  50. #include "lltextureatlas.h"
  52. static LLFastTimer::DeclareTimer FTM_FRUSTUM_CULL("Frustum Culling");
  53. static LLFastTimer::DeclareTimer FTM_CULL_REBOUND("Cull Rebound");
  55. const F32 SG_OCCLUSION_FUDGE = 0.25f;
  56. #define SG_DISCARD_TOLERANCE 0.01f
  58. #if LL_OCTREE_PARANOIA_CHECK
  59. #define assert_octree_valid(x) x->validate()
  60. #define assert_states_valid(x) ((LLSpatialGroup*) x->mSpatialPartition->mOctree->getListener(0))->checkStates()
  61. #else
  62. #define assert_octree_valid(x)
  63. #define assert_states_valid(x)
  64. #endif
  67. static U32 sZombieGroups = 0;
  68. U32 LLSpatialGroup::sNodeCount = 0;
  69. BOOL LLSpatialGroup::sNoDelete = FALSE;
  71. static F32 sLastMaxTexPriority = 1.f;
  72. static F32 sCurMaxTexPriority = 1.f;
  74. class LLOcclusionQueryPool : public LLGLNamePool
  75. {
  76. protected:
  77. virtual GLuint allocateName()
  78. {
  79. GLuint name;
  80. glGenQueriesARB(1, &name);
  81. return name;
  82. }
  84. virtual void releaseName(GLuint name)
  85. {
  86. glDeleteQueriesARB(1, &name);
  87. }
  88. };
  90. static LLOcclusionQueryPool sQueryPool;
  92. //static counter for frame to switch LOD on
  94. void sg_assert(BOOL expr)
  95. {
  96. #if LL_OCTREE_PARANOIA_CHECK
  97. if (!expr)
  98. {
  99. llerrs << "Octree invalid!" << llendl;
  100. }
  101. #endif
  102. }
  104. #if LL_DEBUG
  105. void validate_drawable(LLDrawable* drawablep)
  106. {
  107. F64 rad = drawablep->getBinRadius();
  108. const LLVector3* ext = drawablep->getSpatialExtents();
  110. if (rad < 0 || rad > 4096 ||
  111. (ext[1]-ext[0]).magVec() > 4096)
  112. {
  113. llwarns << "Invalid drawable found in octree." << llendl;
  114. }
  115. }
  116. #else
  117. #define validate_drawable(x)
  118. #endif
  121. S32 AABBSphereIntersect(const LLVector3& min, const LLVector3& max, const LLVector3 &origin, const F32 &rad)
  122. {
  123. return AABBSphereIntersectR2(min, max, origin, rad*rad);
  124. }
  126. S32 AABBSphereIntersectR2(const LLVector3& min, const LLVector3& max, const LLVector3 &origin, const F32 &r)
  127. {
  128. F32 d = 0.f;
  129. F32 t;
  131. if ((min-origin).magVecSquared() < r &&
  132. (max-origin).magVecSquared() < r)
  133. {
  134. return 2;
  135. }
  137. for (U32 i = 0; i < 3; i++)
  138. {
  139. if (origin.mV[i] < min.mV[i])
  140. {
  141. t = min.mV[i] - origin.mV[i];
  142. d += t*t;
  143. }
  144. else if (origin.mV[i] > max.mV[i])
  145. {
  146. t = origin.mV[i] - max.mV[i];
  147. d += t*t;
  148. }
  150. if (d > r)
  151. {
  152. return 0;
  153. }
  154. }
  156. return 1;
  157. }
  160. typedef enum
  161. {
  162. b000 = 0x00,
  163. b001 = 0x01,
  164. b010 = 0x02,
  165. b011 = 0x03,
  166. b100 = 0x04,
  167. b101 = 0x05,
  168. b110 = 0x06,
  169. b111 = 0x07,
  170. } eLoveTheBits;
  172. //contact Runitai Linden for a copy of the SL object used to write this table
  173. //basically, you give the table a bitmask of the look-at vector to a node and it
  174. //gives you a triangle fan index array
  175. static U8 sOcclusionIndices[] =
  176. {
  177.  // 000
  178. b111, b110, b010, b011, b001, b101, b100, b110,
  179. //001 
  180. b110, b000, b010, b011, b111, b101, b100, b000,
  181.  //010
  182. b101, b100, b110, b111, b011, b001, b000, b100,
  183.  //011 
  184. b100, b010, b110, b111, b101, b001, b000, b010,
  185. //100 
  186. b011, b010, b000, b001, b101, b111, b110, b010,
  187.  //101 
  188. b010, b100, b000, b001, b011, b111, b110, b100,
  189.  //110
  190. b001, b000, b100, b101, b111, b011, b010, b000,
  191.  //111
  192. b000, b110, b100, b101, b001, b011, b010, b110,
  193. };
  195. U8* get_box_fan_indices(LLCamera* camera, const LLVector3& center)
  196. {
  197. LLVector3 d = center - camera->getOrigin();
  199. U8 cypher = 0;
  200. if (d.mV[0] > 0)
  201. {
  202. cypher |= b100;
  203. }
  204. if (d.mV[1] > 0)
  205. {
  206. cypher |= b010;
  207. }
  208. if (d.mV[2] > 0)
  209. {
  210. cypher |= b001;
  211. }
  213. return sOcclusionIndices+cypher*8;
  214. }
  216. void LLSpatialGroup::buildOcclusion()
  217. {
  218. if (!mOcclusionVerts)
  219. {
  220. mOcclusionVerts = new F32[8*3];
  221. }
  223. LLVector3 r = mBounds[1] + LLVector3(SG_OCCLUSION_FUDGE, SG_OCCLUSION_FUDGE, SG_OCCLUSION_FUDGE);
  225. for (U32 k = 0; k < 3; k++)
  226. {
  227. r.mV[k] = llmin(mBounds[1].mV[k]+0.25f, r.mV[k]);
  228. }
  230. F32* v = mOcclusionVerts;
  231. F32* c = mBounds[0].mV;
  232. F32* s = r.mV;
  234. //vertex positions are encoded so the 3 bits of their vertex index 
  235. //correspond to their axis facing, with bit position 3,2,1 matching
  236. //axis facing x,y,z, bit set meaning positive facing, bit clear 
  237. //meaning negative facing
  238. v[0] = c[0]-s[0]; v[1]  = c[1]-s[1]; v[2]  = c[2]-s[2];  // 0 - 0000 
  239. v[3] = c[0]-s[0]; v[4]  = c[1]-s[1]; v[5]  = c[2]+s[2];  // 1 - 0001
  240. v[6] = c[0]-s[0]; v[7]  = c[1]+s[1]; v[8]  = c[2]-s[2];  // 2 - 0010
  241. v[9] = c[0]-s[0]; v[10] = c[1]+s[1]; v[11] = c[2]+s[2];  // 3 - 0011
  242.    
  243. v[12] = c[0]+s[0]; v[13] = c[1]-s[1]; v[14] = c[2]-s[2]; // 4 - 0100
  244. v[15] = c[0]+s[0]; v[16] = c[1]-s[1]; v[17] = c[2]+s[2]; // 5 - 0101
  245. v[18] = c[0]+s[0]; v[19] = c[1]+s[1]; v[20] = c[2]-s[2]; // 6 - 0110
  246. v[21] = c[0]+s[0]; v[22] = c[1]+s[1]; v[23] = c[2]+s[2]; // 7 - 0111
  248. clearState(LLSpatialGroup::OCCLUSION_DIRTY);
  249. }
  252. BOOL earlyFail(LLCamera* camera, LLSpatialGroup* group);
  254. //returns:
  255. // 0 if sphere and AABB are not intersecting 
  256. // 1 if they are
  257. // 2 if AABB is entirely inside sphere
  259. S32 LLSphereAABB(const LLVector3& center, const LLVector3& size, const LLVector3& pos, const F32 &rad)
  260. {
  261. S32 ret = 2;
  263. LLVector3 min = center - size;
  264. LLVector3 max = center + size;
  265. for (U32 i = 0; i < 3; i++)
  266. {
  267. if (min.mV[i] > pos.mV[i] + rad ||
  268. max.mV[i] < pos.mV[i] - rad)
  269. { //totally outside
  270. return 0;
  271. }
  273. if (min.mV[i] < pos.mV[i] - rad ||
  274. max.mV[i] > pos.mV[i] + rad)
  275. { //intersecting
  276. ret = 1;
  277. }
  278. }
  280. return ret;
  281. }
  283. LLSpatialGroup::~LLSpatialGroup()
  284. {
  285. /*if (sNoDelete)
  286. {
  287. llerrs << "Illegal deletion of LLSpatialGroup!" << llendl;
  288. }*/
  290. if (isState(DEAD))
  291. {
  292. sZombieGroups--;
  293. }
  295. sNodeCount--;
  297. if (gGLManager.mHasOcclusionQuery && mOcclusionQuery[LLViewerCamera::sCurCameraID])
  298. {
  299. sQueryPool.release(mOcclusionQuery[LLViewerCamera::sCurCameraID]);
  300. }
  302. delete [] mOcclusionVerts;
  304. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  305. clearDrawMap();
  306. clearAtlasList() ;
  307. }
  309. BOOL LLSpatialGroup::hasAtlas(LLTextureAtlas* atlasp)
  310. {
  311. S8 type = atlasp->getComponents() - 1 ;
  312. for(std::list<LLTextureAtlas*>::iterator iter = mAtlasList[type].begin(); iter != mAtlasList[type].end() ; ++iter)
  313. {
  314. if(atlasp == *iter)
  315. {
  316. return TRUE ;
  317. }
  318. }
  319. return FALSE ;
  320. }
  322. void LLSpatialGroup::addAtlas(LLTextureAtlas* atlasp, S8 recursive_level) 
  323. {
  324. if(!hasAtlas(atlasp))
  325. {
  326. mAtlasList[atlasp->getComponents() - 1].push_back(atlasp) ;
  327. atlasp->addSpatialGroup(this) ;
  328. }
  330. --recursive_level;
  331. if(recursive_level)//levels propagating up.
  332. {
  333. LLSpatialGroup* parent = getParent() ;
  334. if(parent)
  335. {
  336. parent->addAtlas(atlasp, recursive_level) ;
  337. }
  338. }
  339. }
  341. void LLSpatialGroup::removeAtlas(LLTextureAtlas* atlasp, BOOL remove_group, S8 recursive_level) 
  342. {
  343. mAtlasList[atlasp->getComponents() - 1].remove(atlasp) ;
  344. if(remove_group)
  345. {
  346. atlasp->removeSpatialGroup(this) ;
  347. }
  349. --recursive_level;
  350. if(recursive_level)//levels propagating up.
  351. {
  352. LLSpatialGroup* parent = getParent() ;
  353. if(parent)
  354. {
  355. parent->removeAtlas(atlasp, recursive_level) ;
  356. }
  357. }
  358. }
  360. void LLSpatialGroup::clearAtlasList() 
  361. {
  362. std::list<LLTextureAtlas*>::iterator iter ;
  363. for(S8 i = 0 ; i < 4 ; i++)
  364. {
  365. if(mAtlasList[i].size() > 0)
  366. {
  367. for(iter = mAtlasList[i].begin(); iter != mAtlasList[i].end() ; ++iter)
  368. {
  369. ((LLTextureAtlas*)*iter)->removeSpatialGroup(this) ;
  370. }
  371. mAtlasList[i].clear() ;
  372. }
  373. }
  374. }
  376. LLTextureAtlas* LLSpatialGroup::getAtlas(S8 ncomponents, S8 to_be_reserved, S8 recursive_level)
  377. {
  378. S8 type = ncomponents - 1 ;
  379. if(mAtlasList[type].size() > 0)
  380. {
  381. for(std::list<LLTextureAtlas*>::iterator iter = mAtlasList[type].begin(); iter != mAtlasList[type].end() ; ++iter)
  382. {
  383. if(!((LLTextureAtlas*)*iter)->isFull(to_be_reserved))
  384. {
  385. return *iter ;
  386. }
  387. }
  388. }
  390. --recursive_level;
  391. if(recursive_level)
  392. {
  393. LLSpatialGroup* parent = getParent() ;
  394. if(parent)
  395. {
  396. return parent->getAtlas(ncomponents, to_be_reserved, recursive_level) ;
  397. }
  398. }
  399. return NULL ;
  400. }
  402. void LLSpatialGroup::setCurUpdatingSlot(LLTextureAtlasSlot* slotp) 
  403. { 
  404. mCurUpdatingSlotp = slotp;
  406. //if(!hasAtlas(mCurUpdatingSlotp->getAtlas()))
  407. //{
  408. // addAtlas(mCurUpdatingSlotp->getAtlas()) ;
  409. //}
  410. }
  412. LLTextureAtlasSlot* LLSpatialGroup::getCurUpdatingSlot(LLViewerTexture* imagep, S8 recursive_level) 
  413. { 
  414. if(gFrameCount && mCurUpdatingTime == gFrameCount && mCurUpdatingTexture == imagep)
  415. {
  416. return mCurUpdatingSlotp ;
  417. }
  419. //--recursive_level ;
  420. //if(recursive_level)
  421. //{
  422. // LLSpatialGroup* parent = getParent() ;
  423. // if(parent)
  424. // {
  425. // return parent->getCurUpdatingSlot(imagep, recursive_level) ;
  426. // }
  427. //}
  428. return NULL ;
  429. }
  431. void LLSpatialGroup::clearDrawMap()
  432. {
  433. mDrawMap.clear();
  434. }
  436. BOOL LLSpatialGroup::isRecentlyVisible() const
  437. {
  438. return (LLDrawable::getCurrentFrame() - mVisible[LLViewerCamera::sCurCameraID]) < LLDrawable::getMinVisFrameRange() ;
  439. }
  441. BOOL LLSpatialGroup::isVisible() const
  442. {
  443. return mVisible[LLViewerCamera::sCurCameraID] == LLDrawable::getCurrentFrame() ? TRUE : FALSE;
  444. }
  446. void LLSpatialGroup::setVisible()
  447. {
  448. mVisible[LLViewerCamera::sCurCameraID] = LLDrawable::getCurrentFrame();
  449. }
  451. void LLSpatialGroup::validate()
  452. {
  453. #if LL_OCTREE_PARANOIA_CHECK
  455. sg_assert(!isState(DIRTY));
  456. sg_assert(!isDead());
  458. LLVector3 myMin = mBounds[0] - mBounds[1];
  459. LLVector3 myMax = mBounds[0] + mBounds[1];
  461. validateDrawMap();
  463. for (element_iter i = getData().begin(); i != getData().end(); ++i)
  464. {
  465. LLDrawable* drawable = *i;
  466. sg_assert(drawable->getSpatialGroup() == this);
  467. if (drawable->getSpatialBridge())
  468. {
  469. sg_assert(drawable->getSpatialBridge() == mSpatialPartition->asBridge());
  470. }
  472. /*if (drawable->isSpatialBridge())
  473. {
  474. LLSpatialPartition* part = drawable->asPartition();
  475. if (!part)
  476. {
  477. llerrs << "Drawable reports it is a spatial bridge but not a partition." << llendl;
  478. }
  479. LLSpatialGroup* group = (LLSpatialGroup*) part->mOctree->getListener(0);
  480. group->validate();
  481. }*/
  482. }
  484. for (U32 i = 0; i < mOctreeNode->getChildCount(); ++i)
  485. {
  486. LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(i)->getListener(0);
  488. group->validate();
  490. //ensure all children are enclosed in this node
  491. LLVector3 center = group->mBounds[0];
  492. LLVector3 size = group->mBounds[1];
  494. LLVector3 min = center - size;
  495. LLVector3 max = center + size;
  497. for (U32 j = 0; j < 3; j++)
  498. {
  499. sg_assert(min.mV[j] >= myMin.mV[j]-0.02f);
  500. sg_assert(max.mV[j] <= myMax.mV[j]+0.02f);
  501. }
  502. }
  504. #endif
  505. }
  507. void LLSpatialGroup::checkStates()
  508. {
  509. #if LL_OCTREE_PARANOIA_CHECK
  510. LLOctreeStateCheck checker;
  511. checker.traverse(mOctreeNode);
  512. #endif
  513. }
  515. void validate_draw_info(LLDrawInfo& params)
  516. {
  517. #if LL_OCTREE_PARANOIA_CHECK
  518. if (params.mVertexBuffer.isNull())
  519. {
  520. llerrs << "Draw batch has no vertex buffer." << llendl;
  521. }
  523. //bad range
  524. if (params.mStart >= params.mEnd)
  525. {
  526. llerrs << "Draw batch has invalid range." << llendl;
  527. }
  529. if (params.mEnd >= (U32) params.mVertexBuffer->getNumVerts())
  530. {
  531. llerrs << "Draw batch has buffer overrun error." << llendl;
  532. }
  534. if (params.mOffset + params.mCount > (U32) params.mVertexBuffer->getNumIndices())
  535. {
  536. llerrs << "Draw batch has index buffer ovverrun error." << llendl;
  537. }
  539. //bad indices
  540. U16* indicesp = (U16*) params.mVertexBuffer->getIndicesPointer();
  541. if (indicesp)
  542. {
  543. for (U32 i = params.mOffset; i < params.mOffset+params.mCount; i++)
  544. {
  545. if (indicesp[i] < (U16)params.mStart)
  546. {
  547. llerrs << "Draw batch has vertex buffer index out of range error (index too low)." << llendl;
  548. }
  550. if (indicesp[i] > (U16)params.mEnd)
  551. {
  552. llerrs << "Draw batch has vertex buffer index out of range error (index too high)." << llendl;
  553. }
  554. }
  555. }
  556. #endif
  557. }
  559. void LLSpatialGroup::validateDrawMap()
  560. {
  561. #if LL_OCTREE_PARANOIA_CHECK
  562. for (draw_map_t::iterator i = mDrawMap.begin(); i != mDrawMap.end(); ++i)
  563. {
  564. LLSpatialGroup::drawmap_elem_t& draw_vec = i->second;
  565. for (drawmap_elem_t::iterator j = draw_vec.begin(); j != draw_vec.end(); ++j)
  566. {
  567. LLDrawInfo& params = **j;
  569. validate_draw_info(params);
  570. }
  571. }
  572. #endif
  573. }
  575. BOOL LLSpatialGroup::updateInGroup(LLDrawable *drawablep, BOOL immediate)
  576. {
  577. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  579. drawablep->updateSpatialExtents();
  580. validate_drawable(drawablep);
  582. OctreeNode* parent = mOctreeNode->getOctParent();
  584. if (mOctreeNode->isInside(drawablep->getPositionGroup()) && 
  585. (mOctreeNode->contains(drawablep) ||
  586.  (drawablep->getBinRadius() > mOctreeNode->getSize().mdV[0] &&
  587. parent && parent->getElementCount() >= LL_OCTREE_MAX_CAPACITY)))
  588. {
  589. unbound();
  590. setState(OBJECT_DIRTY);
  591. //setState(GEOM_DIRTY);
  592. validate_drawable(drawablep);
  593. return TRUE;
  594. }
  596. return FALSE;
  597. }
  600. BOOL LLSpatialGroup::addObject(LLDrawable *drawablep, BOOL add_all, BOOL from_octree)
  601. {
  602. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  603. if (!from_octree)
  604. {
  605. mOctreeNode->insert(drawablep);
  606. }
  607. else
  608. {
  609. drawablep->setSpatialGroup(this);
  610. validate_drawable(drawablep);
  611. setState(OBJECT_DIRTY | GEOM_DIRTY);
  612. setOcclusionState(LLSpatialGroup::DISCARD_QUERY, LLSpatialGroup::STATE_MODE_ALL_CAMERAS);
  613. gPipeline.markRebuild(this, TRUE);
  614. if (drawablep->isSpatialBridge())
  615. {
  616. mBridgeList.push_back((LLSpatialBridge*) drawablep);
  617. }
  618. if (drawablep->getRadius() > 1.f)
  619. {
  620. setState(IMAGE_DIRTY);
  621. }
  622. }
  624. return TRUE;
  625. }
  627. void LLSpatialGroup::rebuildGeom()
  628. {
  629. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  630. if (!isDead())
  631. {
  632. mSpatialPartition->rebuildGeom(this);
  633. }
  634. }
  636. void LLSpatialGroup::rebuildMesh()
  637. {
  638. if (!isDead())
  639. {
  640. mSpatialPartition->rebuildMesh(this);
  641. }
  642. }
  644. static LLFastTimer::DeclareTimer FTM_REBUILD_VBO("VBO Rebuilt");
  646. void LLSpatialPartition::rebuildGeom(LLSpatialGroup* group)
  647. {
  648. /*if (!gPipeline.hasRenderType(mDrawableType))
  649. {
  650. return;
  651. }*/
  653. if (group->isDead() || !group->isState(LLSpatialGroup::GEOM_DIRTY))
  654. {
  655. /*if (!group->isState(LLSpatialGroup::GEOM_DIRTY) && mRenderByGroup)
  656. {
  657. llerrs << "WTF?" << llendl;
  658. }*/
  659. return;
  660. }
  662. if (group->changeLOD())
  663. {
  664. group->mLastUpdateDistance = group->mDistance;
  665. group->mLastUpdateViewAngle = group->mViewAngle;
  666. }
  668. LLFastTimer ftm(FTM_REBUILD_VBO);
  670. group->clearDrawMap();
  672. //get geometry count
  673. U32 index_count = 0;
  674. U32 vertex_count = 0;
  676. addGeometryCount(group, vertex_count, index_count);
  678. if (vertex_count > 0 && index_count > 0)
  679. { //create vertex buffer containing volume geometry for this node
  680. group->mBuilt = 1.f;
  681. if (group->mVertexBuffer.isNull() || (group->mBufferUsage != group->mVertexBuffer->getUsage() && LLVertexBuffer::sEnableVBOs))
  682. {
  683. group->mVertexBuffer = createVertexBuffer(mVertexDataMask, group->mBufferUsage);
  684. group->mVertexBuffer->allocateBuffer(vertex_count, index_count, true);
  685. stop_glerror();
  686. }
  687. else
  688. {
  689. group->mVertexBuffer->resizeBuffer(vertex_count, index_count);
  690. stop_glerror();
  691. }
  693. getGeometry(group);
  694. }
  695. else
  696. {
  697. group->mVertexBuffer = NULL;
  698. group->mBufferMap.clear();
  699. }
  701. group->mLastUpdateTime = gFrameTimeSeconds;
  702. group->clearState(LLSpatialGroup::GEOM_DIRTY);
  703. }
  706. void LLSpatialPartition::rebuildMesh(LLSpatialGroup* group)
  707. {
  709. }
  711. BOOL LLSpatialGroup::boundObjects(BOOL empty, LLVector3& minOut, LLVector3& maxOut)
  712. {
  713. const OctreeNode* node = mOctreeNode;
  715. if (node->getData().empty())
  716. { //don't do anything if there are no objects
  717. if (empty && mOctreeNode->getParent())
  718. { //only root is allowed to be empty
  719. OCT_ERRS << "Empty leaf found in octree." << llendl;
  720. }
  721. return FALSE;
  722. }
  724. LLVector3& newMin = mObjectExtents[0];
  725. LLVector3& newMax = mObjectExtents[1];
  727. if (isState(OBJECT_DIRTY))
  728. { //calculate new bounding box
  729. clearState(OBJECT_DIRTY);
  731. //initialize bounding box to first element
  732. OctreeNode::const_element_iter i = node->getData().begin();
  733. LLDrawable* drawablep = *i;
  734. const LLVector3* minMax = drawablep->getSpatialExtents();
  736. newMin.setVec(minMax[0]);
  737. newMax.setVec(minMax[1]);
  739. for (++i; i != node->getData().end(); ++i)
  740. {
  741. drawablep = *i;
  742. minMax = drawablep->getSpatialExtents();
  744. update_min_max(newMin, newMax, minMax[0]);
  745. update_min_max(newMin, newMax, minMax[1]);
  747. //bin up the object
  748. /*for (U32 i = 0; i < 3; i++)
  749. {
  750. if (minMax[0].mV[i] < newMin.mV[i])
  751. {
  752. newMin.mV[i] = minMax[0].mV[i];
  753. }
  754. if (minMax[1].mV[i] > newMax.mV[i])
  755. {
  756. newMax.mV[i] = minMax[1].mV[i];
  757. }
  758. }*/
  759. }
  761. mObjectBounds[0] = (newMin + newMax) * 0.5f;
  762. mObjectBounds[1] = (newMax - newMin) * 0.5f;
  763. }
  765. if (empty)
  766. {
  767. minOut = newMin;
  768. maxOut = newMax;
  769. }
  770. else
  771. {
  772. for (U32 i = 0; i < 3; i++)
  773. {
  774. if (newMin.mV[i] < minOut.mV[i])
  775. {
  776. minOut.mV[i] = newMin.mV[i];
  777. }
  778. if (newMax.mV[i] > maxOut.mV[i])
  779. {
  780. maxOut.mV[i] = newMax.mV[i];
  781. }
  782. }
  783. }
  785. return TRUE;
  786. }
  788. void LLSpatialGroup::unbound()
  789. {
  790. if (isState(DIRTY))
  791. {
  792. return;
  793. }
  795. setState(DIRTY);
  797. //all the parent nodes need to rebound this child
  798. if (mOctreeNode)
  799. {
  800. OctreeNode* parent = (OctreeNode*) mOctreeNode->getParent();
  801. while (parent != NULL)
  802. {
  803. LLSpatialGroup* group = (LLSpatialGroup*) parent->getListener(0);
  804. if (group->isState(DIRTY))
  805. {
  806. return;
  807. }
  809. group->setState(DIRTY);
  810. parent = (OctreeNode*) parent->getParent();
  811. }
  812. }
  813. }
  815. LLSpatialGroup* LLSpatialGroup::getParent()
  816. {
  817. if (isDead())
  818. {
  819. return NULL;
  820. }
  822. if(!mOctreeNode)
  823. {
  824. return NULL;
  825. }
  826. OctreeNode* parent = mOctreeNode->getOctParent();
  828. if (parent)
  829. {
  830. return (LLSpatialGroup*) parent->getListener(0);
  831. }
  833. return NULL;
  834. }
  836. BOOL LLSpatialGroup::removeObject(LLDrawable *drawablep, BOOL from_octree)
  837. {
  838. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  839. unbound();
  840. if (mOctreeNode && !from_octree)
  841. {
  842. if (!mOctreeNode->remove(drawablep))
  843. {
  844. OCT_ERRS << "Could not remove drawable from spatial group" << llendl;
  845. }
  846. }
  847. else
  848. {
  849. drawablep->setSpatialGroup(NULL);
  850. setState(GEOM_DIRTY);
  851. gPipeline.markRebuild(this, TRUE);
  853. if (drawablep->isSpatialBridge())
  854. {
  855. for (bridge_list_t::iterator i = mBridgeList.begin(); i != mBridgeList.end(); ++i)
  856. {
  857. if (*i == drawablep)
  858. {
  859. mBridgeList.erase(i);
  860. break;
  861. }
  862. }
  863. }
  865. if (getElementCount() == 0)
  866. { //delete draw map on last element removal since a rebuild might never happen
  867. clearDrawMap();
  868. }
  869. }
  870. return TRUE;
  871. }
  873. void LLSpatialGroup::shift(const LLVector3 &offset)
  874. {
  875. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  876. LLVector3d offsetd(offset);
  877. mOctreeNode->setCenter(mOctreeNode->getCenter()+offsetd);
  878. mOctreeNode->updateMinMax();
  879. mBounds[0] += offset;
  880. mExtents[0] += offset;
  881. mExtents[1] += offset;
  882. mObjectBounds[0] += offset;
  883. mObjectExtents[0] += offset;
  884. mObjectExtents[1] += offset;
  886. //if (!mSpatialPartition->mRenderByGroup)
  887. {
  888. setState(GEOM_DIRTY);
  889. gPipeline.markRebuild(this, TRUE);
  890. }
  892. if (mOcclusionVerts)
  893. {
  894. for (U32 i = 0; i < 8; i++)
  895. {
  896. F32* v = mOcclusionVerts+i*3;
  897. v[0] += offset.mV[0];
  898. v[1] += offset.mV[1];
  899. v[2] += offset.mV[2];
  900. }
  901. }
  902. }
  904. class LLSpatialSetState : public LLSpatialGroup::OctreeTraveler
  905. {
  906. public:
  907. U32 mState;
  908. LLSpatialSetState(U32 state) : mState(state) { }
  909. virtual void visit(const LLSpatialGroup::OctreeNode* branch) { ((LLSpatialGroup*) branch->getListener(0))->setState(mState); }
  910. };
  912. class LLSpatialSetStateDiff : public LLSpatialSetState
  913. {
  914. public:
  915. LLSpatialSetStateDiff(U32 state) : LLSpatialSetState(state) { }
  917. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  918. {
  919. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  921. if (!group->isState(mState))
  922. {
  923. LLSpatialGroup::OctreeTraveler::traverse(n);
  924. }
  925. }
  926. };
  928. void LLSpatialGroup::setState(U32 state) 
  929. { 
  930. mState |= state; 
  932. if (state > LLSpatialGroup::STATE_MASK)
  933. {
  934. llerrs << "WTF?" << llendl;
  935. }
  936. }
  938. void LLSpatialGroup::setState(U32 state, S32 mode) 
  939. {
  940. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  942. if (state > LLSpatialGroup::STATE_MASK)
  943. {
  944. llerrs << "WTF?" << llendl;
  945. }
  947. if (mode > STATE_MODE_SINGLE)
  948. {
  949. if (mode == STATE_MODE_DIFF)
  950. {
  951. LLSpatialSetStateDiff setter(state);
  952. setter.traverse(mOctreeNode);
  953. }
  954. else
  955. {
  956. LLSpatialSetState setter(state);
  957. setter.traverse(mOctreeNode);
  958. }
  959. }
  960. else
  961. {
  962. mState |= state;
  963. }
  964. }
  966. class LLSpatialClearState : public LLSpatialGroup::OctreeTraveler
  967. {
  968. public:
  969. U32 mState;
  970. LLSpatialClearState(U32 state) : mState(state) { }
  971. virtual void visit(const LLSpatialGroup::OctreeNode* branch) { ((LLSpatialGroup*) branch->getListener(0))->clearState(mState); }
  972. };
  974. class LLSpatialClearStateDiff : public LLSpatialClearState
  975. {
  976. public:
  977. LLSpatialClearStateDiff(U32 state) : LLSpatialClearState(state) { }
  979. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  980. {
  981. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  983. if (group->isState(mState))
  984. {
  985. LLSpatialGroup::OctreeTraveler::traverse(n);
  986. }
  987. }
  988. };
  990. void LLSpatialGroup::clearState(U32 state)
  991. {
  992. if (state > LLSpatialGroup::STATE_MASK)
  993. {
  994. llerrs << "WTF?" << llendl;
  995. }
  997. mState &= ~state; 
  998. }
  1000. void LLSpatialGroup::clearState(U32 state, S32 mode)
  1001. {
  1002. if (state > LLSpatialGroup::STATE_MASK)
  1003. {
  1004. llerrs << "WTF?" << llendl;
  1005. }
  1007. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1009. if (mode > STATE_MODE_SINGLE)
  1010. {
  1011. if (mode == STATE_MODE_DIFF)
  1012. {
  1013. LLSpatialClearStateDiff clearer(state);
  1014. clearer.traverse(mOctreeNode);
  1015. }
  1016. else
  1017. {
  1018. LLSpatialClearState clearer(state);
  1019. clearer.traverse(mOctreeNode);
  1020. }
  1021. }
  1022. else
  1023. {
  1024. mState &= ~state;
  1025. }
  1026. }
  1028. BOOL LLSpatialGroup::isState(U32 state) const
  1029. { 
  1030. if (state > LLSpatialGroup::STATE_MASK)
  1031. {
  1032. llerrs << "WTF?" << llendl;
  1033. }
  1035. return mState & state ? TRUE : FALSE; 
  1036. }
  1038. //=====================================
  1039. // Occlusion State Set/Clear
  1040. //=====================================
  1041. class LLSpatialSetOcclusionState : public LLSpatialGroup::OctreeTraveler
  1042. {
  1043. public:
  1044. U32 mState;
  1045. LLSpatialSetOcclusionState(U32 state) : mState(state) { }
  1046. virtual void visit(const LLSpatialGroup::OctreeNode* branch) { ((LLSpatialGroup*) branch->getListener(0))->setOcclusionState(mState); }
  1047. };
  1049. class LLSpatialSetOcclusionStateDiff : public LLSpatialSetOcclusionState
  1050. {
  1051. public:
  1052. LLSpatialSetOcclusionStateDiff(U32 state) : LLSpatialSetOcclusionState(state) { }
  1054. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  1055. {
  1056. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  1058. if (!group->isOcclusionState(mState))
  1059. {
  1060. LLSpatialGroup::OctreeTraveler::traverse(n);
  1061. }
  1062. }
  1063. };
  1066. void LLSpatialGroup::setOcclusionState(U32 state, S32 mode) 
  1067. {
  1068. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1070. if (mode > STATE_MODE_SINGLE)
  1071. {
  1072. if (mode == STATE_MODE_DIFF)
  1073. {
  1074. LLSpatialSetOcclusionStateDiff setter(state);
  1075. setter.traverse(mOctreeNode);
  1076. }
  1077. else if (mode == STATE_MODE_BRANCH)
  1078. {
  1079. LLSpatialSetOcclusionState setter(state);
  1080. setter.traverse(mOctreeNode);
  1081. }
  1082. else
  1083. {
  1084. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  1085. {
  1086. mOcclusionState[i] |= state;
  1087. }
  1088. }
  1089. }
  1090. else
  1091. {
  1092. mOcclusionState[LLViewerCamera::sCurCameraID] |= state;
  1093. }
  1094. }
  1096. class LLSpatialClearOcclusionState : public LLSpatialGroup::OctreeTraveler
  1097. {
  1098. public:
  1099. U32 mState;
  1101. LLSpatialClearOcclusionState(U32 state) : mState(state) { }
  1102. virtual void visit(const LLSpatialGroup::OctreeNode* branch) { ((LLSpatialGroup*) branch->getListener(0))->clearOcclusionState(mState); }
  1103. };
  1105. class LLSpatialClearOcclusionStateDiff : public LLSpatialClearOcclusionState
  1106. {
  1107. public:
  1108. LLSpatialClearOcclusionStateDiff(U32 state) : LLSpatialClearOcclusionState(state) { }
  1110. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  1111. {
  1112. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  1114. if (group->isOcclusionState(mState))
  1115. {
  1116. LLSpatialGroup::OctreeTraveler::traverse(n);
  1117. }
  1118. }
  1119. };
  1121. void LLSpatialGroup::clearOcclusionState(U32 state, S32 mode)
  1122. {
  1123. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1125. if (mode > STATE_MODE_SINGLE)
  1126. {
  1127. if (mode == STATE_MODE_DIFF)
  1128. {
  1129. LLSpatialClearOcclusionStateDiff clearer(state);
  1130. clearer.traverse(mOctreeNode);
  1131. }
  1132. else if (mode == STATE_MODE_BRANCH)
  1133. {
  1134. LLSpatialClearOcclusionState clearer(state);
  1135. clearer.traverse(mOctreeNode);
  1136. }
  1137. else
  1138. {
  1139. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  1140. {
  1141. mOcclusionState[i] &= ~state;
  1142. }
  1143. }
  1144. }
  1145. else
  1146. {
  1147. mOcclusionState[LLViewerCamera::sCurCameraID] &= ~state;
  1148. }
  1149. }
  1150. //======================================
  1151. // Octree Listener Implementation
  1152. //======================================
  1154. LLSpatialGroup::LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part) :
  1155. mState(0),
  1156. mBuilt(0.f),
  1157. mOctreeNode(node),
  1158. mSpatialPartition(part),
  1159. mVertexBuffer(NULL), 
  1160. mBufferUsage(GL_STATIC_DRAW_ARB),
  1161. mDistance(0.f),
  1162. mDepth(0.f),
  1163. mLastUpdateDistance(-1.f), 
  1164. mLastUpdateTime(gFrameTimeSeconds),
  1165. mViewAngle(0.f),
  1166. mLastUpdateViewAngle(-1.f),
  1167. mAtlasList(4),
  1168. mCurUpdatingTime(0),
  1169. mCurUpdatingSlotp(NULL),
  1170. mCurUpdatingTexture (NULL)
  1171. {
  1172. sNodeCount++;
  1173. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1175. sg_assert(mOctreeNode->getListenerCount() == 0);
  1176. mOctreeNode->addListener(this);
  1177. setState(SG_INITIAL_STATE_MASK);
  1178. gPipeline.markRebuild(this, TRUE);
  1180. mBounds[0] = LLVector3(node->getCenter());
  1181. mBounds[1] = LLVector3(node->getSize());
  1183. part->mLODSeed = (part->mLODSeed+1)%part->mLODPeriod;
  1184. mLODHash = part->mLODSeed;
  1186. OctreeNode* oct_parent = node->getOctParent();
  1188. LLSpatialGroup* parent = oct_parent ? (LLSpatialGroup*) oct_parent->getListener(0) : NULL;
  1190. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  1191. {
  1192. mOcclusionQuery[i] = 0;
  1193. mOcclusionState[i] = parent ? SG_STATE_INHERIT_MASK & parent->mOcclusionState[i] : 0;
  1194. mVisible[i] = 0;
  1195. }
  1197. mOcclusionVerts = NULL;
  1199. mRadius = 1;
  1200. mPixelArea = 1024.f;
  1201. }
  1203. void LLSpatialGroup::updateDistance(LLCamera &camera)
  1204. {
  1205. if (LLViewerCamera::sCurCameraID != LLViewerCamera::CAMERA_WORLD)
  1206. {
  1207. llerrs << "WTF?" << llendl;
  1208. }
  1210. #if !LL_RELEASE_FOR_DOWNLOAD
  1211. if (isState(LLSpatialGroup::OBJECT_DIRTY))
  1212. {
  1213. llerrs << "Spatial group dirty on distance update." << llendl;
  1214. }
  1215. #endif
  1216. if (!getData().empty())
  1217. {
  1218. mRadius = mSpatialPartition->mRenderByGroup ? mObjectBounds[1].magVec() :
  1219. (F32) mOctreeNode->getSize().magVec();
  1220. mDistance = mSpatialPartition->calcDistance(this, camera);
  1221. mPixelArea = mSpatialPartition->calcPixelArea(this, camera);
  1222. }
  1223. }
  1225. F32 LLSpatialPartition::calcDistance(LLSpatialGroup* group, LLCamera& camera)
  1226. {
  1227. LLVector3 eye = group->mObjectBounds[0] - camera.getOrigin();
  1229. F32 dist = 0.f;
  1231. if (group->mDrawMap.find(LLRenderPass::PASS_ALPHA) != group->mDrawMap.end())
  1232. {
  1233. LLVector3 v = eye;
  1234. dist = eye.normVec();
  1236. if (!group->isState(LLSpatialGroup::ALPHA_DIRTY))
  1237. {
  1238. if (!group->mSpatialPartition->isBridge())
  1239. {
  1240. LLVector3 view_angle = LLVector3(eye * LLVector3(1,0,0),
  1241.  eye * LLVector3(0,1,0),
  1242.  eye * LLVector3(0,0,1));
  1244. if ((view_angle-group->mLastUpdateViewAngle).magVec() > 0.64f)
  1245. {
  1246. group->mViewAngle = view_angle;
  1247. group->mLastUpdateViewAngle = view_angle;
  1248. //for occasional alpha sorting within the group
  1249. //NOTE: If there is a trivial way to detect that alpha sorting here would not change the render order,
  1250. //not setting this node to dirty would be a very good thing
  1251. group->setState(LLSpatialGroup::ALPHA_DIRTY);
  1252. gPipeline.markRebuild(group, FALSE);
  1253. }
  1254. }
  1255. }
  1257. //calculate depth of node for alpha sorting
  1259. LLVector3 at = camera.getAtAxis();
  1261. //front of bounding box
  1262. for (U32 i = 0; i < 3; i++)
  1263. {
  1264. v.mV[i] -= group->mObjectBounds[1].mV[i]*0.25f * at.mV[i];
  1265. }
  1267. group->mDepth = v * at;
  1268. }
  1269. else
  1270. {
  1271. dist = eye.magVec();
  1272. }
  1274. if (dist < 16.f)
  1275. {
  1276. dist /= 16.f;
  1277. dist *= dist;
  1278. dist *= 16.f;
  1279. }
  1281. return dist;
  1282. }
  1284. F32 LLSpatialPartition::calcPixelArea(LLSpatialGroup* group, LLCamera& camera)
  1285. {
  1286. return LLPipeline::calcPixelArea(group->mObjectBounds[0], group->mObjectBounds[1], camera);
  1287. }
  1289. F32 LLSpatialGroup::getUpdateUrgency() const
  1290. {
  1291. if (!isVisible())
  1292. {
  1293. return 0.f;
  1294. }
  1295. else
  1296. {
  1297. return (gFrameTimeSeconds - mLastUpdateTime+4.f)/mDistance;
  1298. }
  1299. }
  1301. BOOL LLSpatialGroup::needsUpdate()
  1302. {
  1303. return (LLDrawable::getCurrentFrame()%mSpatialPartition->mLODPeriod == mLODHash) ? TRUE : FALSE;
  1304. }
  1306. BOOL LLSpatialGroup::changeLOD()
  1307. {
  1308. if (isState(ALPHA_DIRTY))
  1309. { ///an alpha sort is going to happen, update distance and LOD
  1310. return TRUE;
  1311. }
  1313. if (mSpatialPartition->mSlopRatio > 0.f)
  1314. {
  1315. F32 ratio = (mDistance - mLastUpdateDistance)/(llmax(mLastUpdateDistance, mRadius));
  1317. if (fabsf(ratio) >= mSpatialPartition->mSlopRatio)
  1318. {
  1319. return TRUE;
  1320. }
  1322. if (mDistance > mRadius)
  1323. {
  1324. return FALSE;
  1325. }
  1326. }
  1328. if (needsUpdate())
  1329. {
  1330. return TRUE;
  1331. }
  1333. return FALSE;
  1334. }
  1336. void LLSpatialGroup::handleInsertion(const TreeNode* node, LLDrawable* drawablep)
  1337. {
  1338. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1339. addObject(drawablep, FALSE, TRUE);
  1340. unbound();
  1341. setState(OBJECT_DIRTY);
  1342. }
  1344. void LLSpatialGroup::handleRemoval(const TreeNode* node, LLDrawable* drawable)
  1345. {
  1346. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1347. removeObject(drawable, TRUE);
  1348. setState(OBJECT_DIRTY);
  1349. }
  1351. void LLSpatialGroup::handleDestruction(const TreeNode* node)
  1352. {
  1353. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1354. setState(DEAD);
  1356. for (element_iter i = getData().begin(); i != getData().end(); ++i)
  1357. {
  1358. LLDrawable* drawable = *i;
  1359. if (drawable->getSpatialGroup() == this)
  1360. {
  1361. drawable->setSpatialGroup(NULL);
  1362. }
  1363. }
  1365. clearDrawMap();
  1366. mVertexBuffer = NULL;
  1367. mBufferMap.clear();
  1368. sZombieGroups++;
  1369. mOctreeNode = NULL;
  1370. }
  1372. void LLSpatialGroup::handleStateChange(const TreeNode* node)
  1373. {
  1374. //drop bounding box upon state change
  1375. if (mOctreeNode != node)
  1376. {
  1377. mOctreeNode = (OctreeNode*) node;
  1378. }
  1379. unbound();
  1380. }
  1382. void LLSpatialGroup::handleChildAddition(const OctreeNode* parent, OctreeNode* child) 
  1383. {
  1384. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1385. if (child->getListenerCount() == 0)
  1386. {
  1387. new LLSpatialGroup(child, mSpatialPartition);
  1388. }
  1389. else
  1390. {
  1391. OCT_ERRS << "LLSpatialGroup redundancy detected." << llendl;
  1392. }
  1394. unbound();
  1396. assert_states_valid(this);
  1397. }
  1399. void LLSpatialGroup::handleChildRemoval(const OctreeNode* parent, const OctreeNode* child)
  1400. {
  1401. unbound();
  1402. }
  1404. void LLSpatialGroup::destroyGL() 
  1405. {
  1406. setState(LLSpatialGroup::GEOM_DIRTY | LLSpatialGroup::IMAGE_DIRTY);
  1407. gPipeline.markRebuild(this, TRUE);
  1409. mLastUpdateTime = gFrameTimeSeconds;
  1410. mVertexBuffer = NULL;
  1411. mBufferMap.clear();
  1413. clearDrawMap();
  1415. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  1416. {
  1417. if (mOcclusionQuery[i])
  1418. {
  1419. sQueryPool.release(mOcclusionQuery[i]);
  1420. mOcclusionQuery[i] = 0;
  1421. }
  1422. }
  1424. delete [] mOcclusionVerts;
  1425. mOcclusionVerts = NULL;
  1427. for (LLSpatialGroup::element_iter i = getData().begin(); i != getData().end(); ++i)
  1428. {
  1429. LLDrawable* drawable = *i;
  1430. for (S32 j = 0; j < drawable->getNumFaces(); j++)
  1431. {
  1432. LLFace* facep = drawable->getFace(j);
  1433. facep->mVertexBuffer = NULL;
  1434. facep->mLastVertexBuffer = NULL;
  1435. }
  1436. }
  1437. }
  1439. BOOL LLSpatialGroup::rebound()
  1440. {
  1441. if (!isState(DIRTY))
  1442. { //return TRUE if we're not empty
  1443. return TRUE;
  1444. }
  1446. if (mOctreeNode->getChildCount() == 1 && mOctreeNode->getElementCount() == 0)
  1447. {
  1448. LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(0)->getListener(0);
  1449. group->rebound();
  1451. //copy single child's bounding box
  1452. mBounds[0] = group->mBounds[0];
  1453. mBounds[1] = group->mBounds[1];
  1454. mExtents[0] = group->mExtents[0];
  1455. mExtents[1] = group->mExtents[1];
  1457. group->setState(SKIP_FRUSTUM_CHECK);
  1458. }
  1459. else if (mOctreeNode->isLeaf())
  1460. { //copy object bounding box if this is a leaf
  1461. boundObjects(TRUE, mExtents[0], mExtents[1]);
  1462. mBounds[0] = mObjectBounds[0];
  1463. mBounds[1] = mObjectBounds[1];
  1464. }
  1465. else
  1466. {
  1467. LLVector3& newMin = mExtents[0];
  1468. LLVector3& newMax = mExtents[1];
  1469. LLSpatialGroup* group = (LLSpatialGroup*) mOctreeNode->getChild(0)->getListener(0);
  1470. group->clearState(SKIP_FRUSTUM_CHECK);
  1471. group->rebound();
  1472. //initialize to first child
  1473. newMin = group->mExtents[0];
  1474. newMax = group->mExtents[1];
  1476. //first, rebound children
  1477. for (U32 i = 1; i < mOctreeNode->getChildCount(); i++)
  1478. {
  1479. group = (LLSpatialGroup*) mOctreeNode->getChild(i)->getListener(0);
  1480. group->clearState(SKIP_FRUSTUM_CHECK);
  1481. group->rebound();
  1482. const LLVector3& max = group->mExtents[1];
  1483. const LLVector3& min = group->mExtents[0];
  1485. for (U32 j = 0; j < 3; j++)
  1486. {
  1487. if (max.mV[j] > newMax.mV[j])
  1488. {
  1489. newMax.mV[j] = max.mV[j];
  1490. }
  1491. if (min.mV[j] < newMin.mV[j])
  1492. {
  1493. newMin.mV[j] = min.mV[j];
  1494. }
  1495. }
  1496. }
  1498. boundObjects(FALSE, newMin, newMax);
  1500. mBounds[0] = (newMin + newMax)*0.5f;
  1501. mBounds[1] = (newMax - newMin)*0.5f;
  1502. }
  1504. setState(OCCLUSION_DIRTY);
  1506. clearState(DIRTY);
  1508. return TRUE;
  1509. }
  1511. static LLFastTimer::DeclareTimer FTM_OCCLUSION_READBACK("Readback Occlusion");
  1512. void LLSpatialGroup::checkOcclusion()
  1513. {
  1514. if (LLPipeline::sUseOcclusion > 1)
  1515. {
  1516. LLSpatialGroup* parent = getParent();
  1517. if (parent && parent->isOcclusionState(LLSpatialGroup::OCCLUDED))
  1518. { //if the parent has been marked as occluded, the child is implicitly occluded
  1519. clearOcclusionState(QUERY_PENDING | DISCARD_QUERY);
  1520. }
  1521. else if (isOcclusionState(QUERY_PENDING))
  1522. { //otherwise, if a query is pending, read it back
  1523. LLFastTimer t(FTM_OCCLUSION_READBACK);
  1524. GLuint res = 1;
  1525. if (!isOcclusionState(DISCARD_QUERY) && mOcclusionQuery[LLViewerCamera::sCurCameraID])
  1526. {
  1527. glGetQueryObjectuivARB(mOcclusionQuery[LLViewerCamera::sCurCameraID], GL_QUERY_RESULT_ARB, &res);
  1528. }
  1530. if (isOcclusionState(DISCARD_QUERY))
  1531. {
  1532. res = 2;
  1533. }
  1535. if (res > 0)
  1536. {
  1537. assert_states_valid(this);
  1538. clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
  1539. assert_states_valid(this);
  1540. }
  1541. else
  1542. {
  1543. assert_states_valid(this);
  1544. setOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
  1545. assert_states_valid(this);
  1546. }
  1548. clearOcclusionState(QUERY_PENDING | DISCARD_QUERY);
  1549. }
  1550. else if (mSpatialPartition->isOcclusionEnabled() && isOcclusionState(LLSpatialGroup::OCCLUDED))
  1551. { //check occlusion has been issued for occluded node that has not had a query issued
  1552. assert_states_valid(this);
  1553. clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
  1554. assert_states_valid(this);
  1555. }
  1556. }
  1557. }
  1559. void LLSpatialGroup::doOcclusion(LLCamera* camera)
  1560. {
  1561. if (mSpatialPartition->isOcclusionEnabled() && LLPipeline::sUseOcclusion > 1)
  1562. {
  1563. if (earlyFail(camera, this))
  1564. {
  1565. setOcclusionState(LLSpatialGroup::DISCARD_QUERY);
  1566. assert_states_valid(this);
  1567. clearOcclusionState(LLSpatialGroup::OCCLUDED, LLSpatialGroup::STATE_MODE_DIFF);
  1568. assert_states_valid(this);
  1569. }
  1570. else
  1571. {
  1572. {
  1573. LLFastTimer t(FTM_RENDER_OCCLUSION);
  1575. if (!mOcclusionQuery[LLViewerCamera::sCurCameraID])
  1576. {
  1577. mOcclusionQuery[LLViewerCamera::sCurCameraID] = sQueryPool.allocate();
  1578. }
  1580. if (!mOcclusionVerts || isState(LLSpatialGroup::OCCLUSION_DIRTY))
  1581. {
  1582. buildOcclusion();
  1583. }
  1585. glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mOcclusionQuery[LLViewerCamera::sCurCameraID]);
  1586. glVertexPointer(3, GL_FLOAT, 0, mOcclusionVerts);
  1587. if (camera->getOrigin().isExactlyZero())
  1588. { //origin is invalid, draw entire box
  1589. glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
  1590. GL_UNSIGNED_BYTE, sOcclusionIndices);
  1591. glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
  1592. GL_UNSIGNED_BYTE, sOcclusionIndices+b111*8);
  1593. }
  1594. else
  1595. {
  1596. glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8,
  1597. GL_UNSIGNED_BYTE, get_box_fan_indices(camera, mBounds[0]));
  1598. }
  1599. glEndQueryARB(GL_SAMPLES_PASSED_ARB);
  1600. }
  1602. setOcclusionState(LLSpatialGroup::QUERY_PENDING);
  1603. clearOcclusionState(LLSpatialGroup::DISCARD_QUERY);
  1604. }
  1605. }
  1606. }
  1608. //==============================================
  1610. LLSpatialPartition::LLSpatialPartition(U32 data_mask, BOOL render_by_group, U32 buffer_usage)
  1611. : mRenderByGroup(render_by_group)
  1612. {
  1613. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1614. mOcclusionEnabled = TRUE;
  1615. mDrawableType = 0;
  1616. mPartitionType = LLViewerRegion::PARTITION_NONE;
  1617. mLODSeed = 0;
  1618. mLODPeriod = 1;
  1619. mVertexDataMask = data_mask;
  1620. mBufferUsage = buffer_usage;
  1621. mDepthMask = FALSE;
  1622. mSlopRatio = 0.25f;
  1623. mInfiniteFarClip = FALSE;
  1625. LLGLNamePool::registerPool(&sQueryPool);
  1627. mOctree = new LLSpatialGroup::OctreeRoot(LLVector3d(0,0,0), 
  1628. LLVector3d(1,1,1), 
  1629. NULL);
  1630. new LLSpatialGroup(mOctree, this);
  1631. }
  1634. LLSpatialPartition::~LLSpatialPartition()
  1635. {
  1636. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1638. delete mOctree;
  1639. mOctree = NULL;
  1640. }
  1643. LLSpatialGroup *LLSpatialPartition::put(LLDrawable *drawablep, BOOL was_visible)
  1644. {
  1645. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1647. drawablep->updateSpatialExtents();
  1648. validate_drawable(drawablep);
  1650. //keep drawable from being garbage collected
  1651. LLPointer<LLDrawable> ptr = drawablep;
  1653. assert_octree_valid(mOctree);
  1654. mOctree->insert(drawablep);
  1655. assert_octree_valid(mOctree);
  1657. LLSpatialGroup* group = drawablep->getSpatialGroup();
  1659. if (group && was_visible && group->isOcclusionState(LLSpatialGroup::QUERY_PENDING))
  1660. {
  1661. group->setOcclusionState(LLSpatialGroup::DISCARD_QUERY, LLSpatialGroup::STATE_MODE_ALL_CAMERAS);
  1662. }
  1664. return group;
  1665. }
  1667. BOOL LLSpatialPartition::remove(LLDrawable *drawablep, LLSpatialGroup *curp)
  1668. {
  1669. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1671. drawablep->setSpatialGroup(NULL);
  1673. if (!curp->removeObject(drawablep))
  1674. {
  1675. OCT_ERRS << "Failed to remove drawable from octree!" << llendl;
  1676. }
  1678. assert_octree_valid(mOctree);
  1680. return TRUE;
  1681. }
  1683. void LLSpatialPartition::move(LLDrawable *drawablep, LLSpatialGroup *curp, BOOL immediate)
  1684. {
  1685. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1687. // sanity check submitted by open source user bushing Spatula
  1688. // who was seeing crashing here. (See VWR-424 reported by Bunny Mayne)
  1689. if (!drawablep)
  1690. {
  1691. OCT_ERRS << "LLSpatialPartition::move was passed a bad drawable." << llendl;
  1692. return;
  1693. }
  1695. BOOL was_visible = curp ? curp->isVisible() : FALSE;
  1697. if (curp && curp->mSpatialPartition != this)
  1698. {
  1699. //keep drawable from being garbage collected
  1700. LLPointer<LLDrawable> ptr = drawablep;
  1701. if (curp->mSpatialPartition->remove(drawablep, curp))
  1702. {
  1703. put(drawablep, was_visible);
  1704. return;
  1705. }
  1706. else
  1707. {
  1708. OCT_ERRS << "Drawable lost between spatial partitions on outbound transition." << llendl;
  1709. }
  1710. }
  1712. if (curp && curp->updateInGroup(drawablep, immediate))
  1713. {
  1714. // Already updated, don't need to do anything
  1715. assert_octree_valid(mOctree);
  1716. return;
  1717. }
  1719. //keep drawable from being garbage collected
  1720. LLPointer<LLDrawable> ptr = drawablep;
  1721. if (curp && !remove(drawablep, curp))
  1722. {
  1723. OCT_ERRS << "Move couldn't find existing spatial group!" << llendl;
  1724. }
  1726. put(drawablep, was_visible);
  1727. }
  1729. class LLSpatialShift : public LLSpatialGroup::OctreeTraveler
  1730. {
  1731. public:
  1732. LLSpatialShift(LLVector3 offset) : mOffset(offset) { }
  1733. virtual void visit(const LLSpatialGroup::OctreeNode* branch) 
  1734. { 
  1735. ((LLSpatialGroup*) branch->getListener(0))->shift(mOffset); 
  1736. }
  1738. LLVector3 mOffset;
  1739. };
  1741. void LLSpatialPartition::shift(const LLVector3 &offset)
  1742. { //shift octree node bounding boxes by offset
  1743. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  1744. LLSpatialShift shifter(offset);
  1745. shifter.traverse(mOctree);
  1746. }
  1748. class LLOctreeCull : public LLSpatialGroup::OctreeTraveler
  1749. {
  1750. public:
  1751. LLOctreeCull(LLCamera* camera)
  1752. : mCamera(camera), mRes(0) { }
  1754. virtual bool earlyFail(LLSpatialGroup* group)
  1755. {
  1756. group->checkOcclusion();
  1758. if (group->mOctreeNode->getParent() && //never occlusion cull the root node
  1759.    LLPipeline::sUseOcclusion && //ignore occlusion if disabled
  1760. group->isOcclusionState(LLSpatialGroup::OCCLUDED))
  1761. {
  1762. gPipeline.markOccluder(group);
  1763. return true;
  1764. }
  1766. return false;
  1767. }
  1769. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  1770. {
  1771. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  1773. if (earlyFail(group))
  1774. {
  1775. return;
  1776. }
  1778. if (mRes == 2 || 
  1779. (mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK)))
  1780. { //fully in, just add everything
  1781. LLSpatialGroup::OctreeTraveler::traverse(n);
  1782. }
  1783. else
  1784. {
  1785. mRes = frustumCheck(group);
  1787. if (mRes)
  1788. { //at least partially in, run on down
  1789. LLSpatialGroup::OctreeTraveler::traverse(n);
  1790. }
  1792. mRes = 0;
  1793. }
  1794. }
  1796. virtual S32 frustumCheck(const LLSpatialGroup* group)
  1797. {
  1798. S32 res = mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]);
  1799. if (res != 0)
  1800. {
  1801. res = llmin(res, AABBSphereIntersect(group->mExtents[0], group->mExtents[1], mCamera->getOrigin(), mCamera->mFrustumCornerDist));
  1802. }
  1803. return res;
  1804. }
  1806. virtual S32 frustumCheckObjects(const LLSpatialGroup* group)
  1807. {
  1808. S32 res = mCamera->AABBInFrustumNoFarClip(group->mObjectBounds[0], group->mObjectBounds[1]);
  1809. if (res != 0)
  1810. {
  1811. res = llmin(res, AABBSphereIntersect(group->mObjectExtents[0], group->mObjectExtents[1], mCamera->getOrigin(), mCamera->mFrustumCornerDist));
  1812. }
  1813. return res;
  1814. }
  1816. virtual bool checkObjects(const LLSpatialGroup::OctreeNode* branch, const LLSpatialGroup* group)
  1817. {
  1818. if (branch->getElementCount() == 0) //no elements
  1819. {
  1820. return false;
  1821. }
  1822. else if (branch->getChildCount() == 0) //leaf state, already checked tightest bounding box
  1823. {
  1824. return true;
  1825. }
  1826. else if (mRes == 1 && !frustumCheckObjects(group)) //no objects in frustum
  1827. {
  1828. return false;
  1829. }
  1831. return true;
  1832. }
  1834. virtual void preprocess(LLSpatialGroup* group)
  1835. {
  1837. }
  1839. virtual void processGroup(LLSpatialGroup* group)
  1840. {
  1841. if (group->needsUpdate() ||
  1842. group->mVisible[LLViewerCamera::sCurCameraID] < LLDrawable::getCurrentFrame() - 1)
  1843. {
  1844. group->doOcclusion(mCamera);
  1845. }
  1846. gPipeline.markNotCulled(group, *mCamera);
  1847. }
  1849. virtual void visit(const LLSpatialGroup::OctreeNode* branch) 
  1850. {
  1851. LLSpatialGroup* group = (LLSpatialGroup*) branch->getListener(0);
  1853. preprocess(group);
  1855. if (checkObjects(branch, group))
  1856. {
  1857. processGroup(group);
  1858. }
  1859. }
  1861. LLCamera *mCamera;
  1862. S32 mRes;
  1863. };
  1865. class LLOctreeCullNoFarClip : public LLOctreeCull
  1866. {
  1867. public: 
  1868. LLOctreeCullNoFarClip(LLCamera* camera) 
  1869. : LLOctreeCull(camera) { }
  1871. virtual S32 frustumCheck(const LLSpatialGroup* group)
  1872. {
  1873. return mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]);
  1874. }
  1876. virtual S32 frustumCheckObjects(const LLSpatialGroup* group)
  1877. {
  1878. S32 res = mCamera->AABBInFrustumNoFarClip(group->mObjectBounds[0], group->mObjectBounds[1]);
  1879. return res;
  1880. }
  1881. };
  1883. class LLOctreeCullShadow : public LLOctreeCull
  1884. {
  1885. public:
  1886. LLOctreeCullShadow(LLCamera* camera)
  1887. : LLOctreeCull(camera) { }
  1889. virtual S32 frustumCheck(const LLSpatialGroup* group)
  1890. {
  1891. return mCamera->AABBInFrustum(group->mBounds[0], group->mBounds[1]);
  1892. }
  1894. virtual S32 frustumCheckObjects(const LLSpatialGroup* group)
  1895. {
  1896. return mCamera->AABBInFrustum(group->mObjectBounds[0], group->mObjectBounds[1]);
  1897. }
  1898. };
  1900. class LLOctreeCullVisExtents: public LLOctreeCullShadow
  1901. {
  1902. public:
  1903. LLOctreeCullVisExtents(LLCamera* camera, LLVector3& min, LLVector3& max)
  1904. : LLOctreeCullShadow(camera), mMin(min), mMax(max), mEmpty(TRUE) { }
  1906. virtual bool earlyFail(LLSpatialGroup* group)
  1907. {
  1908. if (group->mOctreeNode->getParent() && //never occlusion cull the root node
  1909. LLPipeline::sUseOcclusion && //ignore occlusion if disabled
  1910. group->isOcclusionState(LLSpatialGroup::OCCLUDED))
  1911. {
  1912. return true;
  1913. }
  1915. return false;
  1916. }
  1918. virtual void traverse(const LLSpatialGroup::OctreeNode* n)
  1919. {
  1920. LLSpatialGroup* group = (LLSpatialGroup*) n->getListener(0);
  1922. if (earlyFail(group))
  1923. {
  1924. return;
  1925. }
  1927. if (mRes == 2)
  1928. {
  1929. //fully in, don't traverse further (won't effect extents
  1930. }
  1931. else if (mRes && group->isState(LLSpatialGroup::SKIP_FRUSTUM_CHECK))
  1932. { //don't need to do frustum check
  1933. LLSpatialGroup::OctreeTraveler::traverse(n);
  1934. }
  1935. else
  1936. {  
  1937. mRes = frustumCheck(group);
  1939. if (mRes)
  1940. { //at least partially in, run on down
  1941. LLSpatialGroup::OctreeTraveler::traverse(n);
  1942. }
  1944. mRes = 0;
  1945. }
  1946. }
  1948. virtual void processGroup(LLSpatialGroup* group)
  1949. {
  1950. if (group->isState(LLSpatialGroup::DIRTY) || group->getData().empty())
  1951. {
  1952. llerrs << "WTF?" << llendl;
  1953. }
  1955. if (mRes < 2)
  1956. {
  1957. if (mCamera->AABBInFrustum(group->mObjectBounds[0], group->mObjectBounds[1]) > 0)
  1958. {
  1959. mEmpty = FALSE;
  1960. update_min_max(mMin, mMax, group->mObjectExtents[0]);
  1961. update_min_max(mMin, mMax, group->mObjectExtents[1]);
  1962. }
  1963. }
  1964. else
  1965. {
  1966. mEmpty = FALSE;
  1967. update_min_max(mMin, mMax, group->mExtents[0]);
  1968. update_min_max(mMin, mMax, group->mExtents[1]);
  1969. }
  1970. }
  1972. BOOL mEmpty;
  1973. LLVector3& mMin;
  1974. LLVector3& mMax;
  1975. };
  1977. class LLOctreeCullDetectVisible: public LLOctreeCullShadow
  1978. {
  1979. public:
  1980. LLOctreeCullDetectVisible(LLCamera* camera)
  1981. : LLOctreeCullShadow(camera), mResult(FALSE) { }
  1983. virtual bool earlyFail(LLSpatialGroup* group)
  1984. {
  1985. if (mResult || //already found a node, don't check any more
  1986. (group->mOctreeNode->getParent() && //never occlusion cull the root node
  1987.  LLPipeline::sUseOcclusion && //ignore occlusion if disabled
  1988.  group->isOcclusionState(LLSpatialGroup::OCCLUDED)))
  1989. {
  1990. return true;
  1991. }
  1993. return false;
  1994. }
  1996. virtual void processGroup(LLSpatialGroup* group)
  1997. {
  1998. if (group->isVisible())
  1999. {
  2000. mResult = TRUE;
  2001. }
  2002. }
  2004. BOOL mResult;
  2005. };
  2007. class LLOctreeSelect : public LLOctreeCull
  2008. {
  2009. public:
  2010. LLOctreeSelect(LLCamera* camera, std::vector<LLDrawable*>* results)
  2011. : LLOctreeCull(camera), mResults(results) { }
  2013. virtual bool earlyFail(LLSpatialGroup* group) { return false; }
  2014. virtual void preprocess(LLSpatialGroup* group) { }
  2016. virtual void processGroup(LLSpatialGroup* group)
  2017. {
  2018. LLSpatialGroup::OctreeNode* branch = group->mOctreeNode;
  2020. for (LLSpatialGroup::OctreeNode::const_element_iter i = branch->getData().begin(); i != branch->getData().end(); ++i)
  2021. {
  2022. LLDrawable* drawable = *i;
  2024. if (!drawable->isDead())
  2025. {
  2026. if (drawable->isSpatialBridge())
  2027. {
  2028. drawable->setVisible(*mCamera, mResults, TRUE);
  2029. }
  2030. else
  2031. {
  2032. mResults->push_back(drawable);
  2033. }
  2034. }
  2035. }
  2036. }
  2038. std::vector<LLDrawable*>* mResults;
  2039. };
  2041. void drawBox(const LLVector3& c, const LLVector3& r)
  2042. {
  2043. gGL.begin(LLRender::TRIANGLE_STRIP);
  2044. //left front
  2045. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,-1))).mV);
  2046. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,1))).mV);
  2047. //right front
  2048. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,1,-1))).mV);
  2049. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,1,1))).mV);
  2050. //right back
  2051.   gGL.vertex3fv((c+r.scaledVec(LLVector3(1,-1,-1))).mV);
  2052. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,-1,1))).mV);
  2053. //left back
  2054. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,-1,-1))).mV);
  2055. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,-1,1))).mV);
  2056. //left front
  2057. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,-1))).mV);
  2058. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,1))).mV);
  2059. gGL.end();
  2061. //bottom
  2062. gGL.begin(LLRender::TRIANGLE_STRIP);
  2063. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,1,-1))).mV);
  2064. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,-1,-1))).mV);
  2065. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,-1))).mV);
  2066. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,-1,-1))).mV);
  2067. gGL.end();
  2069. //top
  2070. gGL.begin(LLRender::TRIANGLE_STRIP);
  2071. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,1,1))).mV);
  2072. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,1,1))).mV);
  2073. gGL.vertex3fv((c+r.scaledVec(LLVector3(1,-1,1))).mV);
  2074. gGL.vertex3fv((c+r.scaledVec(LLVector3(-1,-1,1))).mV);
  2075. gGL.end();
  2076. }
  2078. void drawBoxOutline(const LLVector3& pos, const LLVector3& size)
  2079. {
  2080. LLVector3 v1 = size.scaledVec(LLVector3( 1, 1,1));
  2081. LLVector3 v2 = size.scaledVec(LLVector3(-1, 1,1));
  2082. LLVector3 v3 = size.scaledVec(LLVector3(-1,-1,1));
  2083. LLVector3 v4 = size.scaledVec(LLVector3( 1,-1,1));
  2085. gGL.begin(LLRender::LINES); 
  2087. //top
  2088. gGL.vertex3fv((pos+v1).mV);
  2089. gGL.vertex3fv((pos+v2).mV);
  2090. gGL.vertex3fv((pos+v2).mV);
  2091. gGL.vertex3fv((pos+v3).mV);
  2092. gGL.vertex3fv((pos+v3).mV);
  2093. gGL.vertex3fv((pos+v4).mV);
  2094. gGL.vertex3fv((pos+v4).mV);
  2095. gGL.vertex3fv((pos+v1).mV);
  2097. //bottom
  2098. gGL.vertex3fv((pos-v1).mV);
  2099. gGL.vertex3fv((pos-v2).mV);
  2100. gGL.vertex3fv((pos-v2).mV);
  2101. gGL.vertex3fv((pos-v3).mV);
  2102. gGL.vertex3fv((pos-v3).mV);
  2103. gGL.vertex3fv((pos-v4).mV);
  2104. gGL.vertex3fv((pos-v4).mV);
  2105. gGL.vertex3fv((pos-v1).mV);
  2107. //right
  2108. gGL.vertex3fv((pos+v1).mV);
  2109. gGL.vertex3fv((pos-v3).mV);
  2111. gGL.vertex3fv((pos+v4).mV);
  2112. gGL.vertex3fv((pos-v2).mV);
  2114. //left
  2115. gGL.vertex3fv((pos+v2).mV);
  2116. gGL.vertex3fv((pos-v4).mV);
  2118. gGL.vertex3fv((pos+v3).mV);
  2119. gGL.vertex3fv((pos-v1).mV);
  2121. gGL.end();
  2122. }
  2124. class LLOctreeDirty : public LLOctreeTraveler<LLDrawable>
  2125. {
  2126. public:
  2127. virtual void visit(const LLOctreeNode<LLDrawable>* state)
  2128. {
  2129. LLSpatialGroup* group = (LLSpatialGroup*) state->getListener(0);
  2130. group->destroyGL();
  2132. for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
  2133. {
  2134. LLDrawable* drawable = *i;
  2135. if (drawable->getVObj().notNull() && !group->mSpatialPartition->mRenderByGroup)
  2136. {
  2137. gPipeline.markRebuild(drawable, LLDrawable::REBUILD_ALL, TRUE);
  2138. }
  2139. }
  2141. for (LLSpatialGroup::bridge_list_t::iterator i = group->mBridgeList.begin(); i != group->mBridgeList.end(); ++i)
  2142. {
  2143. LLSpatialBridge* bridge = *i;
  2144. traverse(bridge->mOctree);
  2145. }
  2146. }
  2147. };
  2149. void LLSpatialPartition::restoreGL()
  2150. {
  2151. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  2152. }
  2154. void LLSpatialPartition::resetVertexBuffers()
  2155. {
  2156. LLOctreeDirty dirty;
  2157. dirty.traverse(mOctree);
  2158. }
  2160. BOOL LLSpatialPartition::isOcclusionEnabled()
  2161. {
  2162. return mOcclusionEnabled || LLPipeline::sUseOcclusion > 2;
  2163. }
  2165. BOOL LLSpatialPartition::getVisibleExtents(LLCamera& camera, LLVector3& visMin, LLVector3& visMax)
  2166. {
  2167. {
  2168. LLFastTimer ftm(FTM_CULL_REBOUND);
  2169. LLSpatialGroup* group = (LLSpatialGroup*) mOctree->getListener(0);
  2170. group->rebound();
  2171. }
  2173. LLOctreeCullVisExtents vis(&camera, visMin, visMax);
  2174. vis.traverse(mOctree);
  2175. return vis.mEmpty;
  2176. }
  2178. BOOL LLSpatialPartition::visibleObjectsInFrustum(LLCamera& camera)
  2179. {
  2180. LLOctreeCullDetectVisible vis(&camera);
  2181. vis.traverse(mOctree);
  2182. return vis.mResult;
  2183. }
  2185. S32 LLSpatialPartition::cull(LLCamera &camera, std::vector<LLDrawable *>* results, BOOL for_select)
  2186. {
  2187. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  2188. #if LL_OCTREE_PARANOIA_CHECK
  2189. ((LLSpatialGroup*)mOctree->getListener(0))->checkStates();
  2190. #endif
  2191. {
  2192. LLFastTimer ftm(FTM_CULL_REBOUND);
  2193. LLSpatialGroup* group = (LLSpatialGroup*) mOctree->getListener(0);
  2194. group->rebound();
  2195. }
  2197. #if LL_OCTREE_PARANOIA_CHECK
  2198. ((LLSpatialGroup*)mOctree->getListener(0))->validate();
  2199. #endif
  2202. if (for_select)
  2203. {
  2204. LLOctreeSelect selecter(&camera, results);
  2205. selecter.traverse(mOctree);
  2206. }
  2207. else if (LLPipeline::sShadowRender)
  2208. {
  2209. LLFastTimer ftm(FTM_FRUSTUM_CULL);
  2210. LLOctreeCullShadow culler(&camera);
  2211. culler.traverse(mOctree);
  2212. }
  2213. else if (mInfiniteFarClip || !LLPipeline::sUseFarClip)
  2214. {
  2215. LLFastTimer ftm(FTM_FRUSTUM_CULL);
  2216. LLOctreeCullNoFarClip culler(&camera);
  2217. culler.traverse(mOctree);
  2218. }
  2219. else
  2220. {
  2221. LLFastTimer ftm(FTM_FRUSTUM_CULL);
  2222. LLOctreeCull culler(&camera);
  2223. culler.traverse(mOctree);
  2224. }
  2226. return 0;
  2227. }
  2229. BOOL earlyFail(LLCamera* camera, LLSpatialGroup* group)
  2230. {
  2231. if (camera->getOrigin().isExactlyZero())
  2232. {
  2233. return FALSE;
  2234. }
  2236. const F32 vel = SG_OCCLUSION_FUDGE*2.f;
  2237. LLVector3 c = group->mBounds[0];
  2238. LLVector3 r = group->mBounds[1] + LLVector3(vel,vel,vel);
  2239.     
  2240. /*if (r.magVecSquared() > 1024.0*1024.0)
  2241. {
  2242. return TRUE;
  2243. }*/
  2245. LLVector3 e = camera->getOrigin();
  2247. LLVector3 min = c - r;
  2248. LLVector3 max = c + r;
  2250. for (U32 j = 0; j < 3; j++)
  2251. {
  2252. if (e.mV[j] < min.mV[j] || e.mV[j] > max.mV[j])
  2253. {
  2254. return FALSE;
  2255. }
  2256. }
  2258. return TRUE;
  2259. }
  2262. void pushVerts(LLDrawInfo* params, U32 mask)
  2263. {
  2264. LLRenderPass::applyModelMatrix(*params);
  2265. params->mVertexBuffer->setBuffer(mask);
  2266. params->mVertexBuffer->drawRange(params->mParticle ? LLRender::POINTS : LLRender::TRIANGLES,
  2267. params->mStart, params->mEnd, params->mCount, params->mOffset);
  2268. }
  2270. void pushVerts(LLSpatialGroup* group, U32 mask)
  2271. {
  2272. LLDrawInfo* params = NULL;
  2274. for (LLSpatialGroup::draw_map_t::iterator i = group->mDrawMap.begin(); i != group->mDrawMap.end(); ++i)
  2275. {
  2276. for (LLSpatialGroup::drawmap_elem_t::iterator j = i->second.begin(); j != i->second.end(); ++j) 
  2277. {
  2278. params = *j;
  2279. pushVerts(params, mask);
  2280. }
  2281. }
  2282. }
  2284. void pushVerts(LLFace* face, U32 mask)
  2285. {
  2286. LLVertexBuffer* buffer = face->mVertexBuffer;
  2288. if (buffer)
  2289. {
  2290. buffer->setBuffer(mask);
  2291. U16 start = face->getGeomStart();
  2292. U16 end = start + face->getGeomCount()-1;
  2293. U32 count = face->getIndicesCount();
  2294. U16 offset = face->getIndicesStart();
  2295. buffer->drawRange(LLRender::TRIANGLES, start, end, count, offset);
  2296. }
  2298. }
  2300. void pushBufferVerts(LLVertexBuffer* buffer, U32 mask)
  2301. {
  2302. if (buffer)
  2303. {
  2304. buffer->setBuffer(mask);
  2305. buffer->drawRange(LLRender::TRIANGLES, 0, buffer->getRequestedVerts()-1, buffer->getRequestedIndices(), 0);
  2306. }
  2307. }
  2309. void pushBufferVerts(LLSpatialGroup* group, U32 mask)
  2310. {
  2311. if (group->mSpatialPartition->mRenderByGroup)
  2312. {
  2313. if (!group->mDrawMap.empty())
  2314. {
  2315. LLDrawInfo* params = *(group->mDrawMap.begin()->second.begin());
  2316. LLRenderPass::applyModelMatrix(*params);
  2318. pushBufferVerts(group->mVertexBuffer, mask);
  2320. for (LLSpatialGroup::buffer_map_t::iterator i = group->mBufferMap.begin(); i != group->mBufferMap.end(); ++i)
  2321. {
  2322. for (LLSpatialGroup::buffer_texture_map_t::iterator j = i->second.begin(); j != i->second.end(); ++j)
  2323. {
  2324. for (LLSpatialGroup::buffer_list_t::iterator k = j->second.begin(); k != j->second.end(); ++k)
  2325. {
  2326. pushBufferVerts(*k, mask);
  2327. }
  2328. }
  2329. }
  2330. }
  2331. }
  2332. else
  2333. {
  2334. drawBox(group->mBounds[0], group->mBounds[1]);
  2335. }
  2336. }
  2338. void pushVertsColorCoded(LLSpatialGroup* group, U32 mask)
  2339. {
  2340. LLDrawInfo* params = NULL;
  2342. LLColor4 colors[] = {
  2343. LLColor4::green,
  2344. LLColor4::green1,
  2345. LLColor4::green2,
  2346. LLColor4::green3,
  2347. LLColor4::green4,
  2348. LLColor4::green5,
  2349. LLColor4::green6
  2350. };
  2352. static const U32 col_count = LL_ARRAY_SIZE(colors);
  2354. U32 col = 0;
  2356. for (LLSpatialGroup::draw_map_t::iterator i = group->mDrawMap.begin(); i != group->mDrawMap.end(); ++i)
  2357. {
  2358. for (LLSpatialGroup::drawmap_elem_t::iterator j = i->second.begin(); j != i->second.end(); ++j) 
  2359. {
  2360. params = *j;
  2361. LLRenderPass::applyModelMatrix(*params);
  2362. glColor4f(colors[col].mV[0], colors[col].mV[1], colors[col].mV[2], 0.5f);
  2363. params->mVertexBuffer->setBuffer(mask);
  2364. params->mVertexBuffer->drawRange(params->mParticle ? LLRender::POINTS : LLRender::TRIANGLES,
  2365. params->mStart, params->mEnd, params->mCount, params->mOffset);
  2366. col = (col+1)%col_count;
  2367. }
  2368. }
  2369. }
  2371. void renderOctree(LLSpatialGroup* group)
  2372. {
  2373. //render solid object bounding box, color
  2374. //coded by buffer usage and activity
  2375. LLGLDepthTest depth(GL_TRUE, GL_FALSE);
  2376. gGL.setSceneBlendType(LLRender::BT_ADD_WITH_ALPHA);
  2377. LLVector4 col;
  2378. if (group->mBuilt > 0.f)
  2379. {
  2380. group->mBuilt -= 2.f * gFrameIntervalSeconds;
  2381. if (group->mBufferUsage == GL_STATIC_DRAW_ARB)
  2382. {
  2383. col.setVec(1.0f, 0, 0, group->mBuilt*0.5f);
  2384. }
  2385. else 
  2386. {
  2387. col.setVec(0.1f,0.1f,1,0.1f);
  2388. //col.setVec(1.0f, 1.0f, 0, sinf(group->mBuilt*3.14159f)*0.5f);
  2389. }
  2391. if (group->mBufferUsage != GL_STATIC_DRAW_ARB)
  2392. {
  2393. LLGLDepthTest gl_depth(FALSE, FALSE);
  2394. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  2396. gGL.color4f(1,0,0,group->mBuilt);
  2397. gGL.flush();
  2398. glLineWidth(5.f);
  2399. drawBoxOutline(group->mObjectBounds[0], group->mObjectBounds[1]);
  2400. gGL.flush();
  2401. glLineWidth(1.f);
  2402. gGL.flush();
  2403. for (LLSpatialGroup::element_iter i = group->getData().begin(); i != group->getData().end(); ++i)
  2404. {
  2405. LLDrawable* drawable = *i;
  2406. if (!group->mSpatialPartition->isBridge())
  2407. {
  2408. glPushMatrix();
  2409. LLVector3 trans = drawable->getRegion()->getOriginAgent();
  2410. glTranslatef(trans.mV[0], trans.mV[1], trans.mV[2]);
  2411. }
  2413. for (S32 j = 0; j < drawable->getNumFaces(); j++)
  2414. {
  2415. LLFace* face = drawable->getFace(j);
  2416. if (face->mVertexBuffer.notNull())
  2417. {
  2418. if (gFrameTimeSeconds - face->mLastUpdateTime < 0.5f)
  2419. {
  2420. glColor4f(0, 1, 0, group->mBuilt);
  2421. }
  2422. else if (gFrameTimeSeconds - face->mLastMoveTime < 0.5f)
  2423. {
  2424. glColor4f(1, 0, 0, group->mBuilt);
  2425. }
  2426. else
  2427. {
  2428. continue;
  2429. }
  2431. face->mVertexBuffer->setBuffer(LLVertexBuffer::MAP_VERTEX);
  2432. //drawBox((face->mExtents[0] + face->mExtents[1])*0.5f,
  2433. // (face->mExtents[1]-face->mExtents[0])*0.5f);
  2434. face->mVertexBuffer->draw(LLRender::TRIANGLES, face->getIndicesCount(), face->getIndicesStart());
  2435. }
  2436. }
  2438. if (!group->mSpatialPartition->isBridge())
  2439. {
  2440. glPopMatrix();
  2441. }
  2442. }
  2443. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  2444. gGL.color4f(1,1,1,1);
  2445. }
  2446. }
  2447. else
  2448. {
  2449. if (group->mBufferUsage == GL_STATIC_DRAW_ARB && !group->getData().empty() 
  2450. && group->mSpatialPartition->mRenderByGroup)
  2451. {
  2452. col.setVec(0.8f, 0.4f, 0.1f, 0.1f);
  2453. }
  2454. else
  2455. {
  2456. col.setVec(0.1f, 0.1f, 1.f, 0.1f);
  2457. }
  2458. }
  2460. gGL.color4fv(col.mV);
  2461. drawBox(group->mObjectBounds[0], group->mObjectBounds[1]*1.01f+LLVector3(0.001f, 0.001f, 0.001f));
  2463. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  2465. if (group->mBuilt <= 0.f)
  2466. {
  2467. //draw opaque outline
  2468. gGL.color4f(col.mV[0], col.mV[1], col.mV[2], 1.f);
  2469. drawBoxOutline(group->mObjectBounds[0], group->mObjectBounds[1]);
  2471. if (group->mOctreeNode->isLeaf())
  2472. {
  2473. gGL.color4f(1,1,1,1);
  2474. }
  2475. else
  2476. {
  2477. gGL.color4f(0,1,1,1);
  2478. }
  2480. drawBoxOutline(group->mBounds[0],group->mBounds[1]);
  2483. //draw bounding box for draw info
  2484. if (group->mSpatialPartition->mRenderByGroup)
  2485. {
  2486. gGL.color4f(1.0f, 0.75f, 0.25f, 0.6f);
  2487. for (LLSpatialGroup::draw_map_t::iterator i = group->mDrawMap.begin(); i != group->mDrawMap.end(); ++i)
  2488. {
  2489. for (LLSpatialGroup::drawmap_elem_t::iterator j = i->second.begin(); j != i->second.end(); ++j)
  2490. {
  2491. LLDrawInfo* draw_info = *j;
  2492. LLVector3 center = (draw_info->mExtents[1] + draw_info->mExtents[0])*0.5f;
  2493. LLVector3 size = (draw_info->mExtents[1] - draw_info->mExtents[0])*0.5f;
  2494. drawBoxOutline(center, size);
  2495. }
  2496. }
  2497. }
  2498. }
  2500. // LLSpatialGroup::OctreeNode* node = group->mOctreeNode;
  2501. // gGL.color4f(0,1,0,1);
  2502. // drawBoxOutline(LLVector3(node->getCenter()), LLVector3(node->getSize()));
  2503. }
  2505. void renderVisibility(LLSpatialGroup* group, LLCamera* camera)
  2506. {
  2507. LLGLEnable blend(GL_BLEND);
  2508. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  2509. LLGLEnable cull(GL_CULL_FACE);
  2510. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  2512. BOOL render_objects = (!LLPipeline::sUseOcclusion || !group->isOcclusionState(LLSpatialGroup::OCCLUDED)) && group->isVisible() &&
  2513. !group->getData().empty();
  2514. if (render_objects)
  2515. {
  2516. LLGLDepthTest depth_under(GL_TRUE, GL_FALSE, GL_GREATER);
  2517. glColor4f(0, 0.5f, 0, 0.5f);
  2518. gGL.color4f(0, 0.5f, 0, 0.5f);
  2519. pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX);
  2520. }
  2522. {
  2523. LLGLDepthTest depth_over(GL_TRUE, GL_FALSE, GL_LEQUAL);
  2525. if (render_objects)
  2526. {
  2527. glColor4f(0.f, 0.5f, 0.f,1.f);
  2528. gGL.color4f(0.f, 0.5f, 0.f, 1.f);
  2529. pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX);
  2530. }
  2532. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  2534. if (render_objects)
  2535. {
  2536. glColor4f(0.f, 0.75f, 0.f,0.5f);
  2537. gGL.color4f(0.f, 0.75f, 0.f, 0.5f);
  2538. pushBufferVerts(group, LLVertexBuffer::MAP_VERTEX);
  2539. }
  2540. else if (camera && group->mOcclusionVerts)
  2541. {
  2542. LLVertexBuffer::unbind();
  2543. glVertexPointer(3, GL_FLOAT, 0, group->mOcclusionVerts);
  2545. glColor4f(1.0f, 0.f, 0.f, 0.5f);
  2546. glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8, GL_UNSIGNED_BYTE, get_box_fan_indices(camera, group->mBounds[0]));
  2547. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  2549. glColor4f(1.0f, 1.f, 1.f, 1.0f);
  2550. glDrawRangeElements(GL_TRIANGLE_FAN, 0, 7, 8, GL_UNSIGNED_BYTE, get_box_fan_indices(camera, group->mBounds[0]));
  2551. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  2552. }
  2553. }
  2554. }
  2556. void renderCrossHairs(LLVector3 position, F32 size, LLColor4 color)
  2557. {
  2558. gGL.color4fv(color.mV);
  2559. gGL.begin(LLRender::LINES);
  2560. {
  2561. gGL.vertex3fv((position - LLVector3(size, 0.f, 0.f)).mV);
  2562. gGL.vertex3fv((position + LLVector3(size, 0.f, 0.f)).mV);
  2563. gGL.vertex3fv((position - LLVector3(0.f, size, 0.f)).mV);
  2564. gGL.vertex3fv((position + LLVector3(0.f, size, 0.f)).mV);
  2565. gGL.vertex3fv((position - LLVector3(0.f, 0.f, size)).mV);
  2566. gGL.vertex3fv((position + LLVector3(0.f, 0.f, size)).mV);
  2567. }
  2568. gGL.end();
  2569. }
  2572. void renderBoundingBox(LLDrawable* drawable, BOOL set_color = TRUE)
  2573. {
  2574. if (set_color)
  2575. {
  2576. if (drawable->isSpatialBridge())
  2577. {
  2578. gGL.color4f(1,0.5f,0,1);
  2579. }
  2580. else if (drawable->getVOVolume())
  2581. {
  2582. if (drawable->isRoot())
  2583. {
  2584. gGL.color4f(1,1,0,1);
  2585. }
  2586. else
  2587. {
  2588. gGL.color4f(0,1,0,1);
  2589. }
  2590. }
  2591. else if (drawable->getVObj())
  2592. {
  2593. switch (drawable->getVObj()->getPCode())
  2594. {
  2595. case LLViewerObject::LL_VO_SURFACE_PATCH:
  2596. gGL.color4f(0,1,1,1);
  2597. break;
  2598. case LLViewerObject::LL_VO_CLOUDS:
  2599. gGL.color4f(0.5f,0.5f,0.5f,1.0f);
  2600. break;
  2601. case LLViewerObject::LL_VO_PART_GROUP:
  2602. case LLViewerObject::LL_VO_HUD_PART_GROUP:
  2603. gGL.color4f(0,0,1,1);
  2604. break;
  2605. case LLViewerObject::LL_VO_WATER:
  2606. gGL.color4f(0,0.5f,1,1);
  2607. break;
  2608. case LL_PCODE_LEGACY_TREE:
  2609. gGL.color4f(0,0.5f,0,1);
  2610. break;
  2611. default:
  2612. gGL.color4f(1,0,1,1);
  2613. break;
  2614. }
  2615. }
  2616. else 
  2617. {
  2618. gGL.color4f(1,0,0,1);
  2619. }
  2620. }
  2622. const LLVector3* ext;
  2623. LLVector3 pos, size;
  2625. //render face bounding boxes
  2626. for (S32 i = 0; i < drawable->getNumFaces(); i++)
  2627. {
  2628. LLFace* facep = drawable->getFace(i);
  2630. ext = facep->mExtents;
  2632. if (ext[0].isExactlyZero() && ext[1].isExactlyZero())
  2633. {
  2634. continue;
  2635. }
  2636. pos = (ext[0] + ext[1]) * 0.5f;
  2637. size = (ext[1] - ext[0]) * 0.5f;
  2638. drawBoxOutline(pos,size);
  2639. }
  2641. //render drawable bounding box
  2642. ext = drawable->getSpatialExtents();
  2644. pos = (ext[0] + ext[1]) * 0.5f;
  2645. size = (ext[1] - ext[0]) * 0.5f;
  2647. LLViewerObject* vobj = drawable->getVObj();
  2648. if (vobj && vobj->onActiveList())
  2649. {
  2650. gGL.flush();
  2651. glLineWidth(llmax(4.f*sinf(gFrameTimeSeconds*2.f)+1.f, 1.f));
  2652. //glLineWidth(4.f*(sinf(gFrameTimeSeconds*2.f)*0.25f+0.75f));
  2653. stop_glerror();
  2654. drawBoxOutline(pos,size);
  2655. gGL.flush();
  2656. glLineWidth(1.f);
  2657. }
  2658. else
  2659. {
  2660. drawBoxOutline(pos,size);
  2661. }
  2663. }
  2665. void renderTexturePriority(LLDrawable* drawable)
  2666. {
  2667. for (int face=0; face<drawable->getNumFaces(); ++face)
  2668. {
  2669. LLFace *facep = drawable->getFace(face);
  2671. LLVector4 cold(0,0,0.25f);
  2672. LLVector4 hot(1,0.25f,0.25f);
  2674. LLVector4 boost_cold(0,0,0,0);
  2675. LLVector4 boost_hot(0,1,0,1);
  2677. LLGLDisable blend(GL_BLEND);
  2679. //LLViewerTexture* imagep = facep->getTexture();
  2680. //if (imagep)
  2681. {
  2683. //F32 vsize = imagep->mMaxVirtualSize;
  2684. F32 vsize = facep->getPixelArea();
  2686. if (vsize > sCurMaxTexPriority)
  2687. {
  2688. sCurMaxTexPriority = vsize;
  2689. }
  2691. F32 t = vsize/sLastMaxTexPriority;
  2693. LLVector4 col = lerp(cold, hot, t);
  2694. gGL.color4fv(col.mV);
  2695. }
  2696. //else
  2697. //{
  2698. // gGL.color4f(1,0,1,1);
  2699. //}
  2701. LLVector3 center = (facep->mExtents[1]+facep->mExtents[0])*0.5f;
  2702. LLVector3 size = (facep->mExtents[1]-facep->mExtents[0])*0.5f + LLVector3(0.01f, 0.01f, 0.01f);
  2703. drawBox(center, size);
  2705. /*S32 boost = imagep->getBoostLevel();
  2706. if (boost>LLViewerTexture::BOOST_NONE)
  2707. {
  2708. F32 t = (F32) boost / (F32) (LLViewerTexture::BOOST_MAX_LEVEL-1);
  2709. LLVector4 col = lerp(boost_cold, boost_hot, t);
  2710. LLGLEnable blend_on(GL_BLEND);
  2711. gGL.blendFunc(GL_SRC_ALPHA, GL_ONE);
  2712. gGL.color4fv(col.mV);
  2713. drawBox(center, size);
  2714. gGL.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  2715. }*/
  2716. }
  2717. }
  2719. void renderPoints(LLDrawable* drawablep)
  2720. {
  2721. LLGLDepthTest depth(GL_FALSE, GL_FALSE);
  2722. if (drawablep->getNumFaces())
  2723. {
  2724. gGL.begin(LLRender::POINTS);
  2725. gGL.color3f(1,1,1);
  2726. LLVector3 center(drawablep->getPositionGroup());
  2727. for (S32 i = 0; i < drawablep->getNumFaces(); i++)
  2728. {
  2729. gGL.vertex3fv(drawablep->getFace(i)->mCenterLocal.mV);
  2730. }
  2731. gGL.end();
  2732. }
  2733. }
  2735. void renderTextureAnim(LLDrawInfo* params)
  2736. {
  2737. if (!params->mTextureMatrix)
  2738. {
  2739. return;
  2740. }
  2742. LLGLEnable blend(GL_BLEND);
  2743. glColor4f(1,1,0,0.5f);
  2744. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2745. }
  2747. void renderBatchSize(LLDrawInfo* params)
  2748. {
  2749. glColor3ubv((GLubyte*) &(params->mDebugColor));
  2750. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2751. }
  2753. void renderShadowFrusta(LLDrawInfo* params)
  2754. {
  2755. LLGLEnable blend(GL_BLEND);
  2756. gGL.setSceneBlendType(LLRender::BT_ADD);
  2758. LLVector3 center = (params->mExtents[1]+params->mExtents[0])*0.5f;
  2759. LLVector3 size = (params->mExtents[1]-params->mExtents[0])*0.5f;
  2761. if (gPipeline.mShadowCamera[4].AABBInFrustum(center, size))
  2762. {
  2763. glColor3f(1,0,0);
  2764. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2765. }
  2766. if (gPipeline.mShadowCamera[5].AABBInFrustum(center, size))
  2767. {
  2768. glColor3f(0,1,0);
  2769. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2770. }
  2771. if (gPipeline.mShadowCamera[6].AABBInFrustum(center, size))
  2772. {
  2773. glColor3f(0,0,1);
  2774. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2775. }
  2776. if (gPipeline.mShadowCamera[7].AABBInFrustum(center, size))
  2777. {
  2778. glColor3f(1,0,1);
  2779. pushVerts(params, LLVertexBuffer::MAP_VERTEX);
  2780. }
  2782. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  2783. }
  2786. void renderLights(LLDrawable* drawablep)
  2787. {
  2788. if (!drawablep->isLight())
  2789. {
  2790. return;
  2791. }
  2793. if (drawablep->getNumFaces())
  2794. {
  2795. LLGLEnable blend(GL_BLEND);
  2796. glColor4f(0,1,1,0.5f);
  2798. for (S32 i = 0; i < drawablep->getNumFaces(); i++)
  2799. {
  2800. pushVerts(drawablep->getFace(i), LLVertexBuffer::MAP_VERTEX);
  2801. }
  2803. const LLVector3* ext = drawablep->getSpatialExtents();
  2805. LLVector3 pos = (ext[0] + ext[1]) * 0.5f;
  2806. LLVector3 size = (ext[1] - ext[0]) * 0.5f;
  2808. {
  2809. LLGLDepthTest depth(GL_FALSE, GL_TRUE);
  2810. gGL.color4f(1,1,1,1);
  2811. drawBoxOutline(pos, size);
  2812. }
  2814. gGL.color4f(1,1,0,1);
  2815. F32 rad = drawablep->getVOVolume()->getLightRadius();
  2816. drawBoxOutline(pos, LLVector3(rad,rad,rad));
  2817. }
  2818. }
  2821. void renderRaycast(LLDrawable* drawablep)
  2822. {
  2823. if (drawablep->getVObj() != gDebugRaycastObject)
  2824. {
  2825. return;
  2826. }
  2828. if (drawablep->getNumFaces())
  2829. {
  2830. LLGLEnable blend(GL_BLEND);
  2831. gGL.color4f(0,1,1,0.5f);
  2833. if (drawablep->getVOVolume() && gDebugRaycastFaceHit != -1)
  2834. {
  2835. glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
  2836. pushVerts(drawablep->getFace(gDebugRaycastFaceHit), LLVertexBuffer::MAP_VERTEX);
  2837. glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
  2838. }
  2839. else if (drawablep->isAvatar())
  2840. {
  2841. LLGLDepthTest depth(GL_FALSE);
  2842. LLVOAvatar* av = (LLVOAvatar*) drawablep->getVObj().get();
  2843. av->renderCollisionVolumes();
  2844. }
  2846. // draw intersection point
  2847. glPushMatrix();
  2848. glLoadMatrixd(gGLModelView);
  2849. LLVector3 translate = gDebugRaycastIntersection;
  2850. glTranslatef(translate.mV[0], translate.mV[1], translate.mV[2]);
  2851. LLCoordFrame orient;
  2852. orient.lookDir(gDebugRaycastNormal, gDebugRaycastBinormal);
  2853. LLMatrix4 rotation;
  2854. orient.getRotMatrixToParent(rotation);
  2855. glMultMatrixf((float*)rotation.mMatrix);
  2857. gGL.color4f(1,0,0,0.5f);
  2858. drawBox(LLVector3(0, 0, 0), LLVector3(0.1f, 0.022f, 0.022f));
  2859. gGL.color4f(0,1,0,0.5f);
  2860. drawBox(LLVector3(0, 0, 0), LLVector3(0.021f, 0.1f, 0.021f));
  2861. gGL.color4f(0,0,1,0.5f);
  2862. drawBox(LLVector3(0, 0, 0), LLVector3(0.02f, 0.02f, 0.1f));
  2863. glPopMatrix();
  2865. // draw bounding box of prim
  2866. const LLVector3* ext = drawablep->getSpatialExtents();
  2868. LLVector3 pos = (ext[0] + ext[1]) * 0.5f;
  2869. LLVector3 size = (ext[1] - ext[0]) * 0.5f;
  2871. LLGLDepthTest depth(GL_FALSE, GL_TRUE);
  2872. gGL.color4f(0,0.5f,0.5f,1);
  2873. drawBoxOutline(pos, size);
  2875. }
  2876. }
  2879. void renderAvatarCollisionVolumes(LLVOAvatar* avatar)
  2880. {
  2881. avatar->renderCollisionVolumes();
  2882. }
  2884. void renderAgentTarget(LLVOAvatar* avatar)
  2885. {
  2886. // render these for self only (why, i don't know)
  2887. if (avatar->isSelf())
  2888. {
  2889. renderCrossHairs(avatar->getPositionAgent(), 0.2f, LLColor4(1, 0, 0, 0.8f));
  2890. renderCrossHairs(avatar->mDrawable->getPositionAgent(), 0.2f, LLColor4(1, 0, 0, 0.8f));
  2891. renderCrossHairs(avatar->mRoot.getWorldPosition(), 0.2f, LLColor4(1, 1, 1, 0.8f));
  2892. renderCrossHairs(avatar->mPelvisp->getWorldPosition(), 0.2f, LLColor4(0, 0, 1, 0.8f));
  2893. }
  2894. }
  2897. class LLOctreeRenderNonOccluded : public LLOctreeTraveler<LLDrawable>
  2898. {
  2899. public:
  2900. LLCamera* mCamera;
  2901. LLOctreeRenderNonOccluded(LLCamera* camera): mCamera(camera) {}
  2903. virtual void traverse(const LLSpatialGroup::OctreeNode* node)
  2904. {
  2905. LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
  2907. if (!mCamera || mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1]))
  2908. {
  2909. node->accept(this);
  2910. stop_glerror();
  2912. for (U32 i = 0; i < node->getChildCount(); i++)
  2913. {
  2914. traverse(node->getChild(i));
  2915. stop_glerror();
  2916. }
  2918. //draw tight fit bounding boxes for spatial group
  2919. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCTREE))
  2920. {
  2921. group->rebuildGeom();
  2922. group->rebuildMesh();
  2924. renderOctree(group);
  2925. stop_glerror();
  2926. }
  2928. //render visibility wireframe
  2929. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCCLUSION))
  2930. {
  2931. group->rebuildGeom();
  2932. group->rebuildMesh();
  2934. gGL.flush();
  2935. glPushMatrix();
  2936. gGLLastMatrix = NULL;
  2937. glLoadMatrixd(gGLModelView);
  2938. renderVisibility(group, mCamera);
  2939. stop_glerror();
  2940. gGLLastMatrix = NULL;
  2941. glPopMatrix();
  2942. gGL.color4f(1,1,1,1);
  2943. }
  2944. }
  2945. }
  2947. virtual void visit(const LLSpatialGroup::OctreeNode* branch)
  2948. {
  2949. LLSpatialGroup* group = (LLSpatialGroup*) branch->getListener(0);
  2951. if (group->isState(LLSpatialGroup::GEOM_DIRTY) || (mCamera && !mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1])))
  2952. {
  2953. return;
  2954. }
  2956. LLVector3 nodeCenter = group->mBounds[0];
  2957. LLVector3 octCenter = LLVector3(group->mOctreeNode->getCenter());
  2959. group->rebuildGeom();
  2960. group->rebuildMesh();
  2962. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BBOXES))
  2963. {
  2964. if (!group->getData().empty())
  2965. {
  2966. gGL.color3f(0,0,1);
  2967. drawBoxOutline(group->mObjectBounds[0],
  2968. group->mObjectBounds[1]);
  2969. }
  2970. }
  2972. for (LLSpatialGroup::OctreeNode::const_element_iter i = branch->getData().begin(); i != branch->getData().end(); ++i)
  2973. {
  2974. LLDrawable* drawable = *i;
  2976. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BBOXES))
  2977. {
  2978. renderBoundingBox(drawable);
  2979. }
  2981. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BUILD_QUEUE))
  2982. {
  2983. if (drawable->isState(LLDrawable::IN_REBUILD_Q2))
  2984. {
  2985. gGL.color4f(0.6f, 0.6f, 0.1f, 1.f);
  2986. const LLVector3* ext = drawable->getSpatialExtents();
  2987. drawBoxOutline((ext[0]+ext[1])*0.5f, (ext[1]-ext[0])*0.5f);
  2988. }
  2989. }
  2991. if (drawable->getVOVolume() && gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
  2992. {
  2993. renderTexturePriority(drawable);
  2994. }
  2996. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_POINTS))
  2997. {
  2998. renderPoints(drawable);
  2999. }
  3001. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_LIGHTS))
  3002. {
  3003. renderLights(drawable);
  3004. }
  3006. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_RAYCAST))
  3007. {
  3008. renderRaycast(drawable);
  3009. }
  3011. LLVOAvatar* avatar = dynamic_cast<LLVOAvatar*>(drawable->getVObj().get());
  3013. if (avatar && gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_AVATAR_VOLUME))
  3014. {
  3015. renderAvatarCollisionVolumes(avatar);
  3016. }
  3018. if (avatar && gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_AGENT_TARGET))
  3019. {
  3020. renderAgentTarget(avatar);
  3021. }
  3023. }
  3025. for (LLSpatialGroup::draw_map_t::iterator i = group->mDrawMap.begin(); i != group->mDrawMap.end(); ++i)
  3026. {
  3027. LLSpatialGroup::drawmap_elem_t& draw_vec = i->second;
  3028. for (LLSpatialGroup::drawmap_elem_t::iterator j = draw_vec.begin(); j != draw_vec.end(); ++j)
  3029. {
  3030. LLDrawInfo* draw_info = *j;
  3031. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_ANIM))
  3032. {
  3033. renderTextureAnim(draw_info);
  3034. }
  3035. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_BATCH_SIZE))
  3036. {
  3037. renderBatchSize(draw_info);
  3038. }
  3039. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA))
  3040. {
  3041. renderShadowFrusta(draw_info);
  3042. }
  3043. }
  3044. }
  3045. }
  3046. };
  3048. class LLOctreePushBBoxVerts : public LLOctreeTraveler<LLDrawable>
  3049. {
  3050. public:
  3051. LLCamera* mCamera;
  3052. LLOctreePushBBoxVerts(LLCamera* camera): mCamera(camera) {}
  3054. virtual void traverse(const LLSpatialGroup::OctreeNode* node)
  3055. {
  3056. LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
  3058. if (!mCamera || mCamera->AABBInFrustum(group->mBounds[0], group->mBounds[1]))
  3059. {
  3060. node->accept(this);
  3062. for (U32 i = 0; i < node->getChildCount(); i++)
  3063. {
  3064. traverse(node->getChild(i));
  3065. }
  3066. }
  3067. }
  3069. virtual void visit(const LLSpatialGroup::OctreeNode* branch)
  3070. {
  3071. LLSpatialGroup* group = (LLSpatialGroup*) branch->getListener(0);
  3073. if (group->isState(LLSpatialGroup::GEOM_DIRTY) || (mCamera && !mCamera->AABBInFrustumNoFarClip(group->mBounds[0], group->mBounds[1])))
  3074. {
  3075. return;
  3076. }
  3078. for (LLSpatialGroup::OctreeNode::const_element_iter i = branch->getData().begin(); i != branch->getData().end(); ++i)
  3079. {
  3080. LLDrawable* drawable = *i;
  3082. renderBoundingBox(drawable, FALSE);
  3083. }
  3084. }
  3085. };
  3087. void LLSpatialPartition::renderIntersectingBBoxes(LLCamera* camera)
  3088. {
  3089. LLOctreePushBBoxVerts pusher(camera);
  3090. pusher.traverse(mOctree);
  3091. }
  3093. class LLOctreeStateCheck : public LLOctreeTraveler<LLDrawable>
  3094. {
  3095. public:
  3096. U32 mInheritedMask[LLViewerCamera::NUM_CAMERAS];
  3098. LLOctreeStateCheck()
  3099. { 
  3100. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  3101. {
  3102. mInheritedMask[i] = 0;
  3103. }
  3104. }
  3106. virtual void traverse(const LLSpatialGroup::OctreeNode* node)
  3107. {
  3108. LLSpatialGroup* group = (LLSpatialGroup*) node->getListener(0);
  3110. node->accept(this);
  3113. U32 temp[LLViewerCamera::NUM_CAMERAS];
  3115. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  3116. {
  3117. temp[i] = mInheritedMask[i];
  3118. mInheritedMask[i] |= group->mOcclusionState[i] & LLSpatialGroup::OCCLUDED; 
  3119. }
  3121. for (U32 i = 0; i < node->getChildCount(); i++)
  3122. {
  3123. traverse(node->getChild(i));
  3124. }
  3126. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  3127. {
  3128. mInheritedMask[i] = temp[i];
  3129. }
  3130. }
  3133. virtual void visit(const LLOctreeNode<LLDrawable>* state)
  3134. {
  3135. LLSpatialGroup* group = (LLSpatialGroup*) state->getListener(0);
  3137. for (U32 i = 0; i < LLViewerCamera::NUM_CAMERAS; i++)
  3138. {
  3139. if (mInheritedMask[i] && !(group->mOcclusionState[i] & mInheritedMask[i]))
  3140. {
  3141. llerrs << "Spatial group failed inherited mask test." << llendl;
  3142. }
  3143. }
  3145. if (group->isState(LLSpatialGroup::DIRTY))
  3146. {
  3147. assert_parent_state(group, LLSpatialGroup::DIRTY);
  3148. }
  3149. }
  3151. void assert_parent_state(LLSpatialGroup* group, U32 state)
  3152. {
  3153. LLSpatialGroup* parent = group->getParent();
  3154. while (parent)
  3155. {
  3156. if (!parent->isState(state))
  3157. {
  3158. llerrs << "Spatial group failed parent state check." << llendl;
  3159. }
  3160. parent = parent->getParent();
  3161. }
  3162. }
  3163. };
  3166. void LLSpatialPartition::renderDebug()
  3167. {
  3168. if (!gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_OCTREE |
  3169.   LLPipeline::RENDER_DEBUG_OCCLUSION |
  3170.   LLPipeline::RENDER_DEBUG_LIGHTS |
  3171.   LLPipeline::RENDER_DEBUG_BATCH_SIZE |
  3172.   LLPipeline::RENDER_DEBUG_BBOXES |
  3173.   LLPipeline::RENDER_DEBUG_POINTS |
  3174.   LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY |
  3175.   LLPipeline::RENDER_DEBUG_TEXTURE_ANIM |
  3176.   LLPipeline::RENDER_DEBUG_RAYCAST |
  3177.   LLPipeline::RENDER_DEBUG_AVATAR_VOLUME |
  3178.   LLPipeline::RENDER_DEBUG_AGENT_TARGET |
  3179.   LLPipeline::RENDER_DEBUG_BUILD_QUEUE |
  3180.   LLPipeline::RENDER_DEBUG_SHADOW_FRUSTA)) 
  3181. {
  3182. return;
  3183. }
  3185. if (gPipeline.hasRenderDebugMask(LLPipeline::RENDER_DEBUG_TEXTURE_PRIORITY))
  3186. {
  3187. //sLastMaxTexPriority = lerp(sLastMaxTexPriority, sCurMaxTexPriority, gFrameIntervalSeconds);
  3188. sLastMaxTexPriority = (F32) LLViewerCamera::getInstance()->getScreenPixelArea();
  3189. sCurMaxTexPriority = 0.f;
  3190. }
  3192. LLMemType mt(LLMemType::MTYPE_SPACE_PARTITION);
  3194. LLGLDisable cullface(GL_CULL_FACE);
  3195. LLGLEnable blend(GL_BLEND);
  3196. gGL.setSceneBlendType(LLRender::BT_ALPHA);
  3197. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  3198. gPipeline.disableLights();
  3200. LLSpatialBridge* bridge = asBridge();
  3201. LLCamera* camera = LLViewerCamera::getInstance();
  3203. if (bridge)
  3204. {
  3205. camera = NULL;
  3206. }
  3208. LLOctreeStateCheck checker;
  3209. checker.traverse(mOctree);
  3211. LLOctreeRenderNonOccluded render_debug(camera);
  3212. render_debug.traverse(mOctree);
  3213. }
  3215. void LLSpatialGroup::drawObjectBox(LLColor4 col)
  3216. {
  3217. gGL.color4fv(col.mV);
  3218. drawBox(mObjectBounds[0], mObjectBounds[1]*1.01f+LLVector3(0.001f, 0.001f, 0.001f));
  3219. }
  3222. BOOL LLSpatialPartition::isVisible(const LLVector3& v)
  3223. {
  3224. if (!LLViewerCamera::getInstance()->sphereInFrustum(v, 4.0f))
  3225. {
  3226. return FALSE;
  3227. }
  3229. return TRUE;
  3230. }
  3232. class LLOctreeIntersect : public LLSpatialGroup::OctreeTraveler
  3233. {
  3234. public:
  3235. LLVector3 mStart;
  3236. LLVector3 mEnd;
  3237. S32       *mFaceHit;
  3238. LLVector3 *mIntersection;
  3239. LLVector2 *mTexCoord;
  3240. LLVector3 *mNormal;
  3241. LLVector3 *mBinormal;
  3242. LLDrawable* mHit;
  3243. BOOL mPickTransparent;
  3245. LLOctreeIntersect(LLVector3 start, LLVector3 end, BOOL pick_transparent,
  3246.   S32* face_hit, LLVector3* intersection, LLVector2* tex_coord, LLVector3* normal, LLVector3* binormal)
  3247. : mStart(start),
  3248.   mEnd(end),
  3249.   mFaceHit(face_hit),
  3250.   mIntersection(intersection),
  3251.   mTexCoord(tex_coord),
  3252.   mNormal(normal),
  3253.   mBinormal(binormal),
  3254.   mHit(NULL),
  3255.   mPickTransparent(pick_transparent)
  3256. {
  3257. }
  3259. virtual void visit(const LLSpatialGroup::OctreeNode* branch) 
  3260. {
  3261. for (LLSpatialGroup::OctreeNode::const_element_iter i = branch->getData().begin(); i != branch->getData().end(); ++i)
  3262. {
  3263. check(*i);
  3264. }
  3265. }
  3267. virtual LLDrawable* check(const LLSpatialGroup::OctreeNode* node)
  3268. {
  3269. node->accept(this);
  3271. for (U32 i = 0; i < node->getChildCount(); i++)
  3272. {
  3273. const LLSpatialGroup::OctreeNode* child = node->getChild(i);
  3274. LLVector3 res;
  3276. LLSpatialGroup* group = (LLSpatialGroup*) child->getListener(0);
  3278. LLVector3 size;
  3279. LLVector3 center;
  3281. size = group->mBounds[1];
  3282. center = group->mBounds[0];
  3284. LLVector3 local_start = mStart;
  3285. LLVector3 local_end   = mEnd;
  3287. if (group->mSpatialPartition->isBridge())
  3288. {
  3289. LLMatrix4 local_matrix = group->mSpatialPartition->asBridge()->mDrawable->getRenderMatrix();
  3290. local_matrix.invert();
  3292. local_start = mStart * local_matrix;
  3293. local_end   = mEnd   * local_matrix;
  3294. }
  3296. if (LLLineSegmentBoxIntersect(local_start, local_end, center, size))
  3297. {
  3298. check(child);
  3299. }
  3300. }
  3302. return mHit;
  3303. }
  3305. virtual bool check(LLDrawable* drawable)
  3306. {
  3307. LLVector3 local_start = mStart;
  3308. LLVector3 local_end = mEnd;
  3310. if (!gPipeline.hasRenderType(drawable->getRenderType()) || !drawable->isVisible())
  3311. {
  3312. return false;
  3313. }
  3315. if (drawable->isSpatialBridge())
  3316. {
  3317. LLSpatialPartition *part = drawable->asPartition();
  3318. LLSpatialBridge* bridge = part->asBridge();
  3319. if (bridge && gPipeline.hasRenderType(bridge->mDrawableType))
  3320. {
  3321. check(part->mOctree);
  3322. }
  3323. }
  3324. else
  3325. {
  3326. LLViewerObject* vobj = drawable->getVObj();
  3328. if (vobj)
  3329. {
  3330. LLVector3 intersection;
  3331. if (vobj->lineSegmentIntersect(mStart, mEnd, -1, mPickTransparent, mFaceHit, &intersection, mTexCoord, mNormal, mBinormal))
  3332. {
  3333. mEnd = intersection;  // shorten ray so we only find CLOSER hits
  3334. if (mIntersection)
  3335. {
  3336. *mIntersection = intersection;
  3337. }
  3339. mHit = vobj->mDrawable;
  3340. }
  3341. }
  3342. }
  3344. return false;
  3345. }
  3346. };
  3348. LLDrawable* LLSpatialPartition::lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
  3349.  BOOL pick_transparent,
  3350.  S32* face_hit,                   // return the face hit
  3351.  LLVector3* intersection,         // return the intersection point
  3352.  LLVector2* tex_coord,            // return the texture coordinates of the intersection point
  3353.  LLVector3* normal,               // return the surface normal at the intersection point
  3354.  LLVector3* bi_normal             // return the surface bi-normal at the intersection point
  3355. )
  3357. {
  3358. LLOctreeIntersect intersect(start, end, pick_transparent, face_hit, intersection, tex_coord, normal, bi_normal);
  3359. LLDrawable* drawable = intersect.check(mOctree);
  3361. return drawable;
  3362. }
  3364. LLDrawInfo::LLDrawInfo(U16 start, U16 end, U32 count, U32 offset, 
  3365.    LLViewerTexture* texture, LLVertexBuffer* buffer,
  3366.    BOOL fullbright, U8 bump, BOOL particle, F32 part_size)
  3367. :
  3368. mVertexBuffer(buffer),
  3369. mTexture(texture),
  3370. mTextureMatrix(NULL),
  3371. mModelMatrix(NULL),
  3372. mStart(start),
  3373. mEnd(end),
  3374. mCount(count),
  3375. mOffset(offset), 
  3376. mFullbright(fullbright),
  3377. mBump(bump),
  3378. mParticle(particle),
  3379. mPartSize(part_size),
  3380. mVSize(0.f),
  3381. mGroup(NULL),
  3382. mFace(NULL),
  3383. mDistance(0.f)
  3384. {
  3385. mDebugColor = (rand() << 16) + rand();
  3386. if (mStart >= mVertexBuffer->getRequestedVerts() ||
  3387. mEnd >= mVertexBuffer->getRequestedVerts())
  3388. {
  3389. llerrs << "Invalid draw info vertex range." << llendl;
  3390. }
  3392. if (mOffset >= (U32) mVertexBuffer->getRequestedIndices() ||
  3393. mOffset + mCount > (U32) mVertexBuffer->getRequestedIndices())
  3394. {
  3395. llerrs << "Invalid draw info index range." << llendl;
  3396. }
  3397. }
  3399. LLDrawInfo::~LLDrawInfo()
  3400. {
  3401. /*if (LLSpatialGroup::sNoDelete)
  3402. {
  3403. llerrs << "LLDrawInfo deleted illegally!" << llendl;
  3404. }*/
  3406. if (mFace)
  3407. {
  3408. mFace->setDrawInfo(NULL);
  3409. }
  3410. }
  3412. LLVertexBuffer* LLGeometryManager::createVertexBuffer(U32 type_mask, U32 usage)
  3413. {
  3414. return new LLVertexBuffer(type_mask, usage);
  3415. }
  3417. LLCullResult::LLCullResult() 
  3418. {
  3419. clear();
  3420. }
  3422. void LLCullResult::clear()
  3423. {
  3424. mVisibleGroupsSize = 0;
  3425. mAlphaGroupsSize = 0;
  3426. mOcclusionGroupsSize = 0;
  3427. mDrawableGroupsSize = 0;
  3428. mVisibleListSize = 0;
  3429. mVisibleBridgeSize = 0;
  3431. for (U32 i = 0; i < LLRenderPass::NUM_RENDER_TYPES; i++)
  3432. {
  3433. for (U32 j = 0; j < mRenderMapSize[i]; j++)
  3434. {
  3435. mRenderMap[i][j] = 0;
  3436. }
  3437. mRenderMapSize[i] = 0;
  3438. }
  3439. }
  3441. LLCullResult::sg_list_t::iterator LLCullResult::beginVisibleGroups()
  3442. {
  3443. return mVisibleGroups.begin();
  3444. }
  3446. LLCullResult::sg_list_t::iterator LLCullResult::endVisibleGroups()
  3447. {
  3448. return mVisibleGroups.begin() + mVisibleGroupsSize;
  3449. }
  3451. LLCullResult::sg_list_t::iterator LLCullResult::beginAlphaGroups()
  3452. {
  3453. return mAlphaGroups.begin();
  3454. }
  3456. LLCullResult::sg_list_t::iterator LLCullResult::endAlphaGroups()
  3457. {
  3458. return mAlphaGroups.begin() + mAlphaGroupsSize;
  3459. }
  3461. LLCullResult::sg_list_t::iterator LLCullResult::beginOcclusionGroups()
  3462. {
  3463. return mOcclusionGroups.begin();
  3464. }
  3466. LLCullResult::sg_list_t::iterator LLCullResult::endOcclusionGroups()
  3467. {
  3468. return mOcclusionGroups.begin() + mOcclusionGroupsSize;
  3469. }
  3471. LLCullResult::sg_list_t::iterator LLCullResult::beginDrawableGroups()
  3472. {
  3473. return mDrawableGroups.begin();
  3474. }
  3476. LLCullResult::sg_list_t::iterator LLCullResult::endDrawableGroups()
  3477. {
  3478. return mDrawableGroups.begin() + mDrawableGroupsSize;
  3479. }
  3481. LLCullResult::drawable_list_t::iterator LLCullResult::beginVisibleList()
  3482. {
  3483. return mVisibleList.begin();
  3484. }
  3486. LLCullResult::drawable_list_t::iterator LLCullResult::endVisibleList()
  3487. {
  3488. return mVisibleList.begin() + mVisibleListSize;
  3489. }
  3491. LLCullResult::bridge_list_t::iterator LLCullResult::beginVisibleBridge()
  3492. {
  3493. return mVisibleBridge.begin();
  3494. }
  3496. LLCullResult::bridge_list_t::iterator LLCullResult::endVisibleBridge()
  3497. {
  3498. return mVisibleBridge.begin() + mVisibleBridgeSize;
  3499. }
  3501. LLCullResult::drawinfo_list_t::iterator LLCullResult::beginRenderMap(U32 type)
  3502. {
  3503. return mRenderMap[type].begin();
  3504. }
  3506. LLCullResult::drawinfo_list_t::iterator LLCullResult::endRenderMap(U32 type)
  3507. {
  3508. return mRenderMap[type].begin() + mRenderMapSize[type];
  3509. }
  3511. void LLCullResult::pushVisibleGroup(LLSpatialGroup* group)
  3512. {
  3513. if (mVisibleGroupsSize < mVisibleGroups.size())
  3514. {
  3515. mVisibleGroups[mVisibleGroupsSize] = group;
  3516. }
  3517. else
  3518. {
  3519. mVisibleGroups.push_back(group);
  3520. }
  3521. ++mVisibleGroupsSize;
  3522. }
  3524. void LLCullResult::pushAlphaGroup(LLSpatialGroup* group)
  3525. {
  3526. if (mAlphaGroupsSize < mAlphaGroups.size())
  3527. {
  3528. mAlphaGroups[mAlphaGroupsSize] = group;
  3529. }
  3530. else
  3531. {
  3532. mAlphaGroups.push_back(group);
  3533. }
  3534. ++mAlphaGroupsSize;
  3535. }
  3537. void LLCullResult::pushOcclusionGroup(LLSpatialGroup* group)
  3538. {
  3539. if (mOcclusionGroupsSize < mOcclusionGroups.size())
  3540. {
  3541. mOcclusionGroups[mOcclusionGroupsSize] = group;
  3542. }
  3543. else
  3544. {
  3545. mOcclusionGroups.push_back(group);
  3546. }
  3547. ++mOcclusionGroupsSize;
  3548. }
  3550. void LLCullResult::pushDrawableGroup(LLSpatialGroup* group)
  3551. {
  3552. if (mDrawableGroupsSize < mDrawableGroups.size())
  3553. {
  3554. mDrawableGroups[mDrawableGroupsSize] = group;
  3555. }
  3556. else
  3557. {
  3558. mDrawableGroups.push_back(group);
  3559. }
  3560. ++mDrawableGroupsSize;
  3561. }
  3563. void LLCullResult::pushDrawable(LLDrawable* drawable)
  3564. {
  3565. if (mVisibleListSize < mVisibleList.size())
  3566. {
  3567. mVisibleList[mVisibleListSize] = drawable;
  3568. }
  3569. else
  3570. {
  3571. mVisibleList.push_back(drawable);
  3572. }
  3573. ++mVisibleListSize;
  3574. }
  3576. void LLCullResult::pushBridge(LLSpatialBridge* bridge)
  3577. {
  3578. if (mVisibleBridgeSize < mVisibleBridge.size())
  3579. {
  3580. mVisibleBridge[mVisibleBridgeSize] = bridge;
  3581. }
  3582. else
  3583. {
  3584. mVisibleBridge.push_back(bridge);
  3585. }
  3586. ++mVisibleBridgeSize;
  3587. }
  3589. void LLCullResult::pushDrawInfo(U32 type, LLDrawInfo* draw_info)
  3590. {
  3591. if (mRenderMapSize[type] < mRenderMap[type].size())
  3592. {
  3593. mRenderMap[type][mRenderMapSize[type]] = draw_info;
  3594. }
  3595. else
  3596. {
  3597. mRenderMap[type].push_back(draw_info);
  3598. }
  3599. ++mRenderMapSize[type];
  3600. }
  3603. void LLCullResult::assertDrawMapsEmpty()
  3604. {
  3605. for (U32 i = 0; i < LLRenderPass::NUM_RENDER_TYPES; i++)
  3606. {
  3607. if (mRenderMapSize[i] != 0)
  3608. {
  3609. llerrs << "Stale LLDrawInfo's in LLCullResult!" << llendl;
  3610. }
  3611. }
  3612. }