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

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

游戏引擎

开发平台：

C++ Builder

llvosky.h：源码内容
  1. /** 
  2.  * @file llvosky.h
  3.  * @brief LLVOSky class header file
  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_LLVOSKY_H
  34. #define LL_LLVOSKY_H
  36. #include "stdtypes.h"
  37. #include "v3color.h"
  38. #include "v4coloru.h"
  39. #include "llviewertexture.h"
  40. #include "llviewerobject.h"
  41. #include "llframetimer.h"
  44. //////////////////////////////////
  45. //
  46. // Lots of constants
  47. //
  48. // Will clean these up at some point...
  49. //
  51. const F32 HORIZON_DIST = 1024.0f;
  52. const F32 SKY_BOX_MULT = 16.0f;
  53. const F32 HEAVENLY_BODY_DIST = HORIZON_DIST - 10.f;
  54. const F32 HEAVENLY_BODY_FACTOR = 0.1f;
  55. const F32 HEAVENLY_BODY_SCALE = HEAVENLY_BODY_DIST * HEAVENLY_BODY_FACTOR;
  56. const F32 EARTH_RADIUS = 6.4e6f;       // exact radius = 6.37 x 10^6 m
  57. const F32 ATM_EXP_FALLOFF = 0.000126f;
  58. const F32 ATM_SEA_LEVEL_NDENS = 2.55e25f;
  59. // Somewhat arbitrary:
  60. const F32 ATM_HEIGHT = 100000.f;
  62. const F32 FIRST_STEP = 5000.f;
  63. const F32 INV_FIRST_STEP = 1.f/FIRST_STEP;
  64. const S32 NO_STEPS = 15;
  65. const F32 INV_NO_STEPS = 1.f/NO_STEPS;
  68. // constants used in calculation of scattering coeff of clear air
  69. const F32 sigma = 0.035f;
  70. const F32 fsigma = (6.f + 3.f * sigma) / (6.f-7.f*sigma);
  71. const F64 Ndens = 2.55e25;
  72. const F64 Ndens2 = Ndens*Ndens;
  74. // HACK: Allow server to change sun and moon IDs.
  75. // I can't figure out how to pass the appropriate
  76. // information into the LLVOSky constructor.  JC
  77. extern LLUUID gSunTextureID;
  78. extern LLUUID gMoonTextureID;
  81. LL_FORCE_INLINE LLColor3 color_div(const LLColor3 &col1, const LLColor3 &col2)
  82. {
  83. return LLColor3( 
  84. col1.mV[0] / col2.mV[0],
  85. col1.mV[1] / col2.mV[1],
  86. col1.mV[2] / col2.mV[2] );
  87. }
  89. LLColor3 color_norm(const LLColor3 &col);
  90. BOOL clip_quad_to_horizon(F32& t_left, F32& t_right, LLVector3 v_clipped[4],
  91.   const LLVector3 v_corner[4], const F32 cos_max_angle);
  92. F32 clip_side_to_horizon(const LLVector3& v0, const LLVector3& v1, const F32 cos_max_angle);
  94. inline F32 color_intens ( const LLColor3 &col )
  95. {
  96. return col.mV[0] + col.mV[1] + col.mV[2];
  97. }
  99. inline F32 color_max(const LLColor3 &col)
  100. {
  101. return llmax(col.mV[0], col.mV[1], col.mV[2]);
  102. }
  104. inline F32 color_max(const LLColor4 &col)
  105. {
  106. return llmax(col.mV[0], col.mV[1], col.mV[2]);
  107. }
  110. inline F32 color_min(const LLColor3 &col)
  111. {
  112. return llmin(col.mV[0], col.mV[1], col.mV[2]);
  113. }
  115. class LLFace;
  116. class LLHaze;
  119. class LLSkyTex
  120. {
  121. friend class LLVOSky;
  122. private:
  123. static S32 sResolution;
  124. static S32 sComponents;
  125. LLPointer<LLViewerTexture> mTexture[2];
  126. LLPointer<LLImageRaw> mImageRaw[2];
  127. LLColor4 *mSkyData;
  128. LLVector3 *mSkyDirs; // Cache of sky direction vectors
  129. static S32 sCurrent;
  130. static F32 sInterpVal;
  132. public:
  133. static F32 getInterpVal() { return sInterpVal; }
  134. static void setInterpVal(const F32 v) { sInterpVal = v; }
  135. static BOOL doInterpolate() { return sInterpVal > 0.001f; }
  137. void bindTexture(BOOL curr = TRUE);
  139. protected:
  140. LLSkyTex();
  141. void init();
  142. void cleanupGL();
  143. void restoreGL();
  145. ~LLSkyTex();
  148. static S32 getResolution() { return sResolution; }
  149. static S32 getCurrent() { return sCurrent; }
  150. static S32 stepCurrent() { return (sCurrent = (sCurrent + 1) % 2); }
  151. static S32 getNext() { return ((sCurrent+1) % 2); }
  152. static S32 getWhich(const BOOL curr) { return curr ? sCurrent : getNext(); }
  154. void initEmpty(const S32 tex);
  156. void create(F32 brightness);
  158. void setDir(const LLVector3 &dir, const S32 i, const S32 j)
  159. {
  160. S32 offset = i * sResolution + j;
  161. mSkyDirs[offset] = dir;
  162. }
  164. const LLVector3 &getDir(const S32 i, const S32 j) const
  165. {
  166. S32 offset = i * sResolution + j;
  167. return mSkyDirs[offset];
  168. }
  170. void setPixel(const LLColor4 &col, const S32 i, const S32 j)
  171. {
  172. S32 offset = i * sResolution + j;
  173. mSkyData[offset] = col;
  174. }
  176. void setPixel(const LLColor4U &col, const S32 i, const S32 j)
  177. {
  178. S32 offset = (i * sResolution + j) * sComponents;
  179. U32* pix = (U32*) &(mImageRaw[sCurrent]->getData()[offset]);
  180. *pix = col.mAll;
  181. }
  183. LLColor4U getPixel(const S32 i, const S32 j)
  184. {
  185. LLColor4U col;
  186. S32 offset = (i * sResolution + j) * sComponents;
  187. U32* pix = (U32*) &(mImageRaw[sCurrent]->getData()[offset]);
  188. col.mAll = *pix;
  189. return col;
  190. }
  192. LLImageRaw* getImageRaw(BOOL curr=TRUE) { return mImageRaw[getWhich(curr)]; }
  193. void createGLImage(BOOL curr=TRUE);
  194. };
  196. /// TODO Move into the stars draw pool (and rename them appropriately).
  197. class LLHeavenBody
  198. {
  199. protected:
  200. LLVector3 mDirectionCached; // hack for events that shouldn't happen every frame
  202. LLColor3 mColor;
  203. LLColor3 mColorCached;
  204. F32 mIntensity;
  205. LLVector3 mDirection; // direction of the local heavenly body
  206. LLVector3 mAngularVelocity; // velocity of the local heavenly body
  208. F32 mDiskRadius;
  209. BOOL mDraw; // FALSE - do not draw.
  210. F32 mHorizonVisibility; // number [0, 1] due to how horizon
  211. F32 mVisibility; // same but due to other objects being in throng.
  212. BOOL mVisible;
  213. static F32 sInterpVal;
  214. LLVector3 mQuadCorner[4];
  215. LLVector3 mU;
  216. LLVector3 mV;
  217. LLVector3 mO;
  219. public:
  220. LLHeavenBody(const F32 rad) :
  221. mDirectionCached(LLVector3(0,0,0)),
  222. mDirection(LLVector3(0,0,0)),
  223. mIntensity(0.f),
  224. mDiskRadius(rad), mDraw(FALSE),
  225. mHorizonVisibility(1.f), mVisibility(1.f),
  226. mVisible(FALSE)
  227. {
  228. mColor.setToBlack();
  229. mColorCached.setToBlack();
  230. }
  231. ~LLHeavenBody() {}
  233. const LLVector3& getDirection() const { return mDirection; }
  234. void setDirection(const LLVector3 &direction) { mDirection = direction; }
  235. void setAngularVelocity(const LLVector3 &ang_vel) { mAngularVelocity = ang_vel; }
  236. const LLVector3& getAngularVelocity() const { return mAngularVelocity; }
  238. const LLVector3& getDirectionCached() const { return mDirectionCached; }
  239. void renewDirection() { mDirectionCached = mDirection; }
  241. const LLColor3& getColorCached() const { return mColorCached; }
  242. void setColorCached(const LLColor3& c) { mColorCached = c; }
  243. const LLColor3& getColor() const { return mColor; }
  244. void setColor(const LLColor3& c) { mColor = c; }
  246. void renewColor() { mColorCached = mColor; }
  248. static F32 interpVal() { return sInterpVal; }
  249. static void setInterpVal(const F32 v) { sInterpVal = v; }
  251. LLColor3 getInterpColor() const
  252. {
  253. return sInterpVal * mColor + (1 - sInterpVal) * mColorCached;
  254. }
  256. const F32& getHorizonVisibility() const { return mHorizonVisibility; }
  257. void setHorizonVisibility(const F32 c = 1) { mHorizonVisibility = c; }
  258. const F32& getVisibility() const { return mVisibility; }
  259. void setVisibility(const F32 c = 1) { mVisibility = c; }
  260. F32 getHaloBrighness() const
  261. {
  262. return llmax(0.f, llmin(0.9f, mHorizonVisibility)) * mVisibility;
  263. }
  264. BOOL isVisible() const { return mVisible; }
  265. void setVisible(const BOOL v) { mVisible = v; }
  267. const F32& getIntensity() const { return mIntensity; }
  268. void setIntensity(const F32 c) { mIntensity = c; }
  270. void setDiskRadius(const F32 radius) { mDiskRadius = radius; }
  271. F32 getDiskRadius() const { return mDiskRadius; }
  273. void setDraw(const BOOL draw) { mDraw = draw; }
  274. BOOL getDraw() const { return mDraw; }
  276. const LLVector3& corner(const S32 n) const { return mQuadCorner[n]; }
  277. LLVector3& corner(const S32 n) { return mQuadCorner[n]; }
  278. const LLVector3* corners() const { return mQuadCorner; }
  280. const LLVector3& getU() const { return mU; }
  281. const LLVector3& getV() const { return mV; }
  282. void setU(const LLVector3& u) { mU = u; }
  283. void setV(const LLVector3& v) { mV = v; }
  284. };
  287. LL_FORCE_INLINE LLColor3 refr_ind_calc(const LLColor3 &wave_length)
  288. {
  289. LLColor3 refr_ind;
  290. for (S32 i = 0; i < 3; ++i)
  291. {
  292. const F32 wl2 = wave_length.mV[i] * wave_length.mV[i] * 1e-6f;
  293. refr_ind.mV[i] = 6.43e3f + ( 2.95e6f / ( 146.0f - 1.f/wl2 ) ) + ( 2.55e4f / ( 41.0f - 1.f/wl2 ) );
  294. refr_ind.mV[i] *= 1.0e-8f;
  295. refr_ind.mV[i] += 1.f;
  296. }
  297. return refr_ind;
  298. }
  301. LL_FORCE_INLINE LLColor3 calc_air_sca_sea_level()
  302. {
  303. const static LLColor3 WAVE_LEN(675, 520, 445);
  304. const static LLColor3 refr_ind = refr_ind_calc(WAVE_LEN);
  305. const static LLColor3 n21 = refr_ind * refr_ind - LLColor3(1, 1, 1);
  306. const static LLColor3 n4 = n21 * n21;
  307. const static LLColor3 wl2 = WAVE_LEN * WAVE_LEN * 1e-6f;
  308. const static LLColor3 wl4 = wl2 * wl2;
  309. const static LLColor3 mult_const = fsigma * 2.0f/ 3.0f * 1e24f * (F_PI * F_PI) * n4;
  310. const static F32 dens_div_N = F32( ATM_SEA_LEVEL_NDENS / Ndens2);
  311. return dens_div_N * color_div ( mult_const, wl4 );
  312. }
  314. const LLColor3 gAirScaSeaLevel = calc_air_sca_sea_level();
  315. const F32 AIR_SCA_INTENS = color_intens(gAirScaSeaLevel);
  316. const F32 AIR_SCA_AVG = AIR_SCA_INTENS / 3.f;
  318. class LLHaze
  319. {
  320. public:
  321. LLHaze() : mG(0), mFalloff(1), mAbsCoef(0.f) {mSigSca.setToBlack();}
  322. LLHaze(const F32 g, const LLColor3& sca, const F32 fo = 2.f) : 
  323. mG(g), mSigSca(0.25f/F_PI * sca), mFalloff(fo), mAbsCoef(0.f)
  324. {
  325. mAbsCoef = color_intens(mSigSca) / AIR_SCA_INTENS;
  326. }
  328. LLHaze(const F32 g, const F32 sca, const F32 fo = 2.f) : mG(g),
  329. mSigSca(0.25f/F_PI * LLColor3(sca, sca, sca)), mFalloff(fo)
  330. {
  331. mAbsCoef = 0.01f * sca / AIR_SCA_AVG;
  332. }
  334. static void initClass();
  337. F32 getG() const { return mG; }
  339. void setG(const F32 g)
  340. {
  341. mG = g;
  342. }
  344. const LLColor3& getSigSca() const // sea level
  345. {
  346. return mSigSca;
  347. } 
  349. void setSigSca(const LLColor3& s)
  350. {
  351. mSigSca = s;
  352. mAbsCoef = 0.01f * color_intens(mSigSca) / AIR_SCA_INTENS;
  353. }
  355. void setSigSca(const F32 s0, const F32 s1, const F32 s2)
  356. {
  357. mSigSca = AIR_SCA_AVG * LLColor3 (s0, s1, s2);
  358. mAbsCoef = 0.01f * (s0 + s1 + s2) / 3;
  359. }
  361. F32 getFalloff() const
  362. {
  363. return mFalloff;
  364. }
  366. void setFalloff(const F32 fo)
  367. {
  368. mFalloff = fo;
  369. }
  371. F32 getAbsCoef() const
  372. {
  373. return mAbsCoef;
  374. }
  376. inline static F32 calcFalloff(const F32 h)
  377. {
  378. return (h <= 0) ? 1.0f : (F32)LL_FAST_EXP(-ATM_EXP_FALLOFF * h);
  379. }
  381. inline LLColor3 calcSigSca(const F32 h) const
  382. {
  383. return calcFalloff(h * mFalloff) * mSigSca;
  384. }
  386. inline void calcSigSca(const F32 h, LLColor3 &result) const
  387. {
  388. result = mSigSca;
  389. result *= calcFalloff(h * mFalloff);
  390. }
  392. LLColor3 calcSigExt(const F32 h) const
  393. {
  394. return calcFalloff(h * mFalloff) * (1 + mAbsCoef) * mSigSca;
  395. }
  397. F32 calcPhase(const F32 cos_theta) const;
  399. static inline LLColor3 calcAirSca(const F32 h);
  400. static inline void calcAirSca(const F32 h, LLColor3 &result);
  401. static LLColor3 calcAirScaSeaLevel() { return gAirScaSeaLevel; }
  402. static const LLColor3 &getAirScaSeaLevel() { return sAirScaSeaLevel; }
  403. public:
  404. static LLColor3 sAirScaSeaLevel;
  406. protected:
  407. F32 mG;
  408. LLColor3 mSigSca;
  409. F32 mFalloff; // 1 - slow, >1 - faster
  410. F32 mAbsCoef;
  411. };
  414. class LLCubeMap;
  416. // turn on floating point precision
  417. // in vs2003 for this class.  Otherwise
  418. // black dots go everywhere from 7:10 - 8:50
  419. #if LL_MSVC && __MSVC_VER__ < 8
  420. #pragma optimize("p", on)
  421. #endif
  424. class LLVOSky : public LLStaticViewerObject
  425. {
  426. public:
  427. /// WL PARAMS
  428. F32 dome_radius;
  429. F32 dome_offset_ratio;
  430. LLColor3 sunlight_color;
  431. LLColor3 ambient;
  432. F32 gamma;
  433. LLVector4 lightnorm;
  434. LLVector4 unclamped_lightnorm;
  435. LLColor3 blue_density;
  436. LLColor3 blue_horizon;
  437. F32 haze_density;
  438. LLColor3 haze_horizon;
  439. F32 density_multiplier;
  440. F32 max_y;
  441. LLColor3 glow;
  442. F32 cloud_shadow;
  443. LLColor3 cloud_color;
  444. F32 cloud_scale;
  445. LLColor3 cloud_pos_density1;
  446. LLColor3 cloud_pos_density2;
  448. public:
  449. void initAtmospherics(void);
  450. void calcAtmospherics(void);
  451. LLColor3 createDiffuseFromWL(LLColor3 diffuse, LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient);
  452. LLColor3 createAmbientFromWL(LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient);
  454. void calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLColor3 & vary_CloudColorSun, 
  455. LLColor3 & vary_CloudColorAmbient, F32 & vary_CloudDensity, 
  456. LLVector2 vary_HorizontalProjection[2]);
  458. LLColor3 calcSkyColorWLFrag(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLColor3 & vary_CloudColorSun, 
  459. LLColor3 & vary_CloudColorAmbient, F32 & vary_CloudDensity, 
  460. LLVector2 vary_HorizontalProjection[2]);
  462. public:
  463. enum
  464. {
  465. FACE_SIDE0,
  466. FACE_SIDE1,
  467. FACE_SIDE2,
  468. FACE_SIDE3,
  469. FACE_SIDE4,
  470. FACE_SIDE5,
  471. FACE_SUN, // was 6
  472. FACE_MOON, // was 7
  473. FACE_BLOOM, // was 8
  474. FACE_REFLECTION, // was 10
  475. FACE_DUMMY, //for an ATI bug --bao
  476. FACE_COUNT
  477. };
  479. LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp);
  481. // Initialize/delete data that's only inited once per class.
  482. static void initClass();
  483. void init();
  484. void initCubeMap();
  485. void initEmpty();
  487. void cleanupGL();
  488. void restoreGL();
  490. /*virtual*/ BOOL idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time);
  491. BOOL updateSky();
  493. // Graphical stuff for objects - maybe broken out into render class
  494. // later?
  495. /*virtual*/ void updateTextures();
  496. /*virtual*/ LLDrawable* createDrawable(LLPipeline *pipeline);
  497. /*virtual*/ BOOL updateGeometry(LLDrawable *drawable);
  499. void initSkyTextureDirs(const S32 side, const S32 tile);
  500. void createSkyTexture(const S32 side, const S32 tile);
  502. LLColor4 calcSkyColorInDir(const LLVector3& dir, bool isShiny = false);
  504. LLColor3 calcRadianceAtPoint(const LLVector3& pos) const
  505. {
  506. F32 radiance = mBrightnessScaleGuess * mSun.getIntensity();
  507. return LLColor3(radiance, radiance, radiance);
  508. }
  510. const LLHeavenBody& getSun() const { return mSun; }
  511. const LLHeavenBody& getMoon() const { return mMoon; }
  513. const LLVector3& getToSunLast() const { return mSun.getDirectionCached(); }
  514. const LLVector3& getToSun() const { return mSun.getDirection(); }
  515. const LLVector3& getToMoon() const { return mMoon.getDirection(); }
  516. const LLVector3& getToMoonLast() const { return mMoon.getDirectionCached(); }
  517. BOOL isSunUp() const { return mSun.getDirectionCached().mV[2] > -0.05f; }
  518. void calculateColors();
  520. LLColor3 getSunDiffuseColor() const { return mSunDiffuse; }
  521. LLColor3 getMoonDiffuseColor() const { return mMoonDiffuse; }
  522. LLColor4 getSunAmbientColor() const { return mSunAmbient; }
  523. LLColor4 getMoonAmbientColor() const { return mMoonAmbient; }
  524. const LLColor4& getTotalAmbientColor() const { return mTotalAmbient; }
  525. LLColor4 getFogColor() const { return mFogColor; }
  526. LLColor4 getGLFogColor() const { return mGLFogCol; }
  528. BOOL isSameFace(S32 idx, const LLFace* face) const { return mFace[idx] == face; }
  530. void initSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity);
  532. void setSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity);
  534. BOOL updateHeavenlyBodyGeometry(LLDrawable *drawable, const S32 side, const BOOL is_sun,
  535. LLHeavenBody& hb, const F32 sin_max_angle,
  536. const LLVector3 &up, const LLVector3 &right);
  538. F32 cosHorizon(const F32 delta = 0) const
  539. {
  540. const F32 sin_angle = EARTH_RADIUS/(EARTH_RADIUS + mCameraPosAgent.mV[2]);
  541. return delta - (F32)sqrt(1.f - sin_angle * sin_angle);
  542. }
  544. void updateSunHaloGeometry(LLDrawable *drawable);
  545. void updateReflectionGeometry(LLDrawable *drawable, F32 H, const LLHeavenBody& HB);
  548. const LLHaze& getHaze() const { return mHaze; }
  549. LLHaze& getHaze() { return mHaze; }
  550. F32 getHazeConcentration() const { return mHazeConcentration; }
  551. void setHaze(const LLHaze& h) { mHaze = h; }
  552. F32 getWorldScale() const { return mWorldScale; }
  553. void setWorldScale(const F32 s) { mWorldScale = s; }
  554. void updateFog(const F32 distance);
  555. void setFogRatio(const F32 fog_ratio) { mFogRatio = fog_ratio; }
  556. LLColor4U getFadeColor() const { return mFadeColor; }
  557. F32 getFogRatio() const { return mFogRatio; }
  558. void setCloudDensity(F32 cloud_density) { mCloudDensity = cloud_density; }
  559. void setWind ( const LLVector3& wind ) { mWind = wind.length(); }
  561. const LLVector3 &getCameraPosAgent() const { return mCameraPosAgent; }
  562. LLVector3 getEarthCenter() const { return mEarthCenter; }
  564. LLCubeMap *getCubeMap() const { return mCubeMap; }
  565. S32 getDrawRefl() const { return mDrawRefl; }
  566. void setDrawRefl(const S32 r) { mDrawRefl = r; }
  567. BOOL isReflFace(const LLFace* face) const { return face == mFace[FACE_REFLECTION]; }
  568. LLFace* getReflFace() const { return mFace[FACE_REFLECTION]; }
  570. LLViewerTexture* getSunTex() const { return mSunTexturep; }
  571. LLViewerTexture* getMoonTex() const { return mMoonTexturep; }
  572. LLViewerTexture* getBloomTex() const { return mBloomTexturep; }
  573. void forceSkyUpdate(void) { mForceUpdate = TRUE; }
  575. public:
  576. LLFace *mFace[FACE_COUNT];
  577. LLVector3 mBumpSunDir;
  579. protected:
  580. ~LLVOSky();
  582. LLPointer<LLViewerFetchedTexture> mSunTexturep;
  583. LLPointer<LLViewerFetchedTexture> mMoonTexturep;
  584. LLPointer<LLViewerFetchedTexture> mBloomTexturep;
  586. static S32 sResolution;
  587. static S32 sTileResX;
  588. static S32 sTileResY;
  589. LLSkyTex mSkyTex[6];
  590. LLSkyTex mShinyTex[6];
  591. LLHeavenBody mSun;
  592. LLHeavenBody mMoon;
  593. LLVector3 mSunDefaultPosition;
  594. LLVector3 mSunAngVel;
  595. F32 mAtmHeight;
  596. LLVector3 mEarthCenter;
  597. LLVector3 mCameraPosAgent;
  598. F32 mBrightnessScale;
  599. LLColor3 mBrightestPoint;
  600. F32 mBrightnessScaleNew;
  601. LLColor3 mBrightestPointNew;
  602. F32 mBrightnessScaleGuess;
  603. LLColor3 mBrightestPointGuess;
  604. LLHaze mHaze;
  605. F32 mHazeConcentration;
  606. BOOL mWeatherChange;
  607. F32 mCloudDensity;
  608. F32 mWind;
  610. BOOL mInitialized;
  611. BOOL mForceUpdate; //flag to force instantaneous update of cubemap
  612. LLVector3 mLastLightingDirection;
  613. LLColor3 mLastTotalAmbient;
  614. F32 mAmbientScale;
  615. LLColor3 mNightColorShift;
  616. F32 mInterpVal;
  618. LLColor4 mFogColor;
  619. LLColor4 mGLFogCol;
  621. F32 mFogRatio;
  622. F32 mWorldScale;
  624. LLColor4 mSunAmbient;
  625. LLColor4 mMoonAmbient;
  626. LLColor4 mTotalAmbient;
  627. LLColor3 mSunDiffuse;
  628. LLColor3 mMoonDiffuse;
  629. LLColor4U mFadeColor; // Color to fade in from
  631. LLPointer<LLCubeMap> mCubeMap; // Cube map for the environment
  632. S32 mDrawRefl;
  634. LLFrameTimer mUpdateTimer;
  636. public:
  637. //by bao
  638. //fake vertex buffer updating
  639. //to guarantee at least updating one VBO buffer every frame
  640. //to work around the bug caused by ATI card --> DEV-3855
  641. //
  642. void createDummyVertexBuffer() ;
  643. void updateDummyVertexBuffer() ;
  645. BOOL mHeavenlyBodyUpdated ;
  646. };
  648. // turn it off
  649. #if LL_MSVC && __MSVC_VER__ < 8
  650. #pragma optimize("p", off)
  651. #endif
  653. // Utility functions
  654. F32 azimuth(const LLVector3 &v);
  655. F32 color_norm_pow(LLColor3& col, F32 e, BOOL postmultiply = FALSE);
  658. /* Proportion of light that is scattered into 'path' from 'in' over distance dt. */
  659. /* assumes that vectors 'path' and 'in' are normalized. Scattering coef / 2pi */
  661. inline LLColor3 LLHaze::calcAirSca(const F32 h)
  662. {
  663. static const LLColor3 air_sca_sea_level = calcAirScaSeaLevel();
  664. return calcFalloff(h) * air_sca_sea_level;
  665. }
  667. inline void LLHaze::calcAirSca(const F32 h, LLColor3 &result)
  668. {
  669. static const LLColor3 air_sca_sea_level = calcAirScaSeaLevel();
  670. result = air_sca_sea_level;
  671. result *= calcFalloff(h);
  672. }
  675. #endif