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

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

游戏引擎

开发平台：

C++ Builder

llspatialpartition.h：源码内容
  1. /** 
  2.  * @file llspatialpartition.h
  3.  * @brief LLSpatialGroup header file including definitions for 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. #ifndef LL_LLSPATIALPARTITION_H
  34. #define LL_LLSPATIALPARTITION_H
  36. #define SG_MIN_DIST_RATIO 0.00001f
  38. #include "lldrawable.h"
  39. #include "lloctree.h"
  40. #include "llpointer.h"
  41. #include "llrefcount.h"
  42. #include "llvertexbuffer.h"
  43. #include "llgltypes.h"
  44. #include "llcubemap.h"
  45. #include "lldrawpool.h"
  46. #include "llface.h"
  47. #include "llviewercamera.h"
  49. #include <queue>
  51. #define SG_STATE_INHERIT_MASK (OCCLUDED)
  52. #define SG_INITIAL_STATE_MASK (DIRTY | GEOM_DIRTY)
  54. class LLSpatialPartition;
  55. class LLSpatialBridge;
  56. class LLSpatialGroup;
  57. class LLTextureAtlas;
  58. class LLTextureAtlasSlot;
  60. S32 AABBSphereIntersect(const LLVector3& min, const LLVector3& max, const LLVector3 &origin, const F32 &rad);
  61. S32 AABBSphereIntersectR2(const LLVector3& min, const LLVector3& max, const LLVector3 &origin, const F32 &radius_squared);
  63. // get index buffer for binary encoded axis vertex buffer given a box at center being viewed by given camera
  64. U8* get_box_fan_indices(LLCamera* camera, const LLVector3& center);
  66. class LLDrawInfo : public LLRefCount 
  67. {
  68. protected:
  69. ~LLDrawInfo();
  71. public:
  72. LLDrawInfo(U16 start, U16 end, U32 count, U32 offset, 
  73. LLViewerTexture* image, LLVertexBuffer* buffer, 
  74. BOOL fullbright = FALSE, U8 bump = 0, BOOL particle = FALSE, F32 part_size = 0);
  77. LLPointer<LLVertexBuffer> mVertexBuffer;
  78. LLPointer<LLViewerTexture>     mTexture;
  79. LLColor4U mGlowColor;
  80. S32 mDebugColor;
  81. const LLMatrix4* mTextureMatrix;
  82. const LLMatrix4* mModelMatrix;
  83. U16 mStart;
  84. U16 mEnd;
  85. U32 mCount;
  86. U32 mOffset;
  87. BOOL mFullbright;
  88. U8 mBump;
  89. BOOL mParticle;
  90. F32 mPartSize;
  91. F32 mVSize;
  92. LLSpatialGroup* mGroup;
  93. LLFace* mFace; //associated face
  94. F32 mDistance;
  95. LLVector3 mExtents[2];
  97. struct CompareTexture
  98. {
  99. bool operator()(const LLDrawInfo& lhs, const LLDrawInfo& rhs)
  100. {
  101. return lhs.mTexture > rhs.mTexture;
  102. }
  103. };
  105. struct CompareTexturePtr
  106. { //sort by texture
  107. bool operator()(const LLPointer<LLDrawInfo>& lhs, const LLPointer<LLDrawInfo>& rhs)
  108. {
  109. // sort by pointer, sort NULL down to the end
  110. return lhs.get() != rhs.get() 
  111. && (lhs.isNull() || (rhs.notNull() && lhs->mTexture.get() > rhs->mTexture.get()));
  112. }
  113. };
  115. struct CompareVertexBuffer
  116. { //sort by texture
  117. bool operator()(const LLPointer<LLDrawInfo>& lhs, const LLPointer<LLDrawInfo>& rhs)
  118. {
  119. // sort by pointer, sort NULL down to the end
  120. return lhs.get() != rhs.get() 
  121. && (lhs.isNull() || (rhs.notNull() && lhs->mVertexBuffer.get() > rhs->mVertexBuffer.get()));
  122. }
  123. };
  125. struct CompareTexturePtrMatrix
  126. {
  127. bool operator()(const LLPointer<LLDrawInfo>& lhs, const LLPointer<LLDrawInfo>& rhs)
  128. {
  129. return lhs.get() != rhs.get() 
  130. && (lhs.isNull() || (rhs.notNull() && (lhs->mTexture.get() > rhs->mTexture.get() ||
  131.    (lhs->mTexture.get() == rhs->mTexture.get() && lhs->mModelMatrix > rhs->mModelMatrix))));
  132. }
  134. };
  136. struct CompareBump
  137. {
  138. bool operator()(const LLPointer<LLDrawInfo>& lhs, const LLPointer<LLDrawInfo>& rhs) 
  139. {
  140. // sort by mBump value, sort NULL down to the end
  141. return lhs.get() != rhs.get() 
  142. && (lhs.isNull() || (rhs.notNull() && lhs->mBump > rhs->mBump));
  143. }
  144. };
  146. struct CompareDistanceGreater
  147. {
  148. bool operator()(const LLPointer<LLDrawInfo>& lhs, const LLPointer<LLDrawInfo>& rhs) 
  149. {
  150. // sort by mBump value, sort NULL down to the end
  151. return lhs.get() != rhs.get() 
  152. && (lhs.isNull() || (rhs.notNull() && lhs->mDistance > rhs->mDistance));
  153. }
  154. };
  155. };
  157. class LLSpatialGroup : public LLOctreeListener<LLDrawable>
  158. {
  159. friend class LLSpatialPartition;
  160. friend class LLOctreeStateCheck;
  161. public:
  162. static U32 sNodeCount;
  163. static BOOL sNoDelete; //deletion of spatial groups and draw info not allowed if TRUE
  165. typedef std::vector<LLPointer<LLSpatialGroup> > sg_vector_t;
  166. typedef std::set<LLPointer<LLSpatialGroup> > sg_set_t;
  167. typedef std::list<LLPointer<LLSpatialGroup> > sg_list_t;
  168. typedef std::vector<LLPointer<LLSpatialBridge> > bridge_list_t;
  169. typedef std::vector<LLPointer<LLDrawInfo> > drawmap_elem_t; 
  170. typedef std::map<U32, drawmap_elem_t > draw_map_t;
  171. typedef std::vector<LLPointer<LLVertexBuffer> > buffer_list_t;
  172. typedef std::map<LLPointer<LLViewerTexture>, buffer_list_t> buffer_texture_map_t;
  173. typedef std::map<U32, buffer_texture_map_t> buffer_map_t;
  175. typedef LLOctreeListener<LLDrawable> BaseType;
  176. typedef LLOctreeListener<LLDrawable> OctreeListener;
  177. typedef LLTreeNode<LLDrawable> TreeNode;
  178. typedef LLOctreeNode<LLDrawable> OctreeNode;
  179. typedef LLOctreeRoot<LLDrawable> OctreeRoot;
  180. typedef LLOctreeTraveler<LLDrawable> OctreeTraveler;
  181. typedef LLOctreeNode<LLDrawable>::element_iter element_iter;
  182. typedef LLOctreeNode<LLDrawable>::element_list element_list;
  184. struct CompareDistanceGreater
  185. {
  186. bool operator()(const LLSpatialGroup* const& lhs, const LLSpatialGroup* const& rhs)
  187. {
  188. return lhs->mDistance > rhs->mDistance;
  189. }
  190. };
  192. struct CompareUpdateUrgency
  193. {
  194. bool operator()(const LLPointer<LLSpatialGroup> lhs, const LLPointer<LLSpatialGroup> rhs)
  195. {
  196. return lhs->getUpdateUrgency() > rhs->getUpdateUrgency();
  197. }
  198. };
  200. struct CompareDepthGreater
  201. {
  202. bool operator()(const LLSpatialGroup* const& lhs, const LLSpatialGroup* const& rhs)
  203. {
  204. return lhs->mDepth > rhs->mDepth;
  205. }
  206. };
  208. typedef enum
  209. {
  210. OCCLUDED = 0x00010000,
  211. QUERY_PENDING = 0x00020000,
  212. ACTIVE_OCCLUSION = 0x00040000,
  213. DISCARD_QUERY = 0x00080000,
  214. EARLY_FAIL = 0x00100000,
  215. } eOcclusionState;
  217. typedef enum
  218. {
  219. DEAD = 0x00000001,
  220. DIRTY = 0x00000002,
  221. OBJECT_DIRTY = 0x00000004,
  222. GEOM_DIRTY = 0x00000008,
  223. ALPHA_DIRTY = 0x00000010,
  224. SKIP_FRUSTUM_CHECK = 0x00000020,
  225. IN_IMAGE_QUEUE = 0x00000040,
  226. IMAGE_DIRTY = 0x00000080,
  227. OCCLUSION_DIRTY = 0x00000100,
  228. MESH_DIRTY = 0x00000200,
  229. NEW_DRAWINFO = 0x00000400,
  230. IN_BUILD_Q1 = 0x00000800,
  231. IN_BUILD_Q2 = 0x00001000,
  232. STATE_MASK = 0x0000FFFF,
  233. } eSpatialState;
  235. typedef enum
  236. {
  237. STATE_MODE_SINGLE = 0, //set one node
  238. STATE_MODE_BRANCH, //set entire branch
  239. STATE_MODE_DIFF, //set entire branch as long as current state is different
  240. STATE_MODE_ALL_CAMERAS, //used for occlusion state, set state for all cameras
  241. } eSetStateMode;
  243. LLSpatialGroup(OctreeNode* node, LLSpatialPartition* part);
  245. BOOL isDead() { return isState(DEAD); }
  246. BOOL isState(U32 state) const;
  247. BOOL isOcclusionState(U32 state) const { return mOcclusionState[LLViewerCamera::sCurCameraID] & state ? TRUE : FALSE; }
  248. U32 getState() { return mState; }
  249. void setState(U32 state);
  250. void clearState(U32 state);
  252. void clearDrawMap();
  253. void validate();
  254. void checkStates();
  255. void validateDrawMap();
  257. void setState(U32 state, S32 mode);
  258. void clearState(U32 state, S32 mode);
  260. void setOcclusionState(U32 state, S32 mode = STATE_MODE_SINGLE);
  261. void clearOcclusionState(U32 state, S32 mode = STATE_MODE_SINGLE);
  263. LLSpatialGroup* getParent();
  266. BOOL addObject(LLDrawable *drawablep, BOOL add_all = FALSE, BOOL from_octree = FALSE);
  267. BOOL removeObject(LLDrawable *drawablep, BOOL from_octree = FALSE);
  268. BOOL updateInGroup(LLDrawable *drawablep, BOOL immediate = FALSE); // Update position if it's in the group
  269. BOOL isVisible() const;
  270. BOOL isRecentlyVisible() const;
  271. void setVisible();
  272. void shift(const LLVector3 &offset);
  273. BOOL boundObjects(BOOL empty, LLVector3& newMin, LLVector3& newMax);
  274. void unbound();
  275. BOOL rebound();
  276. void buildOcclusion(); //rebuild mOcclusionVerts
  277. void checkOcclusion(); //read back last occlusion query (if any)
  278. void doOcclusion(LLCamera* camera); //issue occlusion query
  279. void destroyGL();
  281. void updateDistance(LLCamera& camera);
  282. BOOL needsUpdate();
  283. F32 getUpdateUrgency() const;
  284. BOOL changeLOD();
  285. void rebuildGeom();
  286. void rebuildMesh();
  288. void dirtyGeom() { setState(GEOM_DIRTY); }
  289. void dirtyMesh() { setState(MESH_DIRTY); }
  290. element_list& getData() { return mOctreeNode->getData(); }
  291. U32 getElementCount() const { return mOctreeNode->getElementCount(); }
  293. void drawObjectBox(LLColor4 col);
  295.  //LISTENER FUNCTIONS
  296. virtual void handleInsertion(const TreeNode* node, LLDrawable* face);
  297. virtual void handleRemoval(const TreeNode* node, LLDrawable* face);
  298. virtual void handleDestruction(const TreeNode* node);
  299. virtual void handleStateChange(const TreeNode* node);
  300. virtual void handleChildAddition(const OctreeNode* parent, OctreeNode* child);
  301. virtual void handleChildRemoval(const OctreeNode* parent, const OctreeNode* child);
  303. //-------------------
  304. //for atlas use
  305. //-------------------
  306. //atlas
  307. void setCurUpdatingTime(U32 t) {mCurUpdatingTime = t ;}
  308. U32  getCurUpdatingTime() const { return mCurUpdatingTime ;}
  310. void setCurUpdatingSlot(LLTextureAtlasSlot* slotp) ;
  311. LLTextureAtlasSlot* getCurUpdatingSlot(LLViewerTexture* imagep, S8 recursive_level = 3) ;
  313. void setCurUpdatingTexture(LLViewerTexture* tex){ mCurUpdatingTexture = tex ;}
  314. LLViewerTexture* getCurUpdatingTexture() const { return mCurUpdatingTexture ;}
  316. BOOL hasAtlas(LLTextureAtlas* atlasp) ;
  317. LLTextureAtlas* getAtlas(S8 ncomponents, S8 to_be_reserved, S8 recursive_level = 3) ;
  318. void addAtlas(LLTextureAtlas* atlasp, S8 recursive_level = 3) ;
  319. void removeAtlas(LLTextureAtlas* atlasp, BOOL remove_group = TRUE, S8 recursive_level = 3) ;
  320. void clearAtlasList() ;
  321. private:
  322. U32                     mCurUpdatingTime ;
  323. //do not make the below two to use LLPointer
  324. //because mCurUpdatingTime invalidates them automatically.
  325. LLTextureAtlasSlot* mCurUpdatingSlotp ;
  326. LLViewerTexture*          mCurUpdatingTexture ;
  328. std::vector< std::list<LLTextureAtlas*> > mAtlasList ; 
  329. //-------------------
  330. //end for atlas use
  331. //-------------------
  333. protected:
  334. virtual ~LLSpatialGroup();
  336. U32 mState;
  337. U32 mOcclusionState[LLViewerCamera::NUM_CAMERAS];
  338. S32 mLODHash;
  339. static S32 sLODSeed;
  341. public:
  342. bridge_list_t mBridgeList;
  343. buffer_map_t mBufferMap; //used by volume buffers to store unique buffers per texture
  345. F32 mBuilt;
  346. OctreeNode* mOctreeNode;
  347. LLSpatialPartition* mSpatialPartition;
  348. LLVector3 mBounds[2];
  349. LLVector3 mExtents[2];
  351. LLVector3 mObjectExtents[2];
  352. LLVector3 mObjectBounds[2];
  354. LLPointer<LLVertexBuffer> mVertexBuffer;
  355. F32* mOcclusionVerts;
  356. GLuint mOcclusionQuery[LLViewerCamera::NUM_CAMERAS];
  358. U32 mBufferUsage;
  359. draw_map_t mDrawMap;
  361. S32 mVisible[LLViewerCamera::NUM_CAMERAS];
  362. F32 mDistance;
  363. F32 mDepth;
  364. F32 mLastUpdateDistance;
  365. F32 mLastUpdateTime;
  367. LLVector3 mViewAngle;
  368. LLVector3 mLastUpdateViewAngle;
  370. F32 mPixelArea;
  371. F32 mRadius;
  372. };
  374. class LLGeometryManager
  375. {
  376. public:
  377. std::vector<LLFace*> mFaceList;
  378. virtual ~LLGeometryManager() { }
  379. virtual void rebuildGeom(LLSpatialGroup* group) = 0;
  380. virtual void rebuildMesh(LLSpatialGroup* group) = 0;
  381. virtual void getGeometry(LLSpatialGroup* group) = 0;
  382. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32 &index_count);
  384. virtual LLVertexBuffer* createVertexBuffer(U32 type_mask, U32 usage);
  385. };
  387. class LLSpatialPartition: public LLGeometryManager
  388. {
  389. public:
  390. LLSpatialPartition(U32 data_mask,  BOOL render_by_group, U32 mBufferUsage);
  391. virtual ~LLSpatialPartition();
  393. LLSpatialGroup *put(LLDrawable *drawablep, BOOL was_visible = FALSE);
  394. BOOL remove(LLDrawable *drawablep, LLSpatialGroup *curp);
  396. LLDrawable* lineSegmentIntersect(const LLVector3& start, const LLVector3& end,
  397.  BOOL pick_transparent, 
  398.  S32* face_hit,                          // return the face hit
  399.  LLVector3* intersection = NULL,         // return the intersection point
  400.  LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
  401.  LLVector3* normal = NULL,               // return the surface normal at the intersection point
  402.  LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point
  403. );
  406. // If the drawable moves, move it here.
  407. virtual void move(LLDrawable *drawablep, LLSpatialGroup *curp, BOOL immediate = FALSE);
  408. virtual void shift(const LLVector3 &offset);
  410. virtual F32 calcDistance(LLSpatialGroup* group, LLCamera& camera);
  411. virtual F32 calcPixelArea(LLSpatialGroup* group, LLCamera& camera);
  413. virtual void rebuildGeom(LLSpatialGroup* group);
  414. virtual void rebuildMesh(LLSpatialGroup* group);
  416. BOOL visibleObjectsInFrustum(LLCamera& camera);
  417. S32 cull(LLCamera &camera, std::vector<LLDrawable *>* results = NULL, BOOL for_select = FALSE); // Cull on arbitrary frustum
  419. BOOL isVisible(const LLVector3& v);
  421. virtual LLSpatialBridge* asBridge() { return NULL; }
  422. virtual BOOL isBridge() { return asBridge() != NULL; }
  424. void renderDebug();
  425. void renderIntersectingBBoxes(LLCamera* camera);
  426. void restoreGL();
  427. void resetVertexBuffers();
  428. BOOL isOcclusionEnabled();
  429. BOOL getVisibleExtents(LLCamera& camera, LLVector3& visMin, LLVector3& visMax);
  431. public:
  432. LLSpatialGroup::OctreeNode* mOctree;
  433. BOOL mOcclusionEnabled; // if TRUE, occlusion culling is performed
  434. BOOL mInfiniteFarClip; // if TRUE, frustum culling ignores far clip plane
  435. U32 mBufferUsage;
  436. const BOOL mRenderByGroup;
  437. U32 mLODSeed;
  438. U32 mLODPeriod; //number of frames between LOD updates for a given spatial group (staggered by mLODSeed)
  439. U32 mVertexDataMask;
  440. F32 mSlopRatio; //percentage distance must change before drawables receive LOD update (default is 0.25);
  441. BOOL mDepthMask; //if TRUE, objects in this partition will be written to depth during alpha rendering
  442. U32 mDrawableType;
  443. U32 mPartitionType;
  444. };
  446. // class for creating bridges between spatial partitions
  447. class LLSpatialBridge : public LLDrawable, public LLSpatialPartition
  448. {
  449. protected:
  450. ~LLSpatialBridge();
  452. public:
  453. typedef std::vector<LLPointer<LLSpatialBridge> > bridge_vector_t;
  455. LLSpatialBridge(LLDrawable* root, BOOL render_by_group, U32 data_mask);
  457. virtual BOOL isSpatialBridge() const { return TRUE; }
  459. virtual void updateSpatialExtents();
  460. virtual void updateBinRadius();
  461. virtual void setVisible(LLCamera& camera_in, std::vector<LLDrawable*>* results = NULL, BOOL for_select = FALSE);
  462. virtual void updateDistance(LLCamera& camera_in, bool force_update);
  463. virtual void makeActive();
  464. virtual void move(LLDrawable *drawablep, LLSpatialGroup *curp, BOOL immediate = FALSE);
  465. virtual BOOL updateMove();
  466. virtual void shiftPos(const LLVector3& vec);
  467. virtual void cleanupReferences();
  468. virtual LLSpatialPartition* asPartition() { return this; }
  469. virtual LLSpatialBridge* asBridge() { return this; }
  471. virtual LLCamera transformCamera(LLCamera& camera);
  473. LLDrawable* mDrawable;
  474. };
  476. class LLCullResult 
  477. {
  478. public:
  479. LLCullResult();
  481. typedef std::vector<LLSpatialGroup*> sg_list_t;
  482. typedef std::vector<LLDrawable*> drawable_list_t;
  483. typedef std::vector<LLSpatialBridge*> bridge_list_t;
  484. typedef std::vector<LLDrawInfo*> drawinfo_list_t;
  486. void clear();
  488. sg_list_t::iterator beginVisibleGroups();
  489. sg_list_t::iterator endVisibleGroups();
  491. sg_list_t::iterator beginAlphaGroups();
  492. sg_list_t::iterator endAlphaGroups();
  494. sg_list_t::iterator beginOcclusionGroups();
  495. sg_list_t::iterator endOcclusionGroups();
  497. sg_list_t::iterator beginDrawableGroups();
  498. sg_list_t::iterator endDrawableGroups();
  500. drawable_list_t::iterator beginVisibleList();
  501. drawable_list_t::iterator endVisibleList();
  503. bridge_list_t::iterator beginVisibleBridge();
  504. bridge_list_t::iterator endVisibleBridge();
  506. drawinfo_list_t::iterator beginRenderMap(U32 type);
  507. drawinfo_list_t::iterator endRenderMap(U32 type);
  509. void pushVisibleGroup(LLSpatialGroup* group);
  510. void pushAlphaGroup(LLSpatialGroup* group);
  511. void pushOcclusionGroup(LLSpatialGroup* group);
  512. void pushDrawableGroup(LLSpatialGroup* group);
  513. void pushDrawable(LLDrawable* drawable);
  514. void pushBridge(LLSpatialBridge* bridge);
  515. void pushDrawInfo(U32 type, LLDrawInfo* draw_info);
  517. U32 getVisibleGroupsSize() { return mVisibleGroupsSize; }
  518. U32 getAlphaGroupsSize() { return mAlphaGroupsSize; }
  519. U32 getDrawableGroupsSize() { return mDrawableGroupsSize; }
  520. U32 getVisibleListSize() { return mVisibleListSize; }
  521. U32 getVisibleBridgeSize() { return mVisibleBridgeSize; }
  522. U32 getRenderMapSize(U32 type) { return mRenderMapSize[type]; }
  524. void assertDrawMapsEmpty();
  526. private:
  527. U32 mVisibleGroupsSize;
  528. U32 mAlphaGroupsSize;
  529. U32 mOcclusionGroupsSize;
  530. U32 mDrawableGroupsSize;
  531. U32 mVisibleListSize;
  532. U32 mVisibleBridgeSize;
  533. U32 mRenderMapSize[LLRenderPass::NUM_RENDER_TYPES];
  535. sg_list_t mVisibleGroups;
  536. sg_list_t mAlphaGroups;
  537. sg_list_t mOcclusionGroups;
  538. sg_list_t mDrawableGroups;
  539. drawable_list_t mVisibleList;
  540. bridge_list_t mVisibleBridge;
  541. drawinfo_list_t mRenderMap[LLRenderPass::NUM_RENDER_TYPES];
  542. };
  545. //spatial partition for water (implemented in LLVOWater.cpp)
  546. class LLWaterPartition : public LLSpatialPartition
  547. {
  548. public:
  549. LLWaterPartition();
  550. virtual void getGeometry(LLSpatialGroup* group) {  }
  551. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) { }
  552. };
  554. //spatial partition for terrain (impelmented in LLVOSurfacePatch.cpp)
  555. class LLTerrainPartition : public LLSpatialPartition
  556. {
  557. public:
  558. LLTerrainPartition();
  559. virtual void getGeometry(LLSpatialGroup* group);
  560. virtual LLVertexBuffer* createVertexBuffer(U32 type_mask, U32 usage);
  561. };
  563. //spatial partition for trees
  564. class LLTreePartition : public LLSpatialPartition
  565. {
  566. public:
  567. LLTreePartition();
  568. virtual void getGeometry(LLSpatialGroup* group) { }
  569. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) { }
  571. };
  573. //spatial partition for particles (implemented in LLVOPartGroup.cpp)
  574. class LLParticlePartition : public LLSpatialPartition
  575. {
  576. public:
  577. LLParticlePartition();
  578. virtual void getGeometry(LLSpatialGroup* group);
  579. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count);
  580. virtual F32 calcPixelArea(LLSpatialGroup* group, LLCamera& camera);
  581. protected:
  582. U32 mRenderPass;
  583. };
  585. class LLHUDParticlePartition : public LLParticlePartition
  586. {
  587. public:
  588. LLHUDParticlePartition();
  589. };
  591. //spatial partition for grass (implemented in LLVOGrass.cpp)
  592. class LLGrassPartition : public LLParticlePartition
  593. {
  594. public:
  595. LLGrassPartition();
  596. };
  598. //spatial partition for clouds (implemented in LLVOClouds.cpp)
  599. class LLCloudPartition : public LLParticlePartition
  600. {
  601. public:
  602. LLCloudPartition();
  603. };
  605. //class for wrangling geometry out of volumes (implemented in LLVOVolume.cpp)
  606. class LLVolumeGeometryManager: public LLGeometryManager
  607. {
  608. public:
  609. virtual ~LLVolumeGeometryManager() { }
  610. virtual void rebuildGeom(LLSpatialGroup* group);
  611. virtual void rebuildMesh(LLSpatialGroup* group);
  612. virtual void getGeometry(LLSpatialGroup* group);
  613. void genDrawInfo(LLSpatialGroup* group, U32 mask, std::vector<LLFace*>& faces, BOOL distance_sort = FALSE);
  614. void registerFace(LLSpatialGroup* group, LLFace* facep, U32 type);
  616. };
  618. //spatial partition that uses volume geometry manager (implemented in LLVOVolume.cpp)
  619. class LLVolumePartition : public LLSpatialPartition, public LLVolumeGeometryManager
  620. {
  621. public:
  622. LLVolumePartition();
  623. virtual void rebuildGeom(LLSpatialGroup* group) { LLVolumeGeometryManager::rebuildGeom(group); }
  624. virtual void getGeometry(LLSpatialGroup* group) { LLVolumeGeometryManager::getGeometry(group); }
  625. virtual void rebuildMesh(LLSpatialGroup* group) { LLVolumeGeometryManager::rebuildMesh(group); }
  626. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) { LLVolumeGeometryManager::addGeometryCount(group, vertex_count, index_count); }
  627. };
  629. //spatial bridge that uses volume geometry manager (implemented in LLVOVolume.cpp)
  630. class LLVolumeBridge : public LLSpatialBridge, public LLVolumeGeometryManager
  631. {
  632. public:
  633. LLVolumeBridge(LLDrawable* drawable);
  634. virtual void rebuildGeom(LLSpatialGroup* group) { LLVolumeGeometryManager::rebuildGeom(group); }
  635. virtual void getGeometry(LLSpatialGroup* group) { LLVolumeGeometryManager::getGeometry(group); }
  636. virtual void rebuildMesh(LLSpatialGroup* group) { LLVolumeGeometryManager::rebuildMesh(group); }
  637. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) { LLVolumeGeometryManager::addGeometryCount(group, vertex_count, index_count); }
  638. };
  640. class LLHUDBridge : public LLVolumeBridge
  641. {
  642. public:
  643. LLHUDBridge(LLDrawable* drawablep);
  644. virtual void shiftPos(const LLVector3& vec);
  645. virtual F32 calcPixelArea(LLSpatialGroup* group, LLCamera& camera);
  646. };
  648. //spatial partition that holds nothing but spatial bridges
  649. class LLBridgePartition : public LLSpatialPartition
  650. {
  651. public:
  652. LLBridgePartition();
  653. virtual void getGeometry(LLSpatialGroup* group) { }
  654. virtual void addGeometryCount(LLSpatialGroup* group, U32 &vertex_count, U32& index_count) {  }
  655. };
  657. class LLHUDPartition : public LLBridgePartition
  658. {
  659. public:
  660. LLHUDPartition();
  661. virtual void shift(const LLVector3 &offset);
  662. };
  664. void validate_draw_info(LLDrawInfo& params);
  666. extern const F32 SG_BOX_SIDE;
  667. extern const F32 SG_BOX_OFFSET;
  668. extern const F32 SG_BOX_RAD;
  670. extern const F32 SG_OBJ_SIDE;
  671. extern const F32 SG_MAX_OBJ_RAD;
  674. #endif //LL_LLSPATIALPARTITION_H