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

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

游戏引擎

开发平台：

C++ Builder

llvosky.cpp：源码内容
  1. /** 
  2.  * @file llvosky.cpp
  3.  * @brief LLVOSky class implementation
  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. #include "llviewerprecompiledheaders.h"
  35. #include "llvosky.h"
  37. #include "imageids.h"
  38. #include "llfeaturemanager.h"
  39. #include "llviewercontrol.h"
  40. #include "llframetimer.h"
  41. #include "timing.h"
  43. #include "llagent.h"
  44. #include "lldrawable.h"
  45. #include "llface.h"
  46. #include "llcubemap.h"
  47. #include "lldrawpoolsky.h"
  48. #include "lldrawpoolwater.h"
  49. #include "llglheaders.h"
  50. #include "llsky.h"
  51. #include "llviewercamera.h"
  52. #include "llviewertexturelist.h"
  53. #include "llviewerobjectlist.h"
  54. #include "llviewerregion.h"
  55. #include "llworld.h"
  56. #include "pipeline.h"
  57. #include "lldrawpoolwlsky.h"
  58. #include "llwlparammanager.h"
  59. #include "llwaterparammanager.h"
  61. #undef min
  62. #undef max
  64. static const S32 NUM_TILES_X = 8;
  65. static const S32 NUM_TILES_Y = 4;
  66. static const S32 NUM_TILES = NUM_TILES_X * NUM_TILES_Y;
  68. // Heavenly body constants
  69. static const F32 SUN_DISK_RADIUS = 0.5f;
  70. static const F32 MOON_DISK_RADIUS = SUN_DISK_RADIUS * 0.9f;
  71. static const F32 SUN_INTENSITY = 1e5;
  72. static const F32 SUN_DISK_INTENSITY = 24.f;
  75. // Texture coordinates:
  76. static const LLVector2 TEX00 = LLVector2(0.f, 0.f);
  77. static const LLVector2 TEX01 = LLVector2(0.f, 1.f);
  78. static const LLVector2 TEX10 = LLVector2(1.f, 0.f);
  79. static const LLVector2 TEX11 = LLVector2(1.f, 1.f);
  81. // Exported globals
  82. LLUUID gSunTextureID = IMG_SUN;
  83. LLUUID gMoonTextureID = IMG_MOON;
  85. //static 
  86. LLColor3 LLHaze::sAirScaSeaLevel;
  88. class LLFastLn
  89. {
  90. public:
  91. LLFastLn() 
  92. {
  93. mTable[0] = 0;
  94. for( S32 i = 1; i < 257; i++ )
  95. {
  96. mTable[i] = log((F32)i);
  97. }
  98. }
  100. F32 ln( F32 x )
  101. {
  102. const F32 OO_255 = 0.003921568627450980392156862745098f;
  103. const F32 LN_255 = 5.5412635451584261462455391880218f;
  105. if( x < OO_255 )
  106. {
  107. return log(x);
  108. }
  109. else
  110. if( x < 1 )
  111. {
  112. x *= 255.f;
  113. S32 index = llfloor(x);
  114. F32 t = x - index;
  115. F32 low = mTable[index];
  116. F32 high = mTable[index + 1];
  117. return low + t * (high - low) - LN_255;
  118. }
  119. else
  120. if( x <= 255 )
  121. {
  122. S32 index = llfloor(x);
  123. F32 t = x - index;
  124. F32 low = mTable[index];
  125. F32 high = mTable[index + 1];
  126. return low + t * (high - low);
  127. }
  128. else
  129. {
  130. return log( x );
  131. }
  132. }
  134. F32 pow( F32 x, F32 y )
  135. {
  136. return (F32)LL_FAST_EXP(y * ln(x));
  137. }
  140. private:
  141. F32 mTable[257]; // index 0 is unused
  142. };
  144. static LLFastLn gFastLn;
  147. // Functions used a lot.
  149. inline F32 LLHaze::calcPhase(const F32 cos_theta) const
  150. {
  151. const F32 g2 = mG * mG;
  152. const F32 den = 1 + g2 - 2 * mG * cos_theta;
  153. return (1 - g2) * gFastLn.pow(den, -1.5);
  154. }
  156. inline void color_pow(LLColor3 &col, const F32 e)
  157. {
  158. col.mV[0] = gFastLn.pow(col.mV[0], e);
  159. col.mV[1] = gFastLn.pow(col.mV[1], e);
  160. col.mV[2] = gFastLn.pow(col.mV[2], e);
  161. }
  163. inline LLColor3 color_norm(const LLColor3 &col)
  164. {
  165. const F32 m = color_max(col);
  166. if (m > 1.f)
  167. {
  168. return 1.f/m * col;
  169. }
  170. else return col;
  171. }
  173. inline void color_gamma_correct(LLColor3 &col)
  174. {
  175. const F32 gamma_inv = 1.f/1.2f;
  176. if (col.mV[0] != 0.f)
  177. {
  178. col.mV[0] = gFastLn.pow(col.mV[0], gamma_inv);
  179. }
  180. if (col.mV[1] != 0.f)
  181. {
  182. col.mV[1] = gFastLn.pow(col.mV[1], gamma_inv);
  183. }
  184. if (col.mV[2] != 0.f)
  185. {
  186. col.mV[2] = gFastLn.pow(col.mV[2], gamma_inv);
  187. }
  188. }
  192. /***************************************
  193. SkyTex
  194. ***************************************/
  196. S32 LLSkyTex::sComponents = 4;
  197. S32 LLSkyTex::sResolution = 64;
  198. F32 LLSkyTex::sInterpVal = 0.f;
  199. S32 LLSkyTex::sCurrent = 0;
  202. LLSkyTex::LLSkyTex() :
  203. mSkyData(NULL),
  204. mSkyDirs(NULL)
  205. {
  206. }
  208. void LLSkyTex::init()
  209. {
  210. mSkyData = new LLColor4[sResolution * sResolution];
  211. mSkyDirs = new LLVector3[sResolution * sResolution];
  213. for (S32 i = 0; i < 2; ++i)
  214. {
  215. mTexture[i] = LLViewerTextureManager::getLocalTexture(FALSE);
  216. mTexture[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
  217. mImageRaw[i] = new LLImageRaw(sResolution, sResolution, sComponents);
  219. initEmpty(i);
  220. }
  221. }
  223. void LLSkyTex::cleanupGL()
  224. {
  225. mTexture[0] = NULL;
  226. mTexture[1] = NULL;
  227. }
  229. void LLSkyTex::restoreGL()
  230. {
  231. for (S32 i = 0; i < 2; i++)
  232. {
  233. mTexture[i] = LLViewerTextureManager::getLocalTexture(FALSE);
  234. mTexture[i]->setAddressMode(LLTexUnit::TAM_CLAMP);
  235. }
  236. }
  238. LLSkyTex::~LLSkyTex()
  239. {
  240. delete[] mSkyData;
  241. mSkyData = NULL;
  243. delete[] mSkyDirs;
  244. mSkyDirs = NULL;
  245. }
  248. void LLSkyTex::initEmpty(const S32 tex)
  249. {
  250. U8* data = mImageRaw[tex]->getData();
  251. for (S32 i = 0; i < sResolution; ++i)
  252. {
  253. for (S32 j = 0; j < sResolution; ++j)
  254. {
  255. const S32 basic_offset = (i * sResolution + j);
  256. S32 offset = basic_offset * sComponents;
  257. data[offset] = 0;
  258. data[offset+1] = 0;
  259. data[offset+2] = 0;
  260. data[offset+3] = 255;
  262. mSkyData[basic_offset].setToBlack();
  263. }
  264. }
  266. createGLImage(tex);
  267. }
  269. void LLSkyTex::create(const F32 brightness)
  270. {
  271. /// Brightness ignored for now.
  272. U8* data = mImageRaw[sCurrent]->getData();
  273. for (S32 i = 0; i < sResolution; ++i)
  274. {
  275. for (S32 j = 0; j < sResolution; ++j)
  276. {
  277. const S32 basic_offset = (i * sResolution + j);
  278. S32 offset = basic_offset * sComponents;
  279. U32* pix = (U32*)(data + offset);
  280. LLColor4U temp = LLColor4U(mSkyData[basic_offset]);
  281. *pix = temp.mAll;
  282. }
  283. }
  284. createGLImage(sCurrent);
  285. }
  290. void LLSkyTex::createGLImage(S32 which)
  291. {
  292. mTexture[which]->createGLTexture(0, mImageRaw[which], 0, TRUE, LLViewerTexture::LOCAL);
  293. mTexture[which]->setAddressMode(LLTexUnit::TAM_CLAMP);
  294. }
  296. void LLSkyTex::bindTexture(BOOL curr)
  297. {
  298. gGL.getTexUnit(0)->bind(mTexture[getWhich(curr)]);
  299. }
  301. /***************************************
  302. Sky
  303. ***************************************/
  305. F32 LLHeavenBody::sInterpVal = 0;
  307. S32 LLVOSky::sResolution = LLSkyTex::getResolution();
  308. S32 LLVOSky::sTileResX = sResolution/NUM_TILES_X;
  309. S32 LLVOSky::sTileResY = sResolution/NUM_TILES_Y;
  311. LLVOSky::LLVOSky(const LLUUID &id, const LLPCode pcode, LLViewerRegion *regionp)
  312. : LLStaticViewerObject(id, pcode, regionp, TRUE),
  313. mSun(SUN_DISK_RADIUS), mMoon(MOON_DISK_RADIUS),
  314. mBrightnessScale(1.f),
  315. mBrightnessScaleNew(0.f),
  316. mBrightnessScaleGuess(1.f),
  317. mWeatherChange(FALSE),
  318. mCloudDensity(0.2f),
  319. mWind(0.f),
  320. mForceUpdate(FALSE),
  321. mWorldScale(1.f),
  322. mBumpSunDir(0.f, 0.f, 1.f)
  323. {
  324. bool error = false;
  326. /// WL PARAMS
  327. dome_radius = 1.f;
  328. dome_offset_ratio = 0.f;
  329. sunlight_color = LLColor3();
  330. ambient = LLColor3();
  331. gamma = 1.f;
  332. lightnorm = LLVector4();
  333. blue_density = LLColor3();
  334. blue_horizon = LLColor3();
  335. haze_density = 0.f;
  336. haze_horizon = LLColor3();
  337. density_multiplier = 0.f;
  338. max_y = 0.f;
  339. glow = LLColor3();
  340. cloud_shadow = 0.f;
  341. cloud_color = LLColor3();
  342. cloud_scale = 0.f;
  343. cloud_pos_density1 = LLColor3();
  344. cloud_pos_density2 = LLColor3();
  346. mInitialized = FALSE;
  347. mbCanSelect = FALSE;
  348. mUpdateTimer.reset();
  350. for (S32 i = 0; i < 6; i++)
  351. {
  352. mSkyTex[i].init();
  353. mShinyTex[i].init();
  354. }
  355. for (S32 i=0; i<FACE_COUNT; i++)
  356. {
  357. mFace[i] = NULL;
  358. }
  360. mCameraPosAgent = gAgent.getCameraPositionAgent();
  361. mAtmHeight = ATM_HEIGHT;
  362. mEarthCenter = LLVector3(mCameraPosAgent.mV[0], mCameraPosAgent.mV[1], -EARTH_RADIUS);
  364. mSunDefaultPosition = LLVector3(LLWLParamManager::instance()->mCurParams.getVector("lightnorm", error));
  365. if (gSavedSettings.getBOOL("SkyOverrideSimSunPosition"))
  366. {
  367. initSunDirection(mSunDefaultPosition, LLVector3(0, 0, 0));
  368. }
  369. mAmbientScale = gSavedSettings.getF32("SkyAmbientScale");
  370. mNightColorShift = gSavedSettings.getColor3("SkyNightColorShift");
  371. mFogColor.mV[VRED] = mFogColor.mV[VGREEN] = mFogColor.mV[VBLUE] = 0.5f;
  372. mFogColor.mV[VALPHA] = 0.0f;
  373. mFogRatio = 1.2f;
  375. mSun.setIntensity(SUN_INTENSITY);
  376. mMoon.setIntensity(0.1f * SUN_INTENSITY);
  378. mSunTexturep = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);
  379. mSunTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  380. mMoonTexturep = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);
  381. mMoonTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  382. mBloomTexturep = LLViewerTextureManager::getFetchedTexture(IMG_BLOOM1);
  383. mBloomTexturep->setNoDelete() ;
  384. mBloomTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  386. mHeavenlyBodyUpdated = FALSE ;
  388. mDrawRefl = 0;
  389. mHazeConcentration = 0.f;
  390. mInterpVal = 0.f;
  391. }
  394. LLVOSky::~LLVOSky()
  395. {
  396. // Don't delete images - it'll get deleted by gTextureList on shutdown
  397. // This needs to be done for each texture
  399. mCubeMap = NULL;
  400. }
  402. void LLVOSky::initClass()
  403. {
  404. LLHaze::initClass();
  405. }
  408. void LLVOSky::init()
  409. {
  410.     const F32 haze_int = color_intens(mHaze.calcSigSca(0));
  411. mHazeConcentration = haze_int /
  412. (color_intens(LLHaze::calcAirSca(0)) + haze_int);
  414. calcAtmospherics();
  416. // Initialize the cached normalized direction vectors
  417. for (S32 side = 0; side < 6; ++side)
  418. {
  419. for (S32 tile = 0; tile < NUM_TILES; ++tile)
  420. {
  421. initSkyTextureDirs(side, tile);
  422. createSkyTexture(side, tile);
  423. }
  424. }
  426. for (S32 i = 0; i < 6; ++i)
  427. {
  428. mSkyTex[i].create(1.0f);
  429. mShinyTex[i].create(1.0f);
  430. }
  432. initCubeMap();
  433. mInitialized = true;
  435. mHeavenlyBodyUpdated = FALSE ;
  436. }
  438. void LLVOSky::initCubeMap() 
  439. {
  440. std::vector<LLPointer<LLImageRaw> > images;
  441. for (S32 side = 0; side < 6; side++)
  442. {
  443. images.push_back(mShinyTex[side].getImageRaw());
  444. }
  445. if (mCubeMap)
  446. {
  447. mCubeMap->init(images);
  448. }
  449. else if (gSavedSettings.getBOOL("RenderWater") && gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps)
  450. {
  451. mCubeMap = new LLCubeMap();
  452. mCubeMap->init(images);
  453. }
  454. gGL.getTexUnit(0)->disable();
  455. }
  458. void LLVOSky::cleanupGL()
  459. {
  460. S32 i;
  461. for (i = 0; i < 6; i++)
  462. {
  463. mSkyTex[i].cleanupGL();
  464. }
  465. if (getCubeMap())
  466. {
  467. getCubeMap()->destroyGL();
  468. }
  469. }
  471. void LLVOSky::restoreGL()
  472. {
  473. S32 i;
  474. for (i = 0; i < 6; i++)
  475. {
  476. mSkyTex[i].restoreGL();
  477. }
  478. mSunTexturep = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);
  479. mSunTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  480. mMoonTexturep = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);
  481. mMoonTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  482. mBloomTexturep = LLViewerTextureManager::getFetchedTexture(IMG_BLOOM1);
  483. mBloomTexturep->setNoDelete() ;
  484. mBloomTexturep->setAddressMode(LLTexUnit::TAM_CLAMP);
  486. calcAtmospherics();
  488. if (gSavedSettings.getBOOL("RenderWater") && gGLManager.mHasCubeMap
  489.     && LLCubeMap::sUseCubeMaps)
  490. {
  491. LLCubeMap* cube_map = getCubeMap();
  493. std::vector<LLPointer<LLImageRaw> > images;
  494. for (S32 side = 0; side < 6; side++)
  495. {
  496. images.push_back(mShinyTex[side].getImageRaw());
  497. }
  499. if(cube_map)
  500. {
  501. cube_map->init(images);
  502. mForceUpdate = TRUE;
  503. }
  504. }
  506. if (mDrawable)
  507. {
  508. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  509. }
  511. }
  513. void LLVOSky::initSkyTextureDirs(const S32 side, const S32 tile)
  514. {
  515. S32 tile_x = tile % NUM_TILES_X;
  516. S32 tile_y = tile / NUM_TILES_X;
  518. S32 tile_x_pos = tile_x * sTileResX;
  519. S32 tile_y_pos = tile_y * sTileResY;
  521. F32 coeff[3] = {0, 0, 0};
  522. const S32 curr_coef = side >> 1; // 0/1 = Z axis, 2/3 = Y, 4/5 = X
  523. const S32 side_dir = (((side & 1) << 1) - 1);  // even = -1, odd = 1
  524. const S32 x_coef = (curr_coef + 1) % 3;
  525. const S32 y_coef = (x_coef + 1) % 3;
  527. coeff[curr_coef] = (F32)side_dir;
  529. F32 inv_res = 1.f/sResolution;
  530. S32 x, y;
  531. for (y = tile_y_pos; y < (tile_y_pos + sTileResY); ++y)
  532. {
  533. for (x = tile_x_pos; x < (tile_x_pos + sTileResX); ++x)
  534. {
  535. coeff[x_coef] = F32((x<<1) + 1) * inv_res - 1.f;
  536. coeff[y_coef] = F32((y<<1) + 1) * inv_res - 1.f;
  537. LLVector3 dir(coeff[0], coeff[1], coeff[2]);
  538. dir.normalize();
  539. mSkyTex[side].setDir(dir, x, y);
  540. mShinyTex[side].setDir(dir, x, y);
  541. }
  542. }
  543. }
  545. void LLVOSky::createSkyTexture(const S32 side, const S32 tile)
  546. {
  547. S32 tile_x = tile % NUM_TILES_X;
  548. S32 tile_y = tile / NUM_TILES_X;
  550. S32 tile_x_pos = tile_x * sTileResX;
  551. S32 tile_y_pos = tile_y * sTileResY;
  553. S32 x, y;
  554. for (y = tile_y_pos; y < (tile_y_pos + sTileResY); ++y)
  555. {
  556. for (x = tile_x_pos; x < (tile_x_pos + sTileResX); ++x)
  557. {
  558. mSkyTex[side].setPixel(calcSkyColorInDir(mSkyTex[side].getDir(x, y)), x, y);
  559. mShinyTex[side].setPixel(calcSkyColorInDir(mSkyTex[side].getDir(x, y), true), x, y);
  560. }
  561. }
  562. }
  564. static inline LLColor3 componentDiv(LLColor3 const &left, LLColor3 const & right)
  565. {
  566. return LLColor3(left.mV[0]/right.mV[0],
  567.  left.mV[1]/right.mV[1],
  568.  left.mV[2]/right.mV[2]);
  569. }
  572. static inline LLColor3 componentMult(LLColor3 const &left, LLColor3 const & right)
  573. {
  574. return LLColor3(left.mV[0]*right.mV[0],
  575.  left.mV[1]*right.mV[1],
  576.  left.mV[2]*right.mV[2]);
  577. }
  580. static inline LLColor3 componentExp(LLColor3 const &v)
  581. {
  582. return LLColor3(exp(v.mV[0]),
  583.  exp(v.mV[1]),
  584.  exp(v.mV[2]));
  585. }
  587. static inline LLColor3 componentPow(LLColor3 const &v, F32 exponent)
  588. {
  589. return LLColor3(pow(v.mV[0], exponent),
  590. pow(v.mV[1], exponent),
  591. pow(v.mV[2], exponent));
  592. }
  594. static inline LLColor3 componentSaturate(LLColor3 const &v)
  595. {
  596. return LLColor3(std::max(std::min(v.mV[0], 1.f), 0.f),
  597.  std::max(std::min(v.mV[1], 1.f), 0.f),
  598.  std::max(std::min(v.mV[2], 1.f), 0.f));
  599. }
  602. static inline LLColor3 componentSqrt(LLColor3 const &v)
  603. {
  604. return LLColor3(sqrt(v.mV[0]),
  605.  sqrt(v.mV[1]),
  606.  sqrt(v.mV[2]));
  607. }
  609. static inline void componentMultBy(LLColor3 & left, LLColor3 const & right)
  610. {
  611. left.mV[0] *= right.mV[0];
  612. left.mV[1] *= right.mV[1];
  613. left.mV[2] *= right.mV[2];
  614. }
  616. static inline LLColor3 colorMix(LLColor3 const & left, LLColor3 const & right, F32 amount)
  617. {
  618. return (left + ((right - left) * amount));
  619. }
  621. static inline F32 texture2D(LLPointer<LLImageRaw> const & tex, LLVector2 const & uv)
  622. {
  623. U16 w = tex->getWidth();
  624. U16 h = tex->getHeight();
  626. U16 r = U16(uv[0] * w) % w;
  627. U16 c = U16(uv[1] * h) % h;
  629. U8 const * imageBuffer = tex->getData();
  631. U8 sample = imageBuffer[r * w + c];
  633. return sample / 255.f;
  634. }
  636. static inline LLColor3 smear(F32 val)
  637. {
  638. return LLColor3(val, val, val);
  639. }
  641. void LLVOSky::initAtmospherics(void)
  642. {
  643. bool error;
  645. // uniform parameters for convenience
  646. dome_radius = LLWLParamManager::instance()->getDomeRadius();
  647. dome_offset_ratio = LLWLParamManager::instance()->getDomeOffset();
  648. sunlight_color = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("sunlight_color", error));
  649. ambient = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("ambient", error));
  650. //lightnorm = LLWLParamManager::instance()->mCurParams.getVector("lightnorm", error);
  651. gamma = LLWLParamManager::instance()->mCurParams.getVector("gamma", error)[0];
  652. blue_density = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("blue_density", error));
  653. blue_horizon = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("blue_horizon", error));
  654. haze_density = LLWLParamManager::instance()->mCurParams.getVector("haze_density", error)[0];
  655. haze_horizon = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("haze_horizon", error));
  656. density_multiplier = LLWLParamManager::instance()->mCurParams.getVector("density_multiplier", error)[0];
  657. max_y = LLWLParamManager::instance()->mCurParams.getVector("max_y", error)[0];
  658. glow = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("glow", error));
  659. cloud_shadow = LLWLParamManager::instance()->mCurParams.getVector("cloud_shadow", error)[0];
  660. cloud_color = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("cloud_color", error));
  661. cloud_scale = LLWLParamManager::instance()->mCurParams.getVector("cloud_scale", error)[0];
  662. cloud_pos_density1 = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("cloud_pos_density1", error));
  663. cloud_pos_density2 = LLColor3(LLWLParamManager::instance()->mCurParams.getVector("cloud_pos_density2", error));
  665. // light norm is different.  We need the sun's direction, not the light direction
  666. // which could be from the moon.  And we need to clamp it
  667. // just like for the gpu
  668. LLVector3 sunDir = gSky.getSunDirection();
  670. // CFR_TO_OGL
  671. lightnorm = LLVector4(sunDir.mV[1], sunDir.mV[2], sunDir.mV[0], 0);
  672. unclamped_lightnorm = lightnorm;
  673. if(lightnorm.mV[1] < -0.1f)
  674. {
  675. lightnorm.mV[1] = -0.1f;
  676. }
  678. }
  680. LLColor4 LLVOSky::calcSkyColorInDir(const LLVector3 &dir, bool isShiny)
  681. {
  682. F32 saturation = 0.3f;
  683. if (dir.mV[VZ] < -0.02f)
  684. {
  685. LLColor4 col = LLColor4(llmax(mFogColor[0],0.2f), llmax(mFogColor[1],0.2f), llmax(mFogColor[2],0.22f),0.f);
  686. if (isShiny)
  687. {
  688. LLColor3 desat_fog = LLColor3(mFogColor);
  689. F32 brightness = desat_fog.brightness();
  690. // So that shiny somewhat shows up at night.
  691. if (brightness < 0.15f)
  692. {
  693. brightness = 0.15f;
  694. desat_fog = smear(0.15f);
  695. }
  696. LLColor3 greyscale = smear(brightness);
  697. desat_fog = desat_fog * saturation + greyscale * (1.0f - saturation);
  698. if (!gPipeline.canUseWindLightShaders())
  699. {
  700. col = LLColor4(desat_fog, 0.f);
  701. }
  702. else 
  703. {
  704. col = LLColor4(desat_fog * 0.5f, 0.f);
  705. }
  706. }
  707. float x = 1.0f-fabsf(-0.1f-dir.mV[VZ]);
  708. x *= x;
  709. col.mV[0] *= x*x;
  710. col.mV[1] *= powf(x, 2.5f);
  711. col.mV[2] *= x*x*x;
  712. return col;
  713. }
  715. // undo OGL_TO_CFR_ROTATION and negate vertical direction.
  716. LLVector3 Pn = LLVector3(-dir[1] , -dir[2], -dir[0]);
  718. LLColor3 vary_HazeColor(0,0,0);
  719. LLColor3 vary_CloudColorSun(0,0,0);
  720. LLColor3 vary_CloudColorAmbient(0,0,0);
  721. F32 vary_CloudDensity(0);
  722. LLVector2 vary_HorizontalProjection[2];
  723. vary_HorizontalProjection[0] = LLVector2(0,0);
  724. vary_HorizontalProjection[1] = LLVector2(0,0);
  726. calcSkyColorWLVert(Pn, vary_HazeColor, vary_CloudColorSun, vary_CloudColorAmbient,
  727. vary_CloudDensity, vary_HorizontalProjection);
  729. LLColor3 sky_color =  calcSkyColorWLFrag(Pn, vary_HazeColor, vary_CloudColorSun, vary_CloudColorAmbient, 
  730. vary_CloudDensity, vary_HorizontalProjection);
  731. if (isShiny)
  732. {
  733. F32 brightness = sky_color.brightness();
  734. LLColor3 greyscale = smear(brightness);
  735. sky_color = sky_color * saturation + greyscale * (1.0f - saturation);
  736. sky_color *= (0.5f + 0.5f * brightness);
  737. }
  738. return LLColor4(sky_color, 0.0f);
  739. }
  741. // turn on floating point precision
  742. // in vs2003 for this function.  Otherwise
  743. // sky is aliased looking 7:10 - 8:50
  744. #if LL_MSVC && __MSVC_VER__ < 8
  745. #pragma optimize("p", on)
  746. #endif
  748. void LLVOSky::calcSkyColorWLVert(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLColor3 & vary_CloudColorSun, 
  749. LLColor3 & vary_CloudColorAmbient, F32 & vary_CloudDensity, 
  750. LLVector2 vary_HorizontalProjection[2])
  751. {
  752. // project the direction ray onto the sky dome.
  753. F32 phi = acos(Pn[1]);
  754. F32 sinA = sin(F_PI - phi);
  755. F32 Plen = dome_radius * sin(F_PI + phi + asin(dome_offset_ratio * sinA)) / sinA;
  757. Pn *= Plen;
  759. vary_HorizontalProjection[0] = LLVector2(Pn[0], Pn[2]);
  760. vary_HorizontalProjection[0] /= - 2.f * Plen;
  762. // Set altitude
  763. if (Pn[1] > 0.f)
  764. {
  765. Pn *= (max_y / Pn[1]);
  766. }
  767. else
  768. {
  769. Pn *= (-32000.f / Pn[1]);
  770. }
  772. Plen = Pn.length();
  773. Pn /= Plen;
  775. // Initialize temp variables
  776. LLColor3 sunlight = sunlight_color;
  778. // Sunlight attenuation effect (hue and brightness) due to atmosphere
  779. // this is used later for sunlight modulation at various altitudes
  780. LLColor3 light_atten =
  781. (blue_density * 1.0 + smear(haze_density * 0.25f)) * (density_multiplier * max_y);
  783. // Calculate relative weights
  784. LLColor3 temp2(0.f, 0.f, 0.f);
  785. LLColor3 temp1 = blue_density + smear(haze_density);
  786. LLColor3 blue_weight = componentDiv(blue_density, temp1);
  787. LLColor3 haze_weight = componentDiv(smear(haze_density), temp1);
  789. // Compute sunlight from P & lightnorm (for long rays like sky)
  790. temp2.mV[1] = llmax(F_APPROXIMATELY_ZERO, llmax(0.f, Pn[1]) * 1.0f + lightnorm[1] );
  792. temp2.mV[1] = 1.f / temp2.mV[1];
  793. componentMultBy(sunlight, componentExp((light_atten * -1.f) * temp2.mV[1]));
  795. // Distance
  796. temp2.mV[2] = Plen * density_multiplier;
  798. // Transparency (-> temp1)
  799. temp1 = componentExp((temp1 * -1.f) * temp2.mV[2]);
  802. // Compute haze glow
  803. temp2.mV[0] = Pn * LLVector3(lightnorm);
  805. temp2.mV[0] = 1.f - temp2.mV[0];
  806. // temp2.x is 0 at the sun and increases away from sun
  807. temp2.mV[0] = llmax(temp2.mV[0], .001f);
  808. // Set a minimum "angle" (smaller glow.y allows tighter, brighter hotspot)
  809. temp2.mV[0] *= glow.mV[0];
  810. // Higher glow.x gives dimmer glow (because next step is 1 / "angle")
  811. temp2.mV[0] = pow(temp2.mV[0], glow.mV[2]);
  812. // glow.z should be negative, so we're doing a sort of (1 / "angle") function
  814. // Add "minimum anti-solar illumination"
  815. temp2.mV[0] += .25f;
  818. // Haze color above cloud
  819. vary_HazeColor = (blue_horizon * blue_weight * (sunlight + ambient)
  820. + componentMult(haze_horizon.mV[0] * haze_weight, sunlight * temp2.mV[0] + ambient)
  821.  );
  823. // Increase ambient when there are more clouds
  824. LLColor3 tmpAmbient = ambient + (LLColor3::white - ambient) * cloud_shadow * 0.5f;
  826. // Dim sunlight by cloud shadow percentage
  827. sunlight *= (1.f - cloud_shadow);
  829. // Haze color below cloud
  830. LLColor3 additiveColorBelowCloud = (blue_horizon * blue_weight * (sunlight + tmpAmbient)
  831. + componentMult(haze_horizon.mV[0] * haze_weight, sunlight * temp2.mV[0] + tmpAmbient)
  832.  );
  834. // Final atmosphere additive
  835. componentMultBy(vary_HazeColor, LLColor3::white - temp1);
  837. sunlight = sunlight_color;
  838. temp2.mV[1] = llmax(0.f, lightnorm[1] * 2.f);
  839. temp2.mV[1] = 1.f / temp2.mV[1];
  840. componentMultBy(sunlight, componentExp((light_atten * -1.f) * temp2.mV[1]));
  842. // Attenuate cloud color by atmosphere
  843. temp1 = componentSqrt(temp1); //less atmos opacity (more transparency) below clouds
  845. // At horizon, blend high altitude sky color towards the darker color below the clouds
  846. vary_HazeColor +=
  847. componentMult(additiveColorBelowCloud - vary_HazeColor, LLColor3::white - componentSqrt(temp1));
  849. if (Pn[1] < 0.f)
  850. {
  851. // Eric's original: 
  852. // LLColor3 dark_brown(0.143f, 0.129f, 0.114f);
  853. LLColor3 dark_brown(0.082f, 0.076f, 0.066f);
  854. LLColor3 brown(0.430f, 0.386f, 0.322f);
  855. LLColor3 sky_lighting = sunlight + ambient;
  856. F32 haze_brightness = vary_HazeColor.brightness();
  858. if (Pn[1] < -0.05f)
  859. {
  860. vary_HazeColor = colorMix(dark_brown, brown, -Pn[1] * 0.9f) * sky_lighting * haze_brightness;
  861. }
  863. if (Pn[1] > -0.1f)
  864. {
  865. vary_HazeColor = colorMix(LLColor3::white * haze_brightness, vary_HazeColor, fabs((Pn[1] + 0.05f) * -20.f));
  866. }
  867. }
  868. }
  870. #if LL_MSVC && __MSVC_VER__ < 8
  871. #pragma optimize("p", off)
  872. #endif
  874. LLColor3 LLVOSky::calcSkyColorWLFrag(LLVector3 & Pn, LLColor3 & vary_HazeColor, LLColor3 & vary_CloudColorSun, 
  875. LLColor3 & vary_CloudColorAmbient, F32 & vary_CloudDensity, 
  876. LLVector2 vary_HorizontalProjection[2])
  877. {
  878. LLColor3 res;
  880. LLColor3 color0 = vary_HazeColor;
  882. if (!gPipeline.canUseWindLightShaders())
  883. {
  884. LLColor3 color1 = color0 * 2.0f;
  885. color1 = smear(1.f) - componentSaturate(color1);
  886. componentPow(color1, gamma);
  887. res = smear(1.f) - color1;
  888. } 
  889. else 
  890. {
  891. res = color0;
  892. }
  894. # ifndef LL_RELEASE_FOR_DOWNLOAD
  896. LLColor3 color2 = 2.f * color0;
  898. LLColor3 color3 = LLColor3(1.f, 1.f, 1.f) - componentSaturate(color2);
  899. componentPow(color3, gamma);
  900. color3 = LLColor3(1.f, 1.f, 1.f) - color3;
  902. static enum {
  903. OUT_DEFAULT = 0,
  904. OUT_SKY_BLUE = 1,
  905. OUT_RED = 2,
  906. OUT_PN = 3,
  907. OUT_HAZE = 4,
  908. } debugOut = OUT_DEFAULT;
  910. switch(debugOut) 
  911. {
  912. case OUT_DEFAULT:
  913. break;
  914. case OUT_SKY_BLUE:
  915. res = LLColor3(0.4f, 0.4f, 0.9f);
  916. break;
  917. case OUT_RED:
  918. res = LLColor3(1.f, 0.f, 0.f);
  919. break;
  920. case OUT_PN:
  921. res = LLColor3(Pn[0], Pn[1], Pn[2]);
  922. break;
  923. case OUT_HAZE:
  924. res = vary_HazeColor;
  925. break;
  926. }
  927. # endif // LL_RELEASE_FOR_DOWNLOAD
  928. return res;
  929. }
  931. LLColor3 LLVOSky::createDiffuseFromWL(LLColor3 diffuse, LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient)
  932. {
  933. return componentMult(diffuse, sundiffuse) * 4.0f +
  934. componentMult(ambient, sundiffuse) * 2.0f + sunambient;
  935. }
  937. LLColor3 LLVOSky::createAmbientFromWL(LLColor3 ambient, LLColor3 sundiffuse, LLColor3 sunambient)
  938. {
  939. return (componentMult(ambient, sundiffuse) + sunambient) * 0.8f;
  940. }
  943. void LLVOSky::calcAtmospherics(void)
  944. {
  945. initAtmospherics();
  947. LLColor3 vary_HazeColor;
  948. LLColor3 vary_SunlightColor;
  949. LLColor3 vary_AmbientColor;
  950. {
  951. // Initialize temp variables
  952. LLColor3 sunlight = sunlight_color;
  954. // Sunlight attenuation effect (hue and brightness) due to atmosphere
  955. // this is used later for sunlight modulation at various altitudes
  956. LLColor3 light_atten =
  957. (blue_density * 1.0 + smear(haze_density * 0.25f)) * (density_multiplier * max_y);
  959. // Calculate relative weights
  960. LLColor3 temp2(0.f, 0.f, 0.f);
  961. LLColor3 temp1 = blue_density + smear(haze_density);
  962. LLColor3 blue_weight = componentDiv(blue_density, temp1);
  963. LLColor3 haze_weight = componentDiv(smear(haze_density), temp1);
  965. // Compute sunlight from P & lightnorm (for long rays like sky)
  966. /// USE only lightnorm.
  967. // temp2[1] = llmax(0.f, llmax(0.f, Pn[1]) * 1.0f + lightnorm[1] );
  969. // and vary_sunlight will work properly with moon light
  970. F32 lighty = unclamped_lightnorm[1];
  971. if(lighty < LLSky::NIGHTTIME_ELEVATION_COS)
  972. {
  973. lighty = -lighty;
  974. }
  976. temp2.mV[1] = llmax(0.f, lighty);
  977. temp2.mV[1] = 1.f / temp2.mV[1];
  978. componentMultBy(sunlight, componentExp((light_atten * -1.f) * temp2.mV[1]));
  980. // Distance
  981. temp2.mV[2] = density_multiplier;
  983. // Transparency (-> temp1)
  984. temp1 = componentExp((temp1 * -1.f) * temp2.mV[2]);
  986. // vary_AtmosAttenuation = temp1; 
  988. //increase ambient when there are more clouds
  989. LLColor3 tmpAmbient = ambient + (smear(1.f) - ambient) * cloud_shadow * 0.5f;
  991. //haze color
  992. vary_HazeColor =
  993. (blue_horizon * blue_weight * (sunlight*(1.f - cloud_shadow) + tmpAmbient)
  994. + componentMult(haze_horizon.mV[0] * haze_weight, sunlight*(1.f - cloud_shadow) * temp2.mV[0] + tmpAmbient)
  995.  );
  997. //brightness of surface both sunlight and ambient
  998. vary_SunlightColor = componentMult(sunlight, temp1) * 1.f;
  999. vary_SunlightColor.clamp();
  1000. vary_SunlightColor = smear(1.0f) - vary_SunlightColor;
  1001. vary_SunlightColor = componentPow(vary_SunlightColor, gamma);
  1002. vary_SunlightColor = smear(1.0f) - vary_SunlightColor;
  1003. vary_AmbientColor = componentMult(tmpAmbient, temp1) * 0.5;
  1004. vary_AmbientColor.clamp();
  1005. vary_AmbientColor = smear(1.0f) - vary_AmbientColor;
  1006. vary_AmbientColor = componentPow(vary_AmbientColor, gamma);
  1007. vary_AmbientColor = smear(1.0f) - vary_AmbientColor;
  1009. componentMultBy(vary_HazeColor, LLColor3(1.f, 1.f, 1.f) - temp1);
  1011. }
  1013. mSun.setColor(vary_SunlightColor);
  1014. mMoon.setColor(LLColor3(1.0f, 1.0f, 1.0f));
  1016. mSun.renewDirection();
  1017. mSun.renewColor();
  1018. mMoon.renewDirection();
  1019. mMoon.renewColor();
  1021. float dp = getToSunLast() * LLVector3(0,0,1.f);
  1022. if (dp < 0)
  1023. {
  1024. dp = 0;
  1025. }
  1027. // Since WL scales everything by 2, there should always be at least a 2:1 brightness ratio
  1028. // between sunlight and point lights in windlight to normalize point lights.
  1029. F32 sun_dynamic_range = llmax(gSavedSettings.getF32("RenderSunDynamicRange"), 0.0001f);
  1030. LLWLParamManager::instance()->mSceneLightStrength = 2.0f * (1.0f + sun_dynamic_range * dp);
  1032. mSunDiffuse = vary_SunlightColor;
  1033. mSunAmbient = vary_AmbientColor;
  1034. mMoonDiffuse = vary_SunlightColor;
  1035. mMoonAmbient = vary_AmbientColor;
  1037. mTotalAmbient = vary_AmbientColor;
  1038. mTotalAmbient.setAlpha(1);
  1040. mFadeColor = mTotalAmbient + (mSunDiffuse + mMoonDiffuse) * 0.5f;
  1041. mFadeColor.setAlpha(0);
  1042. }
  1044. BOOL LLVOSky::idleUpdate(LLAgent &agent, LLWorld &world, const F64 &time)
  1045. {
  1046. return TRUE;
  1047. }
  1049. BOOL LLVOSky::updateSky()
  1050. {
  1051. if (mDead || !(gPipeline.hasRenderType(LLPipeline::RENDER_TYPE_SKY)))
  1052. {
  1053. return TRUE;
  1054. }
  1056. if (mDead)
  1057. {
  1058. // It's dead.  Don't update it.
  1059. return TRUE;
  1060. }
  1061. if (gGLManager.mIsDisabled)
  1062. {
  1063. return TRUE;
  1064. }
  1066. static S32 next_frame = 0;
  1067. const S32 total_no_tiles = 6 * NUM_TILES;
  1068. const S32 cycle_frame_no = total_no_tiles + 1;
  1070. if (mUpdateTimer.getElapsedTimeF32() > 0.001f)
  1071. {
  1072. mUpdateTimer.reset();
  1073. const S32 frame = next_frame;
  1075. ++next_frame;
  1076. next_frame = next_frame % cycle_frame_no;
  1078. mInterpVal = (!mInitialized) ? 1 : (F32)next_frame / cycle_frame_no;
  1079. // sInterpVal = (F32)next_frame / cycle_frame_no;
  1080. LLSkyTex::setInterpVal( mInterpVal );
  1081. LLHeavenBody::setInterpVal( mInterpVal );
  1082. calcAtmospherics();
  1084. if (mForceUpdate || total_no_tiles == frame)
  1085. {
  1086. LLSkyTex::stepCurrent();
  1088. const static F32 LIGHT_DIRECTION_THRESHOLD = (F32) cos(DEG_TO_RAD * 1.f);
  1089. const static F32 COLOR_CHANGE_THRESHOLD = 0.01f;
  1091. LLVector3 direction = mSun.getDirection();
  1092. direction.normalize();
  1093. const F32 dot_lighting = direction * mLastLightingDirection;
  1095. LLColor3 delta_color;
  1096. delta_color.setVec(mLastTotalAmbient.mV[0] - mTotalAmbient.mV[0],
  1097.    mLastTotalAmbient.mV[1] - mTotalAmbient.mV[1],
  1098.    mLastTotalAmbient.mV[2] - mTotalAmbient.mV[2]);
  1100. if ( mForceUpdate 
  1101.  || (((dot_lighting < LIGHT_DIRECTION_THRESHOLD)
  1102.  || (delta_color.length() > COLOR_CHANGE_THRESHOLD)
  1103.  || !mInitialized)
  1104. && !direction.isExactlyZero()))
  1105. {
  1106. mLastLightingDirection = direction;
  1107. mLastTotalAmbient = mTotalAmbient;
  1108. mInitialized = TRUE;
  1110. if (mCubeMap)
  1111. {
  1112.                     if (mForceUpdate)
  1113. {
  1114. updateFog(LLViewerCamera::getInstance()->getFar());
  1115. for (int side = 0; side < 6; side++) 
  1116. {
  1117. for (int tile = 0; tile < NUM_TILES; tile++) 
  1118. {
  1119. createSkyTexture(side, tile);
  1120. }
  1121. }
  1123. calcAtmospherics();
  1125. for (int side = 0; side < 6; side++) 
  1126. {
  1127. LLImageRaw* raw1 = mSkyTex[side].getImageRaw(TRUE);
  1128. LLImageRaw* raw2 = mSkyTex[side].getImageRaw(FALSE);
  1129. raw2->copy(raw1);
  1130. mSkyTex[side].createGLImage(mSkyTex[side].getWhich(FALSE));
  1132. raw1 = mShinyTex[side].getImageRaw(TRUE);
  1133. raw2 = mShinyTex[side].getImageRaw(FALSE);
  1134. raw2->copy(raw1);
  1135. mShinyTex[side].createGLImage(mShinyTex[side].getWhich(FALSE));
  1136. }
  1137. next_frame = 0;
  1138. }
  1139. }
  1140. }
  1142. /// *TODO really, sky texture and env map should be shared on a single texture
  1143. /// I'll let Brad take this at some point
  1145. // update the sky texture
  1146. for (S32 i = 0; i < 6; ++i)
  1147. {
  1148. mSkyTex[i].create(1.0f);
  1149. mShinyTex[i].create(1.0f);
  1150. }
  1152. // update the environment map
  1153. if (mCubeMap)
  1154. {
  1155. std::vector<LLPointer<LLImageRaw> > images;
  1156. images.reserve(6);
  1157. for (S32 side = 0; side < 6; side++)
  1158. {
  1159. images.push_back(mShinyTex[side].getImageRaw(TRUE));
  1160. }
  1161. mCubeMap->init(images);
  1162. gGL.getTexUnit(0)->disable();
  1163. }
  1165. gPipeline.markRebuild(gSky.mVOGroundp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  1166. // *TODO: decide whether we need to update the stars vertex buffer in LLVOWLSky -Brad.
  1167. //gPipeline.markRebuild(gSky.mVOWLSkyp->mDrawable, LLDrawable::REBUILD_ALL, TRUE);
  1169. mForceUpdate = FALSE;
  1170. }
  1171. else
  1172. {
  1173. const S32 side = frame / NUM_TILES;
  1174. const S32 tile = frame % NUM_TILES;
  1175. createSkyTexture(side, tile);
  1176. }
  1177. }
  1179. if (mDrawable.notNull() && mDrawable->getFace(0) && mDrawable->getFace(0)->mVertexBuffer.isNull())
  1180. {
  1181. gPipeline.markRebuild(mDrawable, LLDrawable::REBUILD_VOLUME, TRUE);
  1182. }
  1183. return TRUE;
  1184. }
  1186. void LLVOSky::updateTextures()
  1187. {
  1188. if (mSunTexturep)
  1189. {
  1190. mSunTexturep->addTextureStats( (F32)MAX_IMAGE_AREA );
  1191. mMoonTexturep->addTextureStats( (F32)MAX_IMAGE_AREA );
  1192. mBloomTexturep->addTextureStats( (F32)MAX_IMAGE_AREA );
  1193. }
  1194. }
  1196. LLDrawable *LLVOSky::createDrawable(LLPipeline *pipeline)
  1197. {
  1198. pipeline->allocDrawable(this);
  1199. mDrawable->setLit(FALSE);
  1201. LLDrawPoolSky *poolp = (LLDrawPoolSky*) gPipeline.getPool(LLDrawPool::POOL_SKY);
  1202. poolp->setSkyTex(mSkyTex);
  1203. mDrawable->setRenderType(LLPipeline::RENDER_TYPE_SKY);
  1205. for (S32 i = 0; i < 6; ++i)
  1206. {
  1207. mFace[FACE_SIDE0 + i] = mDrawable->addFace(poolp, NULL);
  1208. }
  1210. mFace[FACE_SUN] = mDrawable->addFace(poolp, mSunTexturep);
  1211. mFace[FACE_MOON] = mDrawable->addFace(poolp, mMoonTexturep);
  1212. mFace[FACE_BLOOM] = mDrawable->addFace(poolp, mBloomTexturep);
  1214. return mDrawable;
  1215. }
  1217. //by bao
  1218. //fake vertex buffer updating
  1219. //to guarantee at least updating one VBO buffer every frame
  1220. //to walk around the bug caused by ATI card --> DEV-3855
  1221. //
  1222. void LLVOSky::createDummyVertexBuffer()
  1223. {
  1224. if(!mFace[FACE_DUMMY])
  1225. {
  1226. LLDrawPoolSky *poolp = (LLDrawPoolSky*) gPipeline.getPool(LLDrawPool::POOL_SKY);
  1227. mFace[FACE_DUMMY] = mDrawable->addFace(poolp, NULL);
  1228. }
  1230. if(mFace[FACE_DUMMY]->mVertexBuffer.isNull())
  1231. {
  1232. mFace[FACE_DUMMY]->mVertexBuffer = new LLVertexBuffer(LLDrawPoolSky::VERTEX_DATA_MASK, GL_DYNAMIC_DRAW_ARB);
  1233. mFace[FACE_DUMMY]->mVertexBuffer->allocateBuffer(1, 1, TRUE);
  1234. }
  1235. }
  1237. static LLFastTimer::DeclareTimer FTM_RENDER_FAKE_VBO_UPDATE("Fake VBO Update");
  1239. void LLVOSky::updateDummyVertexBuffer()
  1240. {
  1241. if(!LLVertexBuffer::sEnableVBOs)
  1242. return ;
  1244. if(mHeavenlyBodyUpdated)
  1245. {
  1246. mHeavenlyBodyUpdated = FALSE ;
  1247. return ;
  1248. }
  1250. LLFastTimer t(FTM_RENDER_FAKE_VBO_UPDATE) ;
  1252. if(!mFace[FACE_DUMMY] || mFace[FACE_DUMMY]->mVertexBuffer.isNull())
  1253. createDummyVertexBuffer() ;
  1255. LLStrider<LLVector3> vertices ;
  1256. mFace[FACE_DUMMY]->mVertexBuffer->getVertexStrider(vertices,  0);
  1257. *vertices = mCameraPosAgent ;
  1258. mFace[FACE_DUMMY]->mVertexBuffer->setBuffer(0) ;
  1259. }
  1260. //----------------------------------
  1261. //end of fake vertex buffer updating
  1262. //----------------------------------
  1263. static LLFastTimer::DeclareTimer FTM_GEO_SKY("Sky Geometry");
  1265. BOOL LLVOSky::updateGeometry(LLDrawable *drawable)
  1266. {
  1267. LLFastTimer ftm(FTM_GEO_SKY);
  1268. if (mFace[FACE_REFLECTION] == NULL)
  1269. {
  1270. LLDrawPoolWater *poolp = (LLDrawPoolWater*) gPipeline.getPool(LLDrawPool::POOL_WATER);
  1271. if (gPipeline.getPool(LLDrawPool::POOL_WATER)->getVertexShaderLevel() != 0)
  1272. {
  1273. mFace[FACE_REFLECTION] = drawable->addFace(poolp, NULL);
  1274. }
  1275. }
  1277. mCameraPosAgent = drawable->getPositionAgent();
  1278. mEarthCenter.mV[0] = mCameraPosAgent.mV[0];
  1279. mEarthCenter.mV[1] = mCameraPosAgent.mV[1];
  1281. LLVector3 v_agent[8];
  1282. for (S32 i = 0; i < 8; ++i)
  1283. {
  1284. F32 x_sgn = (i&1) ? 1.f : -1.f;
  1285. F32 y_sgn = (i&2) ? 1.f : -1.f;
  1286. F32 z_sgn = (i&4) ? 1.f : -1.f;
  1287. v_agent[i] = HORIZON_DIST * SKY_BOX_MULT * LLVector3(x_sgn, y_sgn, z_sgn);
  1288. }
  1290. LLStrider<LLVector3> verticesp;
  1291. LLStrider<LLVector3> normalsp;
  1292. LLStrider<LLVector2> texCoordsp;
  1293. LLStrider<U16> indicesp;
  1294. U16 index_offset;
  1295. LLFace *face;
  1297. for (S32 side = 0; side < 6; ++side)
  1298. {
  1299. face = mFace[FACE_SIDE0 + side]; 
  1301. if (face->mVertexBuffer.isNull())
  1302. {
  1303. face->setSize(4, 6);
  1304. face->setGeomIndex(0);
  1305. face->setIndicesIndex(0);
  1306. face->mVertexBuffer = new LLVertexBuffer(LLDrawPoolSky::VERTEX_DATA_MASK, GL_STREAM_DRAW_ARB);
  1307. face->mVertexBuffer->allocateBuffer(4, 6, TRUE);
  1309. index_offset = face->getGeometry(verticesp,normalsp,texCoordsp, indicesp);
  1311. S32 vtx = 0;
  1312. S32 curr_bit = side >> 1; // 0/1 = Z axis, 2/3 = Y, 4/5 = X
  1313. S32 side_dir = side & 1;  // even - 0, odd - 1
  1314. S32 i_bit = (curr_bit + 2) % 3;
  1315. S32 j_bit = (i_bit + 2) % 3;
  1317. LLVector3 axis;
  1318. axis.mV[curr_bit] = 1;
  1319. face->mCenterAgent = (F32)((side_dir << 1) - 1) * axis * HORIZON_DIST;
  1321. vtx = side_dir << curr_bit;
  1322. *(verticesp++)  = v_agent[vtx];
  1323. *(verticesp++)  = v_agent[vtx | 1 << j_bit];
  1324. *(verticesp++)  = v_agent[vtx | 1 << i_bit];
  1325. *(verticesp++)  = v_agent[vtx | 1 << i_bit | 1 << j_bit];
  1327. *(texCoordsp++) = TEX00;
  1328. *(texCoordsp++) = TEX01;
  1329. *(texCoordsp++) = TEX10;
  1330. *(texCoordsp++) = TEX11;
  1332. // Triangles for each side
  1333. *indicesp++ = index_offset + 0;
  1334. *indicesp++ = index_offset + 1;
  1335. *indicesp++ = index_offset + 3;
  1337. *indicesp++ = index_offset + 0;
  1338. *indicesp++ = index_offset + 3;
  1339. *indicesp++ = index_offset + 2;
  1341. face->mVertexBuffer->setBuffer(0);
  1342. }
  1343. }
  1345. const LLVector3 &look_at = LLViewerCamera::getInstance()->getAtAxis();
  1346. LLVector3 right = look_at % LLVector3::z_axis;
  1347. LLVector3 up = right % look_at;
  1348. right.normalize();
  1349. up.normalize();
  1351. const static F32 elevation_factor = 0.0f/sResolution;
  1352. const F32 cos_max_angle = cosHorizon(elevation_factor);
  1353. mSun.setDraw(updateHeavenlyBodyGeometry(drawable, FACE_SUN, TRUE, mSun, cos_max_angle, up, right));
  1354. mMoon.setDraw(updateHeavenlyBodyGeometry(drawable, FACE_MOON, FALSE, mMoon, cos_max_angle, up, right));
  1356. const F32 water_height = gAgent.getRegion()->getWaterHeight() + 0.01f;
  1357. // LLWorld::getInstance()->getWaterHeight() + 0.01f;
  1358. const F32 camera_height = mCameraPosAgent.mV[2];
  1359. const F32 height_above_water = camera_height - water_height;
  1361. BOOL sun_flag = FALSE;
  1363. if (mSun.isVisible())
  1364. {
  1365. if (mMoon.isVisible())
  1366. {
  1367. sun_flag = look_at * mSun.getDirection() > 0;
  1368. }
  1369. else
  1370. {
  1371. sun_flag = TRUE;
  1372. }
  1373. }
  1375. if (height_above_water > 0)
  1376. {
  1377. BOOL render_ref = gPipeline.getPool(LLDrawPool::POOL_WATER)->getVertexShaderLevel() == 0;
  1379. if (sun_flag)
  1380. {
  1381. setDrawRefl(0);
  1382. if (render_ref)
  1383. {
  1384. updateReflectionGeometry(drawable, height_above_water, mSun);
  1385. }
  1386. }
  1387. else
  1388. {
  1389. setDrawRefl(1);
  1390. if (render_ref)
  1391. {
  1392. updateReflectionGeometry(drawable, height_above_water, mMoon);
  1393. }
  1394. }
  1395. }
  1396. else
  1397. {
  1398. setDrawRefl(-1);
  1399. }
  1401. LLPipeline::sCompiles++;
  1402. return TRUE;
  1403. }
  1405. BOOL LLVOSky::updateHeavenlyBodyGeometry(LLDrawable *drawable, const S32 f, const BOOL is_sun,
  1406.  LLHeavenBody& hb, const F32 cos_max_angle,
  1407.  const LLVector3 &up, const LLVector3 &right)
  1408. {
  1409. mHeavenlyBodyUpdated = TRUE ;
  1411. LLStrider<LLVector3> verticesp;
  1412. LLStrider<LLVector3> normalsp;
  1413. LLStrider<LLVector2> texCoordsp;
  1414. LLStrider<U16> indicesp;
  1415. S32 index_offset;
  1416. LLFace *facep;
  1418. LLVector3 to_dir = hb.getDirection();
  1420. if (!is_sun)
  1421. {
  1422. to_dir.mV[2] = llmax(to_dir.mV[2]+0.1f, 0.1f);
  1423. }
  1424. LLVector3 draw_pos = to_dir * HEAVENLY_BODY_DIST;
  1427. LLVector3 hb_right = to_dir % LLVector3::z_axis;
  1428. LLVector3 hb_up = hb_right % to_dir;
  1429. hb_right.normalize();
  1430. hb_up.normalize();
  1432. //const static F32 cos_max_turn = sqrt(3.f) / 2; // 30 degrees
  1433. //const F32 cos_turn_right = 1. / (llmax(cos_max_turn, hb_right * right));
  1434. //const F32 cos_turn_up = 1. / llmax(cos_max_turn, hb_up * up);
  1436. const F32 enlargm_factor = ( 1 - to_dir.mV[2] );
  1437. F32 horiz_enlargement = 1 + enlargm_factor * 0.3f;
  1438. F32 vert_enlargement = 1 + enlargm_factor * 0.2f;
  1440. // Parameters for the water reflection
  1441. hb.setU(HEAVENLY_BODY_FACTOR * horiz_enlargement * hb.getDiskRadius() * hb_right);
  1442. hb.setV(HEAVENLY_BODY_FACTOR * vert_enlargement * hb.getDiskRadius() * hb_up);
  1443. // End of parameters for the water reflection
  1445. const LLVector3 scaled_right = HEAVENLY_BODY_DIST * hb.getU();
  1446. const LLVector3 scaled_up = HEAVENLY_BODY_DIST * hb.getV();
  1448. //const LLVector3 scaled_right = horiz_enlargement * HEAVENLY_BODY_SCALE * hb.getDiskRadius() * hb_right;//right;
  1449. //const LLVector3 scaled_up = vert_enlargement * HEAVENLY_BODY_SCALE * hb.getDiskRadius() * hb_up;//up;
  1450. LLVector3 v_clipped[4];
  1452. hb.corner(0) = draw_pos - scaled_right + scaled_up;
  1453. hb.corner(1) = draw_pos - scaled_right - scaled_up;
  1454. hb.corner(2) = draw_pos + scaled_right + scaled_up;
  1455. hb.corner(3) = draw_pos + scaled_right - scaled_up;
  1458. F32 t_left, t_right;
  1459. if (!clip_quad_to_horizon(t_left, t_right, v_clipped, hb.corners(), cos_max_angle))
  1460. {
  1461. hb.setVisible(FALSE);
  1462. return FALSE;
  1463. }
  1464. hb.setVisible(TRUE);
  1466. facep = mFace[f]; 
  1468. if (facep->mVertexBuffer.isNull())
  1469. {
  1470. facep->setSize(4, 6);
  1471. facep->mVertexBuffer = new LLVertexBuffer(LLDrawPoolSky::VERTEX_DATA_MASK, GL_STREAM_DRAW_ARB);
  1472. facep->mVertexBuffer->allocateBuffer(facep->getGeomCount(), facep->getIndicesCount(), TRUE);
  1473. facep->setGeomIndex(0);
  1474. facep->setIndicesIndex(0);
  1475. }
  1477. index_offset = facep->getGeometry(verticesp,normalsp,texCoordsp, indicesp);
  1479. if (-1 == index_offset)
  1480. {
  1481. return TRUE;
  1482. }
  1484. for (S32 vtx = 0; vtx < 4; ++vtx)
  1485. {
  1486. hb.corner(vtx) = v_clipped[vtx];
  1487. *(verticesp++)  = hb.corner(vtx) + mCameraPosAgent;
  1488. }
  1490. *(texCoordsp++) = TEX01;
  1491. *(texCoordsp++) = TEX00;
  1492. *(texCoordsp++) = TEX11;
  1493. *(texCoordsp++) = TEX10;
  1495. *indicesp++ = index_offset + 0;
  1496. *indicesp++ = index_offset + 2;
  1497. *indicesp++ = index_offset + 1;
  1499. *indicesp++ = index_offset + 1;
  1500. *indicesp++ = index_offset + 2;
  1501. *indicesp++ = index_offset + 3;
  1503. facep->mVertexBuffer->setBuffer(0);
  1505. if (is_sun)
  1506. {
  1507. if ((t_left > 0) && (t_right > 0))
  1508. {
  1509. F32 t = (t_left + t_right) * 0.5f;
  1510. mSun.setHorizonVisibility(0.5f * (1 + cos(t * F_PI)));
  1511. }
  1512. else
  1513. {
  1514. mSun.setHorizonVisibility();
  1515. }
  1516. updateSunHaloGeometry(drawable);
  1517. }
  1519. return TRUE;
  1520. }
  1525. // Clips quads with top and bottom sides parallel to horizon.
  1527. BOOL clip_quad_to_horizon(F32& t_left, F32& t_right, LLVector3 v_clipped[4],
  1528.   const LLVector3 v_corner[4], const F32 cos_max_angle)
  1529. {
  1530. t_left = clip_side_to_horizon(v_corner[1], v_corner[0], cos_max_angle);
  1531. t_right = clip_side_to_horizon(v_corner[3], v_corner[2], cos_max_angle);
  1533. if ((t_left >= 1) || (t_right >= 1))
  1534. {
  1535. return FALSE;
  1536. }
  1538. //const BOOL left_clip = (t_left > 0);
  1539. //const BOOL right_clip = (t_right > 0);
  1541. //if (!left_clip && !right_clip)
  1542. {
  1543. for (S32 vtx = 0; vtx < 4; ++vtx)
  1544. {
  1545. v_clipped[vtx]  = v_corner[vtx];
  1546. }
  1547. }
  1548. /* else
  1549. {
  1550. v_clipped[0] = v_corner[0];
  1551. v_clipped[1] = left_clip ? ((1 - t_left) * v_corner[1] + t_left * v_corner[0])
  1552. : v_corner[1];
  1553. v_clipped[2] = v_corner[2];
  1554. v_clipped[3] = right_clip ? ((1 - t_right) * v_corner[3] + t_right * v_corner[2])
  1555. : v_corner[3];
  1556. }*/
  1558. return TRUE;
  1559. }
  1562. F32 clip_side_to_horizon(const LLVector3& V0, const LLVector3& V1, const F32 cos_max_angle)
  1563. {
  1564. const LLVector3 V = V1 - V0;
  1565. const F32 k2 = 1.f/(cos_max_angle * cos_max_angle) - 1;
  1566. const F32 A = V.mV[0] * V.mV[0] + V.mV[1] * V.mV[1] - k2 * V.mV[2] * V.mV[2];
  1567. const F32 B = V0.mV[0] * V.mV[0] + V0.mV[1] * V.mV[1] - k2 * V0.mV[2] * V.mV[2];
  1568. const F32 C = V0.mV[0] * V0.mV[0] + V0.mV[1] * V0.mV[1] - k2 * V0.mV[2] * V0.mV[2];
  1570. if (fabs(A) < 1e-7)
  1571. {
  1572. return -0.1f; // v0 is cone origin and v1 is on the surface of the cone.
  1573. }
  1575. const F32 det = sqrt(B*B - A*C);
  1576. const F32 t1 = (-B - det) / A;
  1577. const F32 t2 = (-B + det) / A;
  1578. const F32 z1 = V0.mV[2] + t1 * V.mV[2];
  1579. const F32 z2 = V0.mV[2] + t2 * V.mV[2];
  1580. if (z1 * cos_max_angle < 0)
  1581. {
  1582. return t2;
  1583. }
  1584. else if (z2 * cos_max_angle < 0)
  1585. {
  1586. return t1;
  1587. }
  1588. else if ((t1 < 0) || (t1 > 1))
  1589. {
  1590. return t2;
  1591. }
  1592. else
  1593. {
  1594. return t1;
  1595. }
  1596. }
  1599. void LLVOSky::updateSunHaloGeometry(LLDrawable *drawable )
  1600. {
  1601. #if 0
  1602. const LLVector3* v_corner = mSun.corners();
  1604. LLStrider<LLVector3> verticesp;
  1605. LLStrider<LLVector3> normalsp;
  1606. LLStrider<LLVector2> texCoordsp;
  1607. LLStrider<U16> indicesp;
  1608. S32 index_offset;
  1609. LLFace *face;
  1611. const LLVector3 right = 2 * (v_corner[2] - v_corner[0]);
  1612. LLVector3 up = 2 * (v_corner[2] - v_corner[3]);
  1613. up.normalize();
  1614. F32 size = right.length();
  1615. up = size * up;
  1616. const LLVector3 draw_pos = 0.25 * (v_corner[0] + v_corner[1] + v_corner[2] + v_corner[3]);
  1618. LLVector3 v_glow_corner[4];
  1620. v_glow_corner[0] = draw_pos - right + up;
  1621. v_glow_corner[1] = draw_pos - right - up;
  1622. v_glow_corner[2] = draw_pos + right + up;
  1623. v_glow_corner[3] = draw_pos + right - up;
  1625. face = mFace[FACE_BLOOM]; 
  1627. if (face->mVertexBuffer.isNull())
  1628. {
  1629. face->setSize(4, 6);
  1630. face->setGeomIndex(0);
  1631. face->setIndicesIndex(0);
  1632. face->mVertexBuffer = new LLVertexBuffer(LLDrawPoolWater::VERTEX_DATA_MASK, GL_STREAM_DRAW_ARB);
  1633. face->mVertexBuffer->allocateBuffer(4, 6, TRUE);
  1634. }
  1636. index_offset = face->getGeometry(verticesp,normalsp,texCoordsp, indicesp);
  1637. if (-1 == index_offset)
  1638. {
  1639. return;
  1640. }
  1642. for (S32 vtx = 0; vtx < 4; ++vtx)
  1643. {
  1644. *(verticesp++)  = v_glow_corner[vtx] + mCameraPosAgent;
  1645. }
  1647. *(texCoordsp++) = TEX01;
  1648. *(texCoordsp++) = TEX00;
  1649. *(texCoordsp++) = TEX11;
  1650. *(texCoordsp++) = TEX10;
  1652. *indicesp++ = index_offset + 0;
  1653. *indicesp++ = index_offset + 2;
  1654. *indicesp++ = index_offset + 1;
  1656. *indicesp++ = index_offset + 1;
  1657. *indicesp++ = index_offset + 2;
  1658. *indicesp++ = index_offset + 3;
  1659. #endif
  1660. }
  1663. F32 dtReflection(const LLVector3& p, F32 cos_dir_from_top, F32 sin_dir_from_top, F32 diff_angl_dir)
  1664. {
  1665. LLVector3 P = p;
  1666. P.normalize();
  1668. const F32 cos_dir_angle = -P.mV[VZ];
  1669. const F32 sin_dir_angle = sqrt(1 - cos_dir_angle * cos_dir_angle);
  1671. F32 cos_diff_angles = cos_dir_angle * cos_dir_from_top
  1672. + sin_dir_angle * sin_dir_from_top;
  1674. F32 diff_angles;
  1675. if (cos_diff_angles > (1 - 1e-7))
  1676. diff_angles = 0;
  1677. else
  1678. diff_angles = acos(cos_diff_angles);
  1680. const F32 rel_diff_angles = diff_angles / diff_angl_dir;
  1681. const F32 dt = 1 - rel_diff_angles;
  1683. return (dt < 0) ? 0 : dt;
  1684. }
  1687. F32 dtClip(const LLVector3& v0, const LLVector3& v1, F32 far_clip2)
  1688. {
  1689. F32 dt_clip;
  1690. const LLVector3 otrezok = v1 - v0;
  1691. const F32 A = otrezok.lengthSquared();
  1692. const F32 B = v0 * otrezok;
  1693. const F32 C = v0.lengthSquared() - far_clip2;
  1694. const F32 det = sqrt(B*B - A*C);
  1695. dt_clip = (-B - det) / A;
  1696. if ((dt_clip < 0) || (dt_clip > 1))
  1697. dt_clip = (-B + det) / A;
  1698. return dt_clip;
  1699. }
  1702. void LLVOSky::updateReflectionGeometry(LLDrawable *drawable, F32 H,
  1703.  const LLHeavenBody& HB)
  1704. {
  1705. const LLVector3 &look_at = LLViewerCamera::getInstance()->getAtAxis();
  1706. // const F32 water_height = gAgent.getRegion()->getWaterHeight() + 0.001f;
  1707. // LLWorld::getInstance()->getWaterHeight() + 0.001f;
  1709. LLVector3 to_dir = HB.getDirection();
  1710. LLVector3 hb_pos = to_dir * (HORIZON_DIST - 10);
  1711. LLVector3 to_dir_proj = to_dir;
  1712. to_dir_proj.mV[VZ] = 0;
  1713. to_dir_proj.normalize();
  1715. LLVector3 Right = to_dir % LLVector3::z_axis;
  1716. LLVector3 Up = Right % to_dir;
  1717. Right.normalize();
  1718. Up.normalize();
  1720. // finding angle between  look direction and sprite.
  1721. LLVector3 look_at_right = look_at % LLVector3::z_axis;
  1722. look_at_right.normalize();
  1724. const static F32 cos_horizon_angle = cosHorizon(0.0f/sResolution);
  1725. //const static F32 horizon_angle = acos(cos_horizon_angle);
  1727. const F32 enlargm_factor = ( 1 - to_dir.mV[2] );
  1728. F32 horiz_enlargement = 1 + enlargm_factor * 0.3f;
  1729. F32 vert_enlargement = 1 + enlargm_factor * 0.2f;
  1731. F32 vert_size = vert_enlargement * HEAVENLY_BODY_SCALE * HB.getDiskRadius();
  1732. Right *= /*cos_lookAt_toDir */ horiz_enlargement * HEAVENLY_BODY_SCALE * HB.getDiskRadius();
  1733. Up *= vert_size;
  1735. LLVector3 v_corner[2];
  1736. LLVector3 stretch_corner[2];
  1738. LLVector3 top_hb = v_corner[0] = stretch_corner[0] = hb_pos - Right + Up;
  1739. v_corner[1] = stretch_corner[1] = hb_pos - Right - Up;
  1741. F32 dt_hor, dt;
  1742. dt_hor = clip_side_to_horizon(v_corner[1], v_corner[0], cos_horizon_angle);
  1744. LLVector2 TEX0t = TEX00;
  1745. LLVector2 TEX1t = TEX10;
  1746. LLVector3 lower_corner = v_corner[1];
  1748. if ((dt_hor > 0) && (dt_hor < 1))
  1749. {
  1750. TEX0t = LLVector2(0, dt_hor);
  1751. TEX1t = LLVector2(1, dt_hor);
  1752. lower_corner = (1 - dt_hor) * v_corner[1] + dt_hor * v_corner[0];
  1753. }
  1754. else
  1755. dt_hor = llmax(0.0f, llmin(1.0f, dt_hor));
  1757. top_hb.normalize();
  1758. const F32 cos_angle_of_view = fabs(top_hb.mV[VZ]);
  1759. const F32 extension = llmin (5.0f, 1.0f / cos_angle_of_view);
  1761. const S32 cols = 1;
  1762. const S32 raws = lltrunc(16 * extension);
  1763. S32 quads = cols * raws;
  1765. stretch_corner[0] = lower_corner + extension * (stretch_corner[0] - lower_corner);
  1766. stretch_corner[1] = lower_corner + extension * (stretch_corner[1] - lower_corner);
  1768. dt = dt_hor;
  1771. F32 cos_dir_from_top[2];
  1773. LLVector3 dir = stretch_corner[0];
  1774. dir.normalize();
  1775. cos_dir_from_top[0] = dir.mV[VZ];
  1777. dir = stretch_corner[1];
  1778. dir.normalize();
  1779. cos_dir_from_top[1] = dir.mV[VZ];
  1781. const F32 sin_dir_from_top = sqrt(1 - cos_dir_from_top[0] * cos_dir_from_top[0]);
  1782. const F32 sin_dir_from_top2 = sqrt(1 - cos_dir_from_top[1] * cos_dir_from_top[1]);
  1783. const F32 cos_diff_dir = cos_dir_from_top[0] * cos_dir_from_top[1]
  1784. + sin_dir_from_top * sin_dir_from_top2;
  1785. const F32 diff_angl_dir = acos(cos_diff_dir);
  1787. v_corner[0] = stretch_corner[0];
  1788. v_corner[1] = lower_corner;
  1791. LLVector2 TEX0tt = TEX01;
  1792. LLVector2 TEX1tt = TEX11;
  1794. LLVector3 v_refl_corner[4];
  1795. LLVector3 v_sprite_corner[4];
  1797. S32 vtx;
  1798. for (vtx = 0; vtx < 2; ++vtx)
  1799. {
  1800. LLVector3 light_proj = v_corner[vtx];
  1801. light_proj.normalize();
  1803. const F32 z = light_proj.mV[VZ];
  1804. const F32 sin_angle = sqrt(1 - z * z);
  1805. light_proj *= 1.f / sin_angle;
  1806. light_proj.mV[VZ] = 0;
  1807. const F32 to_refl_point = H * sin_angle / fabs(z);
  1809. v_refl_corner[vtx] = to_refl_point * light_proj;
  1810. }
  1813. for (vtx = 2; vtx < 4; ++vtx)
  1814. {
  1815. const LLVector3 to_dir_vec = (to_dir_proj * v_refl_corner[vtx-2]) * to_dir_proj;
  1816. v_refl_corner[vtx] = v_refl_corner[vtx-2] + 2 * (to_dir_vec - v_refl_corner[vtx-2]);
  1817. }
  1819. for (vtx = 0; vtx < 4; ++vtx)
  1820. v_refl_corner[vtx].mV[VZ] -= H;
  1822. S32 side = 0;
  1823. LLVector3 refl_corn_norm[2];
  1824. refl_corn_norm[0] = v_refl_corner[1];
  1825. refl_corn_norm[0].normalize();
  1826. refl_corn_norm[1] = v_refl_corner[3];
  1827. refl_corn_norm[1].normalize();
  1829. F32 cos_refl_look_at[2];
  1830. cos_refl_look_at[0] = refl_corn_norm[0] * look_at;
  1831. cos_refl_look_at[1] = refl_corn_norm[1] * look_at;
  1833. if (cos_refl_look_at[1] > cos_refl_look_at[0])
  1834. {
  1835. side = 2;
  1836. }
  1838. //const F32 far_clip = (LLViewerCamera::getInstance()->getFar() - 0.01) / far_clip_factor;
  1839. const F32 far_clip = 512;
  1840. const F32 far_clip2 = far_clip*far_clip;
  1842. F32 dt_clip;
  1843. F32 vtx_near2, vtx_far2;
  1845. if ((vtx_far2 = v_refl_corner[side].lengthSquared()) > far_clip2)
  1846. {
  1847. // whole thing is sprite: reflection is beyond far clip plane.
  1848. dt_clip = 1.1f;
  1849. quads = 1;
  1850. }
  1851. else if ((vtx_near2 = v_refl_corner[side+1].lengthSquared()) > far_clip2)
  1852. {
  1853. // part is reflection, the rest is sprite.
  1854. dt_clip = dtClip(v_refl_corner[side + 1], v_refl_corner[side], far_clip2);
  1855. const LLVector3 P = (1 - dt_clip) * v_refl_corner[side + 1] + dt_clip * v_refl_corner[side];
  1857. F32 dt_tex = dtReflection(P, cos_dir_from_top[0], sin_dir_from_top, diff_angl_dir);
  1859. dt = dt_tex;
  1860. TEX0tt = LLVector2(0, dt);
  1861. TEX1tt = LLVector2(1, dt);
  1862. quads++;
  1863. }
  1864. else
  1865. {
  1866. // whole thing is correct reflection.
  1867. dt_clip = -0.1f;
  1868. }
  1870. LLFace *face = mFace[FACE_REFLECTION]; 
  1872. if (face->mVertexBuffer.isNull() || quads*4 != face->getGeomCount())
  1873. {
  1874. face->setSize(quads * 4, quads * 6);
  1875. face->mVertexBuffer = new LLVertexBuffer(LLDrawPoolWater::VERTEX_DATA_MASK, GL_STREAM_DRAW_ARB);
  1876. face->mVertexBuffer->allocateBuffer(face->getGeomCount(), face->getIndicesCount(), TRUE);
  1877. face->setIndicesIndex(0);
  1878. face->setGeomIndex(0);
  1879. }
  1881. LLStrider<LLVector3> verticesp;
  1882. LLStrider<LLVector3> normalsp;
  1883. LLStrider<LLVector2> texCoordsp;
  1884. LLStrider<U16> indicesp;
  1885. S32 index_offset;
  1887. index_offset = face->getGeometry(verticesp,normalsp,texCoordsp, indicesp);
  1888. if (-1 == index_offset)
  1889. {
  1890. return;
  1891. }
  1893. LLColor3 hb_col3 = HB.getInterpColor();
  1894. hb_col3.clamp();
  1895. const LLColor4 hb_col = LLColor4(hb_col3);
  1897. const F32 min_attenuation = 0.4f;
  1898. const F32 max_attenuation = 0.7f;
  1899. const F32 attenuation = min_attenuation
  1900. + cos_angle_of_view * (max_attenuation - min_attenuation);
  1902. LLColor4 hb_refl_col = (1-attenuation) * hb_col + attenuation * mFogColor;
  1903. face->setFaceColor(hb_refl_col);
  1905. LLVector3 v_far[2];
  1906. v_far[0] = v_refl_corner[1];
  1907. v_far[1] = v_refl_corner[3];
  1909. if(dt_clip > 0)
  1910. {
  1911. if (dt_clip >= 1)
  1912. {
  1913. for (S32 vtx = 0; vtx < 4; ++vtx)
  1914. {
  1915. F32 ratio = far_clip / v_refl_corner[vtx].length();
  1916. *(verticesp++) = v_refl_corner[vtx] = ratio * v_refl_corner[vtx] + mCameraPosAgent;
  1917. }
  1918. const LLVector3 draw_pos = 0.25 *
  1919. (v_refl_corner[0] + v_refl_corner[1] + v_refl_corner[2] + v_refl_corner[3]);
  1920. face->mCenterAgent = draw_pos;
  1921. }
  1922. else
  1923. {
  1924. F32 ratio = far_clip / v_refl_corner[1].length();
  1925. v_sprite_corner[1] = v_refl_corner[1] * ratio;
  1927. ratio = far_clip / v_refl_corner[3].length();
  1928. v_sprite_corner[3] = v_refl_corner[3] * ratio;
  1930. v_refl_corner[1] = (1 - dt_clip) * v_refl_corner[1] + dt_clip * v_refl_corner[0];
  1931. v_refl_corner[3] = (1 - dt_clip) * v_refl_corner[3] + dt_clip * v_refl_corner[2];
  1932. v_sprite_corner[0] = v_refl_corner[1];
  1933. v_sprite_corner[2] = v_refl_corner[3];
  1935. for (S32 vtx = 0; vtx < 4; ++vtx)
  1936. {
  1937. *(verticesp++) = v_sprite_corner[vtx] + mCameraPosAgent;
  1938. }
  1940. const LLVector3 draw_pos = 0.25 *
  1941. (v_refl_corner[0] + v_sprite_corner[1] + v_refl_corner[2] + v_sprite_corner[3]);
  1942. face->mCenterAgent = draw_pos;
  1943. }
  1945. *(texCoordsp++) = TEX0tt;
  1946. *(texCoordsp++) = TEX0t;
  1947. *(texCoordsp++) = TEX1tt;
  1948. *(texCoordsp++) = TEX1t;
  1950. *indicesp++ = index_offset + 0;
  1951. *indicesp++ = index_offset + 2;
  1952. *indicesp++ = index_offset + 1;
  1954. *indicesp++ = index_offset + 1;
  1955. *indicesp++ = index_offset + 2;
  1956. *indicesp++ = index_offset + 3;
  1958. index_offset += 4;
  1959. }
  1961. if (dt_clip < 1)
  1962. {
  1963. if (dt_clip <= 0)
  1964. {
  1965. const LLVector3 draw_pos = 0.25 *
  1966. (v_refl_corner[0] + v_refl_corner[1] + v_refl_corner[2] + v_refl_corner[3]);
  1967. face->mCenterAgent = draw_pos;
  1968. }
  1970. const F32 raws_inv = 1.f/raws;
  1971. const F32 cols_inv = 1.f/cols;
  1972. LLVector3 left = v_refl_corner[0] - v_refl_corner[1];
  1973. LLVector3 right = v_refl_corner[2] - v_refl_corner[3];
  1974. left *= raws_inv;
  1975. right *= raws_inv;
  1977. F32 dt_raw = dt;
  1979. for (S32 raw = 0; raw < raws; ++raw)
  1980. {
  1981. F32 dt_v0 = raw * raws_inv;
  1982. F32 dt_v1 = (raw + 1) * raws_inv;
  1983. const LLVector3 BL = v_refl_corner[1] + (F32)raw * left;
  1984. const LLVector3 BR = v_refl_corner[3] + (F32)raw * right;
  1985. const LLVector3 EL = BL + left;
  1986. const LLVector3 ER = BR + right;
  1987. dt_v0 = dt_raw;
  1988. dt_raw = dt_v1 = dtReflection(EL, cos_dir_from_top[0], sin_dir_from_top, diff_angl_dir);
  1989. for (S32 col = 0; col < cols; ++col)
  1990. {
  1991. F32 dt_h0 = col * cols_inv;
  1992. *(verticesp++) = (1 - dt_h0) * EL + dt_h0 * ER + mCameraPosAgent;
  1993. *(verticesp++) = (1 - dt_h0) * BL + dt_h0 * BR + mCameraPosAgent;
  1994. F32 dt_h1 = (col + 1) * cols_inv;
  1995. *(verticesp++) = (1 - dt_h1) * EL + dt_h1 * ER + mCameraPosAgent;
  1996. *(verticesp++) = (1 - dt_h1) * BL + dt_h1 * BR + mCameraPosAgent;
  1998. *(texCoordsp++) = LLVector2(dt_h0, dt_v1);
  1999. *(texCoordsp++) = LLVector2(dt_h0, dt_v0);
  2000. *(texCoordsp++) = LLVector2(dt_h1, dt_v1);
  2001. *(texCoordsp++) = LLVector2(dt_h1, dt_v0);
  2003. *indicesp++ = index_offset + 0;
  2004. *indicesp++ = index_offset + 2;
  2005. *indicesp++ = index_offset + 1;
  2007. *indicesp++ = index_offset + 1;
  2008. *indicesp++ = index_offset + 2;
  2009. *indicesp++ = index_offset + 3;
  2011. index_offset += 4;
  2012. }
  2013. }
  2014. }
  2016. face->mVertexBuffer->setBuffer(0);
  2017. }
  2022. void LLVOSky::updateFog(const F32 distance)
  2023. {
  2024. if (!gPipeline.hasRenderDebugFeatureMask(LLPipeline::RENDER_DEBUG_FEATURE_FOG))
  2025. {
  2026. glFogf(GL_FOG_DENSITY, 0);
  2027. glFogfv(GL_FOG_COLOR, (F32 *) &LLColor4::white.mV);
  2028. glFogf(GL_FOG_END, 1000000.f);
  2029. return;
  2030. }
  2032. const BOOL hide_clip_plane = TRUE;
  2033. LLColor4 target_fog(0.f, 0.2f, 0.5f, 0.f);
  2035. const F32 water_height = gAgent.getRegion() ? gAgent.getRegion()->getWaterHeight() : 0.f;
  2036. // LLWorld::getInstance()->getWaterHeight();
  2037. F32 camera_height = gAgent.getCameraPositionAgent().mV[2];
  2039. F32 near_clip_height = LLViewerCamera::getInstance()->getAtAxis().mV[VZ] * LLViewerCamera::getInstance()->getNear();
  2040. camera_height += near_clip_height;
  2042. F32 fog_distance = 0.f;
  2043. LLColor3 res_color[3];
  2045. LLColor3 sky_fog_color = LLColor3::white;
  2046. LLColor3 render_fog_color = LLColor3::white;
  2048. LLVector3 tosun = getToSunLast();
  2049. const F32 tosun_z = tosun.mV[VZ];
  2050. tosun.mV[VZ] = 0.f;
  2051. tosun.normalize();
  2052. LLVector3 perp_tosun;
  2053. perp_tosun.mV[VX] = -tosun.mV[VY];
  2054. perp_tosun.mV[VY] = tosun.mV[VX];
  2055. LLVector3 tosun_45 = tosun + perp_tosun;
  2056. tosun_45.normalize();
  2058. F32 delta = 0.06f;
  2059. tosun.mV[VZ] = delta;
  2060. perp_tosun.mV[VZ] = delta;
  2061. tosun_45.mV[VZ] = delta;
  2062. tosun.normalize();
  2063. perp_tosun.normalize();
  2064. tosun_45.normalize();
  2066. // Sky colors, just slightly above the horizon in the direction of the sun, perpendicular to the sun, and at a 45 degree angle to the sun.
  2067. initAtmospherics();
  2068. res_color[0] = calcSkyColorInDir(tosun);
  2069. res_color[1] = calcSkyColorInDir(perp_tosun);
  2070. res_color[2] = calcSkyColorInDir(tosun_45);
  2072. sky_fog_color = color_norm(res_color[0] + res_color[1] + res_color[2]);
  2074. F32 full_off = -0.25f;
  2075. F32 full_on = 0.00f;
  2076. F32 on = (tosun_z - full_off) / (full_on - full_off);
  2077. on = llclamp(on, 0.01f, 1.f);
  2078. sky_fog_color *= 0.5f * on;
  2081. // We need to clamp these to non-zero, in order for the gamma correction to work. 0^y = ???
  2082. S32 i;
  2083. for (i = 0; i < 3; i++)
  2084. {
  2085. sky_fog_color.mV[i] = llmax(0.0001f, sky_fog_color.mV[i]);
  2086. }
  2088. color_gamma_correct(sky_fog_color);
  2090. render_fog_color = sky_fog_color;
  2092. F32 fog_density = 0.f;
  2093. fog_distance = mFogRatio * distance;
  2095. if (camera_height > water_height)
  2096. {
  2097. LLColor4 fog(render_fog_color);
  2098. glFogfv(GL_FOG_COLOR, fog.mV);
  2099. mGLFogCol = fog;
  2101. if (hide_clip_plane)
  2102. {
  2103. // For now, set the density to extend to the cull distance.
  2104. const F32 f_log = 2.14596602628934723963618357029f; // sqrt(fabs(log(0.01f)))
  2105. fog_density = f_log/fog_distance;
  2106. glFogi(GL_FOG_MODE, GL_EXP2);
  2107. }
  2108. else
  2109. {
  2110. const F32 f_log = 4.6051701859880913680359829093687f; // fabs(log(0.01f))
  2111. fog_density = (f_log)/fog_distance;
  2112. glFogi(GL_FOG_MODE, GL_EXP);
  2113. }
  2114. }
  2115. else
  2116. {
  2117. F32 depth = water_height - camera_height;
  2119. // get the water param manager variables
  2120. float water_fog_density = LLWaterParamManager::instance()->getFogDensity();
  2121. LLColor4 water_fog_color = LLDrawPoolWater::sWaterFogColor.mV;
  2123. // adjust the color based on depth.  We're doing linear approximations
  2124. float depth_scale = gSavedSettings.getF32("WaterGLFogDepthScale");
  2125. float depth_modifier = 1.0f - llmin(llmax(depth / depth_scale, 0.01f), 
  2126. gSavedSettings.getF32("WaterGLFogDepthFloor"));
  2128. LLColor4 fogCol = water_fog_color * depth_modifier;
  2129. fogCol.setAlpha(1);
  2131. // set the gl fog color
  2132. glFogfv(GL_FOG_COLOR, (F32 *) &fogCol.mV);
  2133. mGLFogCol = fogCol;
  2135. // set the density based on what the shaders use
  2136. fog_density = water_fog_density * gSavedSettings.getF32("WaterGLFogDensityScale");
  2137. glFogi(GL_FOG_MODE, GL_EXP2);
  2138. }
  2140. mFogColor = sky_fog_color;
  2141. mFogColor.setAlpha(1);
  2142. LLGLSFog gls_fog;
  2144. glFogf(GL_FOG_END, fog_distance*2.2f);
  2146. glFogf(GL_FOG_DENSITY, fog_density);
  2148. glHint(GL_FOG_HINT, GL_NICEST);
  2149. stop_glerror();
  2150. }
  2152. // static
  2153. void LLHaze::initClass()
  2154. {
  2155. sAirScaSeaLevel = LLHaze::calcAirScaSeaLevel();
  2156. }
  2160. // Functions used a lot.
  2163. F32 color_norm_pow(LLColor3& col, F32 e, BOOL postmultiply)
  2164. {
  2165. F32 mv = color_max(col);
  2166. if (0 == mv)
  2167. {
  2168. return 0;
  2169. }
  2171. col *= 1.f / mv;
  2172. color_pow(col, e);
  2173. if (postmultiply)
  2174. {
  2175. col *= mv;
  2176. }
  2177. return mv;
  2178. }
  2180. // Returns angle (RADIANs) between the horizontal projection of "v" and the x_axis.
  2181. // Range of output is 0.0f to 2pi //359.99999...f
  2182. // Returns 0.0f when "v" = +/- z_axis.
  2183. F32 azimuth(const LLVector3 &v)
  2184. {
  2185. F32 azimuth = 0.0f;
  2186. if (v.mV[VX] == 0.0f)
  2187. {
  2188. if (v.mV[VY] > 0.0f)
  2189. {
  2190. azimuth = F_PI * 0.5f;
  2191. }
  2192. else if (v.mV[VY] < 0.0f)
  2193. {
  2194. azimuth = F_PI * 1.5f;// 270.f;
  2195. }
  2196. }
  2197. else
  2198. {
  2199. azimuth = (F32) atan(v.mV[VY] / v.mV[VX]);
  2200. if (v.mV[VX] < 0.0f)
  2201. {
  2202. azimuth += F_PI;
  2203. }
  2204. else if (v.mV[VY] < 0.0f)
  2205. {
  2206. azimuth += F_PI * 2;
  2207. }
  2208. }
  2209. return azimuth;
  2210. }
  2212. void LLVOSky::initSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity)
  2213. {
  2214. LLVector3 sun_direction = (sun_dir.length() == 0) ? LLVector3::x_axis : sun_dir;
  2215. sun_direction.normalize();
  2216. mSun.setDirection(sun_direction);
  2217. mSun.renewDirection();
  2218. mSun.setAngularVelocity(sun_ang_velocity);
  2219. mMoon.setDirection(-mSun.getDirection());
  2220. mMoon.renewDirection();
  2221. mLastLightingDirection = mSun.getDirection();
  2223. calcAtmospherics();
  2225. if ( !mInitialized )
  2226. {
  2227. init();
  2228. LLSkyTex::stepCurrent();
  2229. }
  2230. }
  2232. void LLVOSky::setSunDirection(const LLVector3 &sun_dir, const LLVector3 &sun_ang_velocity)
  2233. {
  2234. LLVector3 sun_direction = (sun_dir.length() == 0) ? LLVector3::x_axis : sun_dir;
  2235. sun_direction.normalize();
  2237. // Push the sun "South" as it approaches directly overhead so that we can always see bump mapping
  2238. // on the upward facing faces of cubes.
  2239. LLVector3 newDir = sun_direction;
  2241. // Same as dot product with the up direction + clamp.
  2242. F32 sunDot = llmax(0.f, newDir.mV[2]);
  2243. sunDot *= sunDot;
  2245. // Create normalized vector that has the sunDir pushed south about an hour and change.
  2246. LLVector3 adjustedDir = (newDir + LLVector3(0.f, -0.70711f, 0.70711f)) * 0.5f;
  2248. // Blend between normal sun dir and adjusted sun dir based on how close we are
  2249. // to having the sun overhead.
  2250. mBumpSunDir = adjustedDir * sunDot + newDir * (1.0f - sunDot);
  2251. mBumpSunDir.normalize();
  2253. F32 dp = mLastLightingDirection * sun_direction;
  2254. mSun.setDirection(sun_direction);
  2255. mSun.setAngularVelocity(sun_ang_velocity);
  2256. mMoon.setDirection(-sun_direction);
  2257. calcAtmospherics();
  2258. if (dp < 0.995f) { //the sun jumped a great deal, update immediately
  2259. mForceUpdate = TRUE;
  2260. }
  2261. }