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

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

游戏引擎

开发平台：

C++ Builder

pipeline.h：源码内容
  1. /** 
  2.  * @file pipeline.h
  3.  * @brief Rendering pipeline definitions
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-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_PIPELINE_H
  34. #define LL_PIPELINE_H
  36. #include "llcamera.h"
  37. #include "llerror.h"
  38. #include "lldarrayptr.h"
  39. #include "lldqueueptr.h"
  40. #include "lldrawpool.h"
  41. #include "llspatialpartition.h"
  42. #include "m4math.h"
  43. #include "llpointer.h"
  44. #include "lldrawpool.h"
  45. #include "llgl.h"
  46. #include "lldrawable.h"
  47. #include "llrendertarget.h"
  49. class LLViewerTexture;
  50. class LLEdge;
  51. class LLFace;
  52. class LLViewerObject;
  53. class LLAgent;
  54. class LLDisplayPrimitive;
  55. class LLTextureEntry;
  56. class LLRenderFunc;
  57. class LLCubeMap;
  58. class LLCullResult;
  59. class LLVOAvatar;
  60. class LLGLSLShader;
  62. typedef enum e_avatar_skinning_method
  63. {
  64. SKIN_METHOD_SOFTWARE,
  65. SKIN_METHOD_VERTEX_PROGRAM
  66. } EAvatarSkinningMethod;
  68. BOOL compute_min_max(LLMatrix4& box, LLVector2& min, LLVector2& max); // Shouldn't be defined here!
  69. bool LLRayAABB(const LLVector3 &center, const LLVector3 &size, const LLVector3& origin, const LLVector3& dir, LLVector3 &coord, F32 epsilon = 0);
  70. BOOL setup_hud_matrices(); // use whole screen to render hud
  71. BOOL setup_hud_matrices(const LLRect& screen_region); // specify portion of screen (in pixels) to render hud attachments from (for picking)
  72. glh::matrix4f glh_copy_matrix(GLdouble* src);
  73. glh::matrix4f glh_get_current_modelview();
  74. void glh_set_current_modelview(const glh::matrix4f& mat);
  75. glh::matrix4f glh_get_current_projection();
  76. void glh_set_current_projection(glh::matrix4f& mat);
  77. glh::matrix4f gl_ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat znear, GLfloat zfar);
  78. glh::matrix4f gl_perspective(GLfloat fovy, GLfloat aspect, GLfloat zNear, GLfloat zFar);
  79. glh::matrix4f gl_lookat(LLVector3 eye, LLVector3 center, LLVector3 up);
  81. extern LLFastTimer::DeclareTimer FTM_RENDER_GEOMETRY;
  82. extern LLFastTimer::DeclareTimer FTM_RENDER_GRASS;
  83. extern LLFastTimer::DeclareTimer FTM_RENDER_INVISIBLE;
  84. extern LLFastTimer::DeclareTimer FTM_RENDER_OCCLUSION;
  85. extern LLFastTimer::DeclareTimer FTM_RENDER_SHINY;
  86. extern LLFastTimer::DeclareTimer FTM_RENDER_SIMPLE;
  87. extern LLFastTimer::DeclareTimer FTM_RENDER_TERRAIN;
  88. extern LLFastTimer::DeclareTimer FTM_RENDER_TREES;
  89. extern LLFastTimer::DeclareTimer FTM_RENDER_UI;
  90. extern LLFastTimer::DeclareTimer FTM_RENDER_WATER;
  91. extern LLFastTimer::DeclareTimer FTM_RENDER_WL_SKY;
  92. extern LLFastTimer::DeclareTimer FTM_RENDER_ALPHA;
  93. extern LLFastTimer::DeclareTimer FTM_RENDER_CHARACTERS;
  94. extern LLFastTimer::DeclareTimer FTM_RENDER_BUMP;
  95. extern LLFastTimer::DeclareTimer FTM_RENDER_FULLBRIGHT;
  96. extern LLFastTimer::DeclareTimer FTM_RENDER_GLOW;
  97. extern LLFastTimer::DeclareTimer FTM_STATESORT;
  98. extern LLFastTimer::DeclareTimer FTM_PIPELINE;
  99. extern LLFastTimer::DeclareTimer FTM_CLIENT_COPY;
  102. class LLPipeline
  103. {
  104. public:
  105. LLPipeline();
  106. ~LLPipeline();
  108. void destroyGL();
  109. void restoreGL();
  110. void resetVertexBuffers();
  111. void resizeScreenTexture();
  112. void releaseGLBuffers();
  113. void createGLBuffers();
  114. void allocateScreenBuffer(U32 resX, U32 resY);
  116. void resetVertexBuffers(LLDrawable* drawable);
  117. void setUseVBO(BOOL use_vbo);
  118. void generateImpostor(LLVOAvatar* avatar);
  119. void bindScreenToTexture();
  120. void renderBloom(BOOL for_snapshot, F32 zoom_factor = 1.f, int subfield = 0);
  122. void init();
  123. void cleanup();
  124. BOOL isInit() { return mInitialized; };
  126. /// @brief Get a draw pool from pool type (POOL_SIMPLE, POOL_MEDIA) and texture.
  127. /// @return Draw pool, or NULL if not found.
  128. LLDrawPool *findPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
  130. /// @brief Get a draw pool for faces of the appropriate type and texture.  Create if necessary.
  131. /// @return Always returns a draw pool.
  132. LLDrawPool *getPool(const U32 pool_type, LLViewerTexture *tex0 = NULL);
  134. /// @brief Figures out draw pool type from texture entry. Creates pool if necessary.
  135. static LLDrawPool* getPoolFromTE(const LLTextureEntry* te, LLViewerTexture* te_image);
  136. static U32 getPoolTypeFromTE(const LLTextureEntry* te, LLViewerTexture* imagep);
  138. void  addPool(LLDrawPool *poolp); // Only to be used by LLDrawPool classes for splitting pools!
  139. void  removePool( LLDrawPool* poolp );
  141. void  allocDrawable(LLViewerObject *obj);
  143. void  unlinkDrawable(LLDrawable*);
  145. // Object related methods
  146. void        markVisible(LLDrawable *drawablep, LLCamera& camera);
  147. void markOccluder(LLSpatialGroup* group);
  148. void doOcclusion(LLCamera& camera);
  149. void markNotCulled(LLSpatialGroup* group, LLCamera &camera);
  150. void        markMoved(LLDrawable *drawablep, BOOL damped_motion = FALSE);
  151. void        markShift(LLDrawable *drawablep);
  152. void        markTextured(LLDrawable *drawablep);
  153. void markGLRebuild(LLGLUpdate* glu);
  154. void markRebuild(LLSpatialGroup* group, BOOL priority = FALSE);
  155. void        markRebuild(LLDrawable *drawablep, LLDrawable::EDrawableFlags flag = LLDrawable::REBUILD_ALL, BOOL priority = FALSE);
  157. //get the object between start and end that's closest to start.
  158. LLViewerObject* lineSegmentIntersectInWorld(const LLVector3& start, const LLVector3& end,
  159. BOOL pick_transparent,
  160. S32* face_hit,                          // return the face hit
  161. LLVector3* intersection = NULL,         // return the intersection point
  162. LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
  163. LLVector3* normal = NULL,               // return the surface normal at the intersection point
  164. LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point  
  165. );
  166. LLViewerObject* lineSegmentIntersectInHUD(const LLVector3& start, const LLVector3& end,
  167.   BOOL pick_transparent,
  168.   S32* face_hit,                          // return the face hit
  169.   LLVector3* intersection = NULL,         // return the intersection point
  170.   LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
  171.   LLVector3* normal = NULL,               // return the surface normal at the intersection point
  172.   LLVector3* bi_normal = NULL             // return the surface bi-normal at the intersection point
  173. );
  175. // Something about these textures has changed.  Dirty them.
  176. void        dirtyPoolObjectTextures(const std::set<LLViewerFetchedTexture*>& textures);
  178. void        resetDrawOrders();
  180. U32         addObject(LLViewerObject *obj);
  182. void enableShadows(const BOOL enable_shadows);
  184. //  void setLocalLighting(const BOOL local_lighting);
  185. //  BOOL isLocalLightingEnabled() const;
  186. S32 setLightingDetail(S32 level);
  187. S32 getLightingDetail() const { return mLightingDetail; }
  188. S32 getMaxLightingDetail() const;
  190. void setUseVertexShaders(BOOL use_shaders);
  191. BOOL getUseVertexShaders() const { return mVertexShadersEnabled; }
  192. BOOL canUseVertexShaders();
  193. BOOL canUseWindLightShaders() const;
  194. BOOL canUseWindLightShadersOnObjects() const;
  196. // phases
  197. void resetFrameStats();
  199. void updateMoveDampedAsync(LLDrawable* drawablep);
  200. void updateMoveNormalAsync(LLDrawable* drawablep);
  201. void updateMovedList(LLDrawable::drawable_vector_t& move_list);
  202. void updateMove();
  203. BOOL visibleObjectsInFrustum(LLCamera& camera);
  204. BOOL getVisibleExtents(LLCamera& camera, LLVector3 &min, LLVector3& max);
  205. BOOL getVisiblePointCloud(LLCamera& camera, LLVector3 &min, LLVector3& max, std::vector<LLVector3>& fp, LLVector3 light_dir = LLVector3(0,0,0));
  206. void updateCull(LLCamera& camera, LLCullResult& result, S32 water_clip = 0);  //if water_clip is 0, ignore water plane, 1, cull to above plane, -1, cull to below plane
  207. void createObjects(F32 max_dtime);
  208. void createObject(LLViewerObject* vobj);
  209. void updateGeom(F32 max_dtime);
  210. void updateGL();
  211. void rebuildPriorityGroups();
  212. void rebuildGroups();
  214. //calculate pixel area of given box from vantage point of given camera
  215. static F32 calcPixelArea(LLVector3 center, LLVector3 size, LLCamera& camera);
  217. void stateSort(LLCamera& camera, LLCullResult& result);
  218. void stateSort(LLSpatialGroup* group, LLCamera& camera);
  219. void stateSort(LLSpatialBridge* bridge, LLCamera& camera);
  220. void stateSort(LLDrawable* drawablep, LLCamera& camera);
  221. void postSort(LLCamera& camera);
  222. void forAllVisibleDrawables(void (*func)(LLDrawable*));
  224. void renderObjects(U32 type, U32 mask, BOOL texture = TRUE);
  225. void renderGroups(LLRenderPass* pass, U32 type, U32 mask, BOOL texture);
  227. void grabReferences(LLCullResult& result);
  229. void renderGeom(LLCamera& camera, BOOL forceVBOUpdate = FALSE);
  230. void renderGeomDeferred(LLCamera& camera);
  231. void renderGeomPostDeferred(LLCamera& camera);
  232. void renderGeomShadow(LLCamera& camera);
  233. void bindDeferredShader(LLGLSLShader& shader, U32 light_index = 0, LLRenderTarget* gi_source = NULL, LLRenderTarget* last_gi_post = NULL, U32 noise_map = 0xFFFFFFFF);
  234. void setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep);
  236. void unbindDeferredShader(LLGLSLShader& shader);
  237. void renderDeferredLighting();
  239. void generateWaterReflection(LLCamera& camera);
  240. void generateSunShadow(LLCamera& camera);
  241. void generateHighlight(LLCamera& camera);
  242. void renderHighlight(const LLViewerObject* obj, F32 fade);
  243. void setHighlightObject(LLDrawable* obj) { mHighlightObject = obj; }
  246. void renderShadow(glh::matrix4f& view, glh::matrix4f& proj, LLCamera& camera, LLCullResult& result, BOOL use_shader = TRUE, BOOL use_occlusion = TRUE);
  247. void generateGI(LLCamera& camera, LLVector3& lightDir, std::vector<LLVector3>& vpc);
  248. void renderHighlights();
  249. void renderDebug();
  251. void renderForSelect(std::set<LLViewerObject*>& objects, BOOL render_transparent, const LLRect& screen_rect);
  252. void rebuildPools(); // Rebuild pools
  254. void findReferences(LLDrawable *drawablep); // Find the lists which have references to this object
  255. BOOL verify(); // Verify that all data in the pipeline is "correct"
  257. S32  getLightCount() const { return mLights.size(); }
  259. void calcNearbyLights(LLCamera& camera);
  260. void setupHWLights(LLDrawPool* pool);
  261. void setupAvatarLights(BOOL for_edit = FALSE);
  262. void enableLights(U32 mask);
  263. void enableLightsStatic();
  264. void enableLightsDynamic();
  265. void enableLightsAvatar();
  266. void enableLightsAvatarEdit(const LLColor4& color);
  267. void enableLightsFullbright(const LLColor4& color);
  268. void disableLights();
  270. void shiftObjects(const LLVector3 &offset);
  272. void setLight(LLDrawable *drawablep, BOOL is_light);
  273. void setActive(LLDrawable *drawablep, BOOL active);
  275. BOOL hasRenderBatches(const U32 type) const;
  276. LLCullResult::drawinfo_list_t::iterator beginRenderMap(U32 type);
  277. LLCullResult::drawinfo_list_t::iterator endRenderMap(U32 type);
  278. LLCullResult::sg_list_t::iterator beginAlphaGroups();
  279. LLCullResult::sg_list_t::iterator endAlphaGroups();
  281. void addTrianglesDrawn(S32 count);
  282. BOOL hasRenderType(const U32 type) const { return (type && (mRenderTypeMask & (1<<type))) ? TRUE : FALSE; }
  283. BOOL hasRenderDebugFeatureMask(const U32 mask) const { return (mRenderDebugFeatureMask & mask) ? TRUE : FALSE; }
  284. BOOL hasRenderDebugMask(const U32 mask) const { return (mRenderDebugMask & mask) ? TRUE : FALSE; }
  285. void setRenderTypeMask(const U32 mask) { mRenderTypeMask = mask; }
  286. U32  getRenderTypeMask() const { return mRenderTypeMask; }
  287. static void toggleRenderType(U32 type);
  289. // For UI control of render features
  290. static BOOL hasRenderTypeControl(void* data);
  291. static void toggleRenderDebug(void* data);
  292. static void toggleRenderDebugFeature(void* data);
  293. static void toggleRenderTypeControl(void* data);
  294. static BOOL toggleRenderTypeControlNegated(void* data);
  295. static BOOL toggleRenderDebugControl(void* data);
  296. static BOOL toggleRenderDebugFeatureControl(void* data);
  298. static void setRenderParticleBeacons(BOOL val);
  299. static void toggleRenderParticleBeacons(void* data);
  300. static BOOL getRenderParticleBeacons(void* data);
  302. static void setRenderSoundBeacons(BOOL val);
  303. static void toggleRenderSoundBeacons(void* data);
  304. static BOOL getRenderSoundBeacons(void* data);
  306. static void setRenderPhysicalBeacons(BOOL val);
  307. static void toggleRenderPhysicalBeacons(void* data);
  308. static BOOL getRenderPhysicalBeacons(void* data);
  310. static void setRenderScriptedBeacons(BOOL val);
  311. static void toggleRenderScriptedBeacons(void* data);
  312. static BOOL getRenderScriptedBeacons(void* data);
  314. static void setRenderScriptedTouchBeacons(BOOL val);
  315. static void toggleRenderScriptedTouchBeacons(void* data);
  316. static BOOL getRenderScriptedTouchBeacons(void* data);
  318. static void setRenderBeacons(BOOL val);
  319. static void toggleRenderBeacons(void* data);
  320. static BOOL getRenderBeacons(void* data);
  322. static void setRenderHighlights(BOOL val);
  323. static void toggleRenderHighlights(void* data);
  324. static BOOL getRenderHighlights(void* data);
  326. static void updateRenderDeferred();
  328. private:
  329. void unloadShaders();
  330. void addToQuickLookup( LLDrawPool* new_poolp );
  331. void removeFromQuickLookup( LLDrawPool* poolp );
  332. BOOL updateDrawableGeom(LLDrawable* drawable, BOOL priority);
  333. void assertInitializedDoError();
  334. bool assertInitialized() { const bool is_init = isInit(); if (!is_init) assertInitializedDoError(); return is_init; };
  336. public:
  337. enum {GPU_CLASS_MAX = 3 };
  339. enum LLRenderTypeMask
  340. {
  341. // Following are pool types (some are also object types)
  342. RENDER_TYPE_SKY = LLDrawPool::POOL_SKY,
  343. RENDER_TYPE_WL_SKY = LLDrawPool::POOL_WL_SKY,
  344. RENDER_TYPE_GROUND = LLDrawPool::POOL_GROUND,
  345. RENDER_TYPE_TERRAIN = LLDrawPool::POOL_TERRAIN,
  346. RENDER_TYPE_SIMPLE = LLDrawPool::POOL_SIMPLE,
  347. RENDER_TYPE_GRASS = LLDrawPool::POOL_GRASS,
  348. RENDER_TYPE_FULLBRIGHT = LLDrawPool::POOL_FULLBRIGHT,
  349. RENDER_TYPE_BUMP = LLDrawPool::POOL_BUMP,
  350. RENDER_TYPE_AVATAR = LLDrawPool::POOL_AVATAR,
  351. RENDER_TYPE_TREE = LLDrawPool::POOL_TREE,
  352. RENDER_TYPE_INVISIBLE = LLDrawPool::POOL_INVISIBLE,
  353. RENDER_TYPE_WATER = LLDrawPool::POOL_WATER,
  354.   RENDER_TYPE_ALPHA = LLDrawPool::POOL_ALPHA,
  355. RENDER_TYPE_GLOW = LLDrawPool::POOL_GLOW,
  356. RENDER_TYPE_PASS_SIMPLE  = LLRenderPass::PASS_SIMPLE,
  357. RENDER_TYPE_PASS_GRASS = LLRenderPass::PASS_GRASS,
  358. RENDER_TYPE_PASS_FULLBRIGHT = LLRenderPass::PASS_FULLBRIGHT,
  359. RENDER_TYPE_PASS_INVISIBLE = LLRenderPass::PASS_INVISIBLE,
  360. RENDER_TYPE_PASS_INVISI_SHINY = LLRenderPass::PASS_INVISI_SHINY,
  361. RENDER_TYPE_PASS_FULLBRIGHT_SHINY = LLRenderPass::PASS_FULLBRIGHT_SHINY,
  362. RENDER_TYPE_PASS_SHINY = LLRenderPass::PASS_SHINY,
  363. RENDER_TYPE_PASS_BUMP = LLRenderPass::PASS_BUMP,
  364. RENDER_TYPE_PASS_GLOW = LLRenderPass::PASS_GLOW,
  365. RENDER_TYPE_PASS_ALPHA = LLRenderPass::PASS_ALPHA,
  366. RENDER_TYPE_PASS_ALPHA_MASK = LLRenderPass::PASS_ALPHA_MASK,
  367. RENDER_TYPE_PASS_FULLBRIGHT_ALPHA_MASK = LLRenderPass::PASS_FULLBRIGHT_ALPHA_MASK,
  368. RENDER_TYPE_PASS_ALPHA_SHADOW = LLRenderPass::PASS_ALPHA_SHADOW,
  369. // Following are object types (only used in drawable mRenderType)
  370. RENDER_TYPE_HUD = LLRenderPass::NUM_RENDER_TYPES,
  371. RENDER_TYPE_VOLUME,
  372. RENDER_TYPE_PARTICLES,
  373. RENDER_TYPE_CLOUDS,
  374. RENDER_TYPE_HUD_PARTICLES
  375. };
  377. enum LLRenderDebugFeatureMask
  378. {
  379. RENDER_DEBUG_FEATURE_UI = 0x0001,
  380. RENDER_DEBUG_FEATURE_SELECTED = 0x0002,
  381. RENDER_DEBUG_FEATURE_HIGHLIGHTED = 0x0004,
  382. RENDER_DEBUG_FEATURE_DYNAMIC_TEXTURES = 0x0008,
  383. //  RENDER_DEBUG_FEATURE_HW_LIGHTING = 0x0010,
  384. RENDER_DEBUG_FEATURE_FLEXIBLE = 0x0010,
  385. RENDER_DEBUG_FEATURE_FOG = 0x0020,
  386. RENDER_DEBUG_FEATURE_FR_INFO = 0x0080,
  387. RENDER_DEBUG_FEATURE_FOOT_SHADOWS = 0x0100,
  388. };
  390. enum LLRenderDebugMask
  391. {
  392. RENDER_DEBUG_COMPOSITION = 0x0000001,
  393. RENDER_DEBUG_VERIFY = 0x0000002,
  394. RENDER_DEBUG_BBOXES = 0x0000004,
  395. RENDER_DEBUG_OCTREE = 0x0000008,
  396. RENDER_DEBUG_PICKING = 0x0000010,
  397. RENDER_DEBUG_OCCLUSION = 0x0000020,
  398. RENDER_DEBUG_POINTS = 0x0000040,
  399. RENDER_DEBUG_TEXTURE_PRIORITY = 0x0000080,
  400. RENDER_DEBUG_TEXTURE_AREA = 0x0000100,
  401. RENDER_DEBUG_FACE_AREA = 0x0000200,
  402. RENDER_DEBUG_PARTICLES = 0x0000400,
  403. RENDER_DEBUG_GLOW = 0x0000800,
  404. RENDER_DEBUG_TEXTURE_ANIM = 0x0001000,
  405. RENDER_DEBUG_LIGHTS = 0x0002000,
  406. RENDER_DEBUG_BATCH_SIZE = 0x0004000,
  407. RENDER_DEBUG_ALPHA_BINS = 0x0008000,
  408. RENDER_DEBUG_RAYCAST            = 0x0010000,
  409. RENDER_DEBUG_SHAME = 0x0020000,
  410. RENDER_DEBUG_SHADOW_FRUSTA = 0x0040000,
  411. RENDER_DEBUG_SCULPTED           = 0x0080000,
  412. RENDER_DEBUG_AVATAR_VOLUME      = 0x0100000,
  413. RENDER_DEBUG_BUILD_QUEUE = 0x0200000,
  414. RENDER_DEBUG_AGENT_TARGET       = 0x0400000,
  415. };
  417. public:
  419. LLSpatialPartition* getSpatialPartition(LLViewerObject* vobj);
  421. void updateCamera(BOOL reset = FALSE);
  423. LLVector3 mFlyCamPosition;
  424. LLQuaternion mFlyCamRotation;
  426. BOOL  mBackfaceCull;
  427. S32  mBatchCount;
  428. S32  mMatrixOpCount;
  429. S32  mTextureMatrixOps;
  430. S32  mMaxBatchSize;
  431. S32  mMinBatchSize;
  432. S32  mMeanBatchSize;
  433. S32  mTrianglesDrawn;
  434. S32  mNumVisibleNodes;
  435. S32  mVerticesRelit;
  437. S32  mLightingChanges;
  438. S32  mGeometryChanges;
  440. S32  mNumVisibleFaces;
  442. static S32 sCompiles;
  444. static BOOL sShowHUDAttachments;
  445. static BOOL sForceOldBakedUpload; // If true will not use capabilities to upload baked textures.
  446. static S32 sUseOcclusion;  // 0 = no occlusion, 1 = read only, 2 = read/write
  447. static BOOL sDelayVBUpdate;
  448. static BOOL sFastAlpha;
  449. static BOOL sDisableShaders; // if TRUE, rendering will be done without shaders
  450. static BOOL sRenderBump;
  451. static BOOL sUseFBO;
  452. static BOOL sUseFarClip;
  453. static BOOL sShadowRender;
  454. static BOOL sWaterReflections;
  455. static BOOL sDynamicLOD;
  456. static BOOL sPickAvatar;
  457. static BOOL sReflectionRender;
  458. static BOOL sImpostorRender;
  459. static BOOL sUnderWaterRender;
  460. static BOOL sRenderGlow;
  461. static BOOL sTextureBindTest;
  462. static BOOL sRenderFrameTest;
  463. static BOOL sRenderAttachedLights;
  464. static BOOL sRenderAttachedParticles;
  465. static BOOL sRenderDeferred;
  466. static S32 sVisibleLightCount;
  467. static F32 sMinRenderSize;
  469. //screen texture
  470. U32  mScreenWidth;
  471. U32  mScreenHeight;
  473. LLRenderTarget mScreen;
  474. LLRenderTarget mUIScreen;
  475. LLRenderTarget mDeferredScreen;
  476. LLRenderTarget mEdgeMap;
  477. LLRenderTarget mDeferredDepth;
  478. LLRenderTarget mDeferredLight[3];
  479. LLMultisampleBuffer mSampleBuffer;
  480. LLRenderTarget mGIMap;
  481. LLRenderTarget mGIMapPost[2];
  482. LLRenderTarget mLuminanceMap;
  483. LLRenderTarget mHighlight;
  485. //sun shadow map
  486. LLRenderTarget mShadow[6];
  487. std::vector<LLVector3> mShadowFrustPoints[4];
  488. LLVector4 mShadowError;
  489. LLVector4 mShadowFOV;
  490. LLVector3 mShadowFrustOrigin[4];
  491. LLCamera mShadowCamera[8];
  492. LLVector3 mShadowExtents[4][2];
  493. glh::matrix4f mSunShadowMatrix[6];
  494. glh::matrix4f mShadowModelview[6];
  495. glh::matrix4f mShadowProjection[6];
  496. glh::matrix4f mGIMatrix;
  497. glh::matrix4f mGIMatrixProj;
  498. glh::matrix4f mGIModelview;
  499. glh::matrix4f mGIProjection;
  500. glh::matrix4f mGINormalMatrix;
  501. glh::matrix4f mGIInvProj;
  502. LLVector2 mGIRange;
  503. F32 mGILightRadius;
  505. LLPointer<LLDrawable> mShadowSpotLight[2];
  506. F32 mSpotLightFade[2];
  507. LLPointer<LLDrawable> mTargetShadowSpotLight[2];
  509. LLVector4 mSunClipPlanes;
  510. LLVector4 mSunOrthoClipPlanes;
  512. LLVector2 mScreenScale;
  514. //water reflection texture
  515. LLRenderTarget mWaterRef;
  517. //water distortion texture (refraction)
  518. LLRenderTarget mWaterDis;
  520. //texture for making the glow
  521. LLRenderTarget mGlow[3];
  523. //noise map
  524. U32 mNoiseMap;
  525. U32 mTrueNoiseMap;
  526. U32 mLightFunc;
  528. LLColor4 mSunDiffuse;
  529. LLVector3 mSunDir;
  531. BOOL mInitialized;
  532. BOOL mVertexShadersEnabled;
  533. S32 mVertexShadersLoaded; // 0 = no, 1 = yes, -1 = failed
  535. protected:
  536. U32 mRenderTypeMask;
  537. U32 mRenderDebugFeatureMask;
  538. U32 mRenderDebugMask;
  540. U32 mOldRenderDebugMask;
  542. /////////////////////////////////////////////
  543. //
  544. //
  545. LLDrawable::drawable_vector_t mMovedList;
  546. LLDrawable::drawable_vector_t mMovedBridge;
  547. LLDrawable::drawable_vector_t mShiftList;
  549. /////////////////////////////////////////////
  550. //
  551. //
  552. struct Light
  553. {
  554. Light(LLDrawable* ptr, F32 d, F32 f = 0.0f)
  555. : drawable(ptr),
  556.   dist(d),
  557.   fade(f)
  558. {}
  559. LLPointer<LLDrawable> drawable;
  560. F32 dist;
  561. F32 fade;
  562. struct compare
  563. {
  564. bool operator()(const Light& a, const Light& b) const
  565. {
  566. if ( a.dist < b.dist )
  567. return true;
  568. else if ( a.dist > b.dist )
  569. return false;
  570. else
  571. return a.drawable < b.drawable;
  572. }
  573. };
  574. };
  575. typedef std::set< Light, Light::compare > light_set_t;
  577. LLDrawable::drawable_set_t mLights;
  578. light_set_t mNearbyLights; // lights near camera
  579. LLColor4 mHWLightColors[8];
  581. /////////////////////////////////////////////
  582. //
  583. // Different queues of drawables being processed.
  584. //
  585. LLDrawable::drawable_list_t  mBuildQ1; // priority
  586. LLDrawable::drawable_list_t  mBuildQ2; // non-priority
  587. LLSpatialGroup::sg_list_t mGroupQ1; //priority
  588. LLSpatialGroup::sg_vector_t mGroupQ2; // non-priority
  590. LLViewerObject::vobj_list_t mCreateQ;
  592. LLDrawable::drawable_set_t mActiveQ;
  594. LLDrawable::drawable_set_t mRetexturedList;
  596. class HighlightItem
  597. {
  598. public:
  599. const LLPointer<LLDrawable> mItem;
  600. mutable F32 mFade;
  602. HighlightItem(LLDrawable* item)
  603. : mItem(item), mFade(0)
  604. {
  605. }
  607. bool operator<(const HighlightItem& rhs) const
  608. {
  609. return mItem < rhs.mItem;
  610. }
  612. bool operator==(const HighlightItem& rhs) const
  613. {
  614. return mItem == rhs.mItem;
  615. }
  617. void incrFade(F32 val) const
  618. {
  619. mFade = llclamp(mFade+val, 0.f, 1.f);
  620. }
  621. };
  623. std::set<HighlightItem> mHighlightSet;
  624. LLPointer<LLDrawable> mHighlightObject;
  626. //////////////////////////////////////////////////
  627. //
  628. // Draw pools are responsible for storing all rendered data,
  629. // and performing the actual rendering of objects.
  630. //
  631. struct compare_pools
  632. {
  633. bool operator()(const LLDrawPool* a, const LLDrawPool* b) const
  634. {
  635. if (!a)
  636. return true;
  637. else if (!b)
  638. return false;
  639. else
  640. {
  641. S32 atype = a->getType();
  642. S32 btype = b->getType();
  643. if (atype < btype)
  644. return true;
  645. else if (atype > btype)
  646. return false;
  647. else
  648. return a->getId() < b->getId();
  649. }
  650. }
  651. };
  652.   typedef std::set<LLDrawPool*, compare_pools > pool_set_t;
  653. pool_set_t mPools;
  654. LLDrawPool* mLastRebuildPool;
  656. // For quick-lookups into mPools (mapped by texture pointer)
  657. std::map<uintptr_t, LLDrawPool*> mTerrainPools;
  658. std::map<uintptr_t, LLDrawPool*> mTreePools;
  659. LLDrawPool* mAlphaPool;
  660. LLDrawPool* mSkyPool;
  661. LLDrawPool* mTerrainPool;
  662. LLDrawPool* mWaterPool;
  663. LLDrawPool* mGroundPool;
  664. LLRenderPass* mSimplePool;
  665. LLRenderPass* mGrassPool;
  666. LLRenderPass* mFullbrightPool;
  667. LLDrawPool* mInvisiblePool;
  668. LLDrawPool* mGlowPool;
  669. LLDrawPool* mBumpPool;
  670. LLDrawPool* mWLSkyPool;
  671. // Note: no need to keep an quick-lookup to avatar pools, since there's only one per avatar
  673. public:
  674. std::vector<LLFace*> mHighlightFaces; // highlight faces on physical objects
  675. protected:
  676. std::vector<LLFace*> mSelectedFaces;
  678. LLPointer<LLViewerFetchedTexture> mFaceSelectImagep;
  680. U32 mLightMask;
  681. U32 mLightMovingMask;
  682. S32 mLightingDetail;
  684. static BOOL sRenderPhysicalBeacons;
  685. static BOOL sRenderScriptedTouchBeacons;
  686. static BOOL sRenderScriptedBeacons;
  687. static BOOL sRenderParticleBeacons;
  688. static BOOL sRenderSoundBeacons;
  689. public:
  690. static BOOL sRenderBeacons;
  691. static BOOL sRenderHighlight;
  692. };
  694. void render_bbox(const LLVector3 &min, const LLVector3 &max);
  695. void render_hud_elements();
  697. extern LLPipeline gPipeline;
  698. extern BOOL gRenderForSelect;
  699. extern BOOL gDebugPipeline;
  700. extern const LLMatrix4* gGLLastMatrix;
  702. #endif