/indra/newview/lldrawpoolwater.cpp

https://bitbucket.org/lindenlab/viewer-beta/ · C++ · 725 lines · 526 code · 140 blank · 59 comment · 64 complexity · 50fd524b975c10ebeddec212b8ce8c6c MD5 · raw file

  1. /**
  2. * @file lldrawpoolwater.cpp
  3. * @brief LLDrawPoolWater class implementation
  4. *
  5. * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  6. * Second Life Viewer Source Code
  7. * Copyright (C) 2010, Linden Research, Inc.
  8. *
  9. * This library is free software; you can redistribute it and/or
  10. * modify it under the terms of the GNU Lesser General Public
  11. * License as published by the Free Software Foundation;
  12. * version 2.1 of the License only.
  13. *
  14. * This library is distributed in the hope that it will be useful,
  15. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17. * Lesser General Public License for more details.
  18. *
  19. * You should have received a copy of the GNU Lesser General Public
  20. * License along with this library; if not, write to the Free Software
  21. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22. *
  23. * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
  24. * $/LicenseInfo$
  25. */
  26. #include "llviewerprecompiledheaders.h"
  27. #include "llfeaturemanager.h"
  28. #include "lldrawpoolwater.h"
  29. #include "llviewercontrol.h"
  30. #include "lldir.h"
  31. #include "llerror.h"
  32. #include "m3math.h"
  33. #include "llrender.h"
  34. #include "llagent.h" // for gAgent for getRegion for getWaterHeight
  35. #include "llcubemap.h"
  36. #include "lldrawable.h"
  37. #include "llface.h"
  38. #include "llsky.h"
  39. #include "llviewertexturelist.h"
  40. #include "llviewerregion.h"
  41. #include "llvosky.h"
  42. #include "llvowater.h"
  43. #include "llworld.h"
  44. #include "pipeline.h"
  45. #include "llviewershadermgr.h"
  46. #include "llwaterparammanager.h"
  47. const LLUUID TRANSPARENT_WATER_TEXTURE("2bfd3884-7e27-69b9-ba3a-3e673f680004");
  48. const LLUUID OPAQUE_WATER_TEXTURE("43c32285-d658-1793-c123-bf86315de055");
  49. static float sTime;
  50. BOOL deferred_render = FALSE;
  51. BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;
  52. BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;
  53. BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;
  54. LLColor4 LLDrawPoolWater::sWaterFogColor = LLColor4(0.2f, 0.5f, 0.5f, 0.f);
  55. F32 LLDrawPoolWater::sWaterFogEnd = 0.f;
  56. LLVector3 LLDrawPoolWater::sLightDir;
  57. LLDrawPoolWater::LLDrawPoolWater() :
  58. LLFacePool(POOL_WATER)
  59. {
  60. mHBTex[0] = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);
  61. gGL.getTexUnit(0)->bind(mHBTex[0]) ;
  62. mHBTex[0]->setAddressMode(LLTexUnit::TAM_CLAMP);
  63. mHBTex[1] = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);
  64. gGL.getTexUnit(0)->bind(mHBTex[1]);
  65. mHBTex[1]->setAddressMode(LLTexUnit::TAM_CLAMP);
  66. mWaterImagep = LLViewerTextureManager::getFetchedTexture(TRANSPARENT_WATER_TEXTURE);
  67. llassert(mWaterImagep);
  68. mWaterImagep->setNoDelete();
  69. mOpaqueWaterImagep = LLViewerTextureManager::getFetchedTexture(OPAQUE_WATER_TEXTURE);
  70. llassert(mOpaqueWaterImagep);
  71. mWaterNormp = LLViewerTextureManager::getFetchedTexture(DEFAULT_WATER_NORMAL);
  72. mWaterNormp->setNoDelete();
  73. restoreGL();
  74. }
  75. LLDrawPoolWater::~LLDrawPoolWater()
  76. {
  77. }
  78. //static
  79. void LLDrawPoolWater::restoreGL()
  80. {
  81. }
  82. LLDrawPool *LLDrawPoolWater::instancePool()
  83. {
  84. llerrs << "Should never be calling instancePool on a water pool!" << llendl;
  85. return NULL;
  86. }
  87. void LLDrawPoolWater::prerender()
  88. {
  89. mVertexShaderLevel = (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps) ?
  90. LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;
  91. // got rid of modulation by light color since it got a little too
  92. // green at sunset and sl-57047 (underwater turns black at 8:00)
  93. sWaterFogColor = LLWaterParamManager::instance().getFogColor();
  94. sWaterFogColor.mV[3] = 0;
  95. }
  96. S32 LLDrawPoolWater::getNumPasses()
  97. {
  98. if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)
  99. {
  100. return 1;
  101. }
  102. return 0;
  103. }
  104. void LLDrawPoolWater::beginPostDeferredPass(S32 pass)
  105. {
  106. beginRenderPass(pass);
  107. deferred_render = TRUE;
  108. }
  109. void LLDrawPoolWater::endPostDeferredPass(S32 pass)
  110. {
  111. endRenderPass(pass);
  112. deferred_render = FALSE;
  113. }
  114. //===============================
  115. //DEFERRED IMPLEMENTATION
  116. //===============================
  117. void LLDrawPoolWater::renderDeferred(S32 pass)
  118. {
  119. LLFastTimer t(FTM_RENDER_WATER);
  120. deferred_render = TRUE;
  121. shade();
  122. deferred_render = FALSE;
  123. }
  124. //=========================================
  125. void LLDrawPoolWater::render(S32 pass)
  126. {
  127. LLFastTimer ftm(FTM_RENDER_WATER);
  128. if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)
  129. {
  130. return;
  131. }
  132. //do a quick 'n dirty depth sort
  133. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  134. iter != mDrawFace.end(); iter++)
  135. {
  136. LLFace* facep = *iter;
  137. facep->mDistance = -facep->mCenterLocal.mV[2];
  138. }
  139. std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());
  140. // See if we are rendering water as opaque or not
  141. if (!gSavedSettings.getBOOL("RenderTransparentWater"))
  142. {
  143. // render water for low end hardware
  144. renderOpaqueLegacyWater();
  145. return;
  146. }
  147. LLGLEnable blend(GL_BLEND);
  148. if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)
  149. {
  150. shade();
  151. return;
  152. }
  153. LLVOSky *voskyp = gSky.mVOSkyp;
  154. stop_glerror();
  155. if (!gGLManager.mHasMultitexture)
  156. {
  157. // Ack! No multitexture! Bail!
  158. return;
  159. }
  160. LLFace* refl_face = voskyp->getReflFace();
  161. gPipeline.disableLights();
  162. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  163. LLGLDisable cullFace(GL_CULL_FACE);
  164. // Set up second pass first
  165. mWaterImagep->addTextureStats(1024.f*1024.f);
  166. gGL.getTexUnit(1)->activate();
  167. gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
  168. gGL.getTexUnit(1)->bind(mWaterImagep) ;
  169. LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
  170. F32 up_dot = camera_up * LLVector3::z_axis;
  171. LLColor4 water_color;
  172. if (LLViewerCamera::getInstance()->cameraUnderWater())
  173. {
  174. water_color.setVec(1.f, 1.f, 1.f, 0.4f);
  175. }
  176. else
  177. {
  178. water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
  179. }
  180. gGL.diffuseColor4fv(water_color.mV);
  181. // Automatically generate texture coords for detail map
  182. glEnable(GL_TEXTURE_GEN_S); //texture unit 1
  183. glEnable(GL_TEXTURE_GEN_T); //texture unit 1
  184. glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  185. glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  186. // Slowly move over time.
  187. F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);
  188. F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};
  189. F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};
  190. glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
  191. glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
  192. gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);
  193. gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_ALPHA);
  194. gGL.getTexUnit(0)->activate();
  195. glClearStencil(1);
  196. glClear(GL_STENCIL_BUFFER_BIT);
  197. LLGLEnable gls_stencil(GL_STENCIL_TEST);
  198. glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);
  199. glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
  200. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  201. iter != mDrawFace.end(); iter++)
  202. {
  203. LLFace *face = *iter;
  204. if (voskyp->isReflFace(face))
  205. {
  206. continue;
  207. }
  208. gGL.getTexUnit(0)->bind(face->getTexture());
  209. face->renderIndexed();
  210. }
  211. // Now, disable texture coord generation on texture state 1
  212. gGL.getTexUnit(1)->activate();
  213. gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
  214. gGL.getTexUnit(1)->disable();
  215. glDisable(GL_TEXTURE_GEN_S); //texture unit 1
  216. glDisable(GL_TEXTURE_GEN_T); //texture unit 1
  217. // Disable texture coordinate and color arrays
  218. gGL.getTexUnit(0)->activate();
  219. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  220. stop_glerror();
  221. if (gSky.mVOSkyp->getCubeMap())
  222. {
  223. gSky.mVOSkyp->getCubeMap()->enable(0);
  224. gSky.mVOSkyp->getCubeMap()->bind();
  225. gGL.matrixMode(LLRender::MM_TEXTURE);
  226. gGL.loadIdentity();
  227. LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
  228. LLMatrix4 camera_rot(camera_mat.getMat3());
  229. camera_rot.invert();
  230. gGL.loadMatrix((F32 *)camera_rot.mMatrix);
  231. gGL.matrixMode(LLRender::MM_MODELVIEW);
  232. LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f, 0.5f*up_dot);
  233. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  234. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  235. iter != mDrawFace.end(); iter++)
  236. {
  237. LLFace *face = *iter;
  238. if (voskyp->isReflFace(face))
  239. {
  240. //refl_face = face;
  241. continue;
  242. }
  243. if (face->getGeomCount() > 0)
  244. {
  245. face->renderIndexed();
  246. }
  247. }
  248. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  249. gSky.mVOSkyp->getCubeMap()->disable();
  250. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  251. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  252. gGL.matrixMode(LLRender::MM_TEXTURE);
  253. gGL.loadIdentity();
  254. gGL.matrixMode(LLRender::MM_MODELVIEW);
  255. }
  256. glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  257. if (refl_face)
  258. {
  259. glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
  260. renderReflection(refl_face);
  261. }
  262. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  263. }
  264. // for low end hardware
  265. void LLDrawPoolWater::renderOpaqueLegacyWater()
  266. {
  267. LLVOSky *voskyp = gSky.mVOSkyp;
  268. LLGLSLShader* shader = NULL;
  269. if (LLGLSLShader::sNoFixedFunction)
  270. {
  271. if (LLPipeline::sUnderWaterRender)
  272. {
  273. shader = &gObjectSimpleNonIndexedTexGenWaterProgram;
  274. }
  275. else
  276. {
  277. shader = &gObjectSimpleNonIndexedTexGenProgram;
  278. }
  279. shader->bind();
  280. }
  281. stop_glerror();
  282. // Depth sorting and write to depth buffer
  283. // since this is opaque, we should see nothing
  284. // behind the water. No blending because
  285. // of no transparency. And no face culling so
  286. // that the underside of the water is also opaque.
  287. LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
  288. LLGLDisable no_cull(GL_CULL_FACE);
  289. LLGLDisable no_blend(GL_BLEND);
  290. gPipeline.disableLights();
  291. mOpaqueWaterImagep->addTextureStats(1024.f*1024.f);
  292. // Activate the texture binding and bind one
  293. // texture since all images will have the same texture
  294. gGL.getTexUnit(0)->activate();
  295. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  296. gGL.getTexUnit(0)->bind(mOpaqueWaterImagep);
  297. // Automatically generate texture coords for water texture
  298. if (!shader)
  299. {
  300. glEnable(GL_TEXTURE_GEN_S); //texture unit 0
  301. glEnable(GL_TEXTURE_GEN_T); //texture unit 0
  302. glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  303. glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  304. }
  305. // Use the fact that we know all water faces are the same size
  306. // to save some computation
  307. // Slowly move texture coordinates over time so the watter appears
  308. // to be moving.
  309. F32 movement_period_secs = 50.f;
  310. F32 offset = fmod(gFrameTimeSeconds, movement_period_secs);
  311. if (movement_period_secs != 0)
  312. {
  313. offset /= movement_period_secs;
  314. }
  315. else
  316. {
  317. offset = 0;
  318. }
  319. F32 tp0[4] = { 16.f / 256.f, 0.0f, 0.0f, offset };
  320. F32 tp1[4] = { 0.0f, 16.f / 256.f, 0.0f, offset };
  321. if (!shader)
  322. {
  323. glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
  324. glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
  325. }
  326. else
  327. {
  328. shader->uniform4fv("object_plane_s", 1, tp0);
  329. shader->uniform4fv("object_plane_t", 1, tp1);
  330. }
  331. gGL.diffuseColor3f(1.f, 1.f, 1.f);
  332. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  333. iter != mDrawFace.end(); iter++)
  334. {
  335. LLFace *face = *iter;
  336. if (voskyp->isReflFace(face))
  337. {
  338. continue;
  339. }
  340. face->renderIndexed();
  341. }
  342. stop_glerror();
  343. if (!shader)
  344. {
  345. // Reset the settings back to expected values
  346. glDisable(GL_TEXTURE_GEN_S); //texture unit 0
  347. glDisable(GL_TEXTURE_GEN_T); //texture unit 0
  348. }
  349. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  350. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  351. }
  352. void LLDrawPoolWater::renderReflection(LLFace* face)
  353. {
  354. LLVOSky *voskyp = gSky.mVOSkyp;
  355. if (!voskyp)
  356. {
  357. return;
  358. }
  359. if (!face->getGeomCount())
  360. {
  361. return;
  362. }
  363. S8 dr = voskyp->getDrawRefl();
  364. if (dr < 0)
  365. {
  366. return;
  367. }
  368. LLGLSNoFog noFog;
  369. gGL.getTexUnit(0)->bind(mHBTex[dr]);
  370. LLOverrideFaceColor override(this, face->getFaceColor().mV);
  371. face->renderIndexed();
  372. }
  373. void LLDrawPoolWater::shade()
  374. {
  375. if (!deferred_render)
  376. {
  377. gGL.setColorMask(true, true);
  378. }
  379. LLVOSky *voskyp = gSky.mVOSkyp;
  380. if(voskyp == NULL)
  381. {
  382. return;
  383. }
  384. LLGLDisable blend(GL_BLEND);
  385. LLColor3 light_diffuse(0,0,0);
  386. F32 light_exp = 0.0f;
  387. LLVector3 light_dir;
  388. LLColor3 light_color;
  389. if (gSky.getSunDirection().mV[2] > LLSky::NIGHTTIME_ELEVATION_COS)
  390. {
  391. light_dir = gSky.getSunDirection();
  392. light_dir.normVec();
  393. light_color = gSky.getSunDiffuseColor();
  394. if(gSky.mVOSkyp) {
  395. light_diffuse = gSky.mVOSkyp->getSun().getColorCached();
  396. light_diffuse.normVec();
  397. }
  398. light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0);
  399. light_diffuse *= light_exp + 0.25f;
  400. }
  401. else
  402. {
  403. light_dir = gSky.getMoonDirection();
  404. light_dir.normVec();
  405. light_color = gSky.getMoonDiffuseColor();
  406. light_diffuse = gSky.mVOSkyp->getMoon().getColorCached();
  407. light_diffuse.normVec();
  408. light_diffuse *= 0.5f;
  409. light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0);
  410. }
  411. light_exp *= light_exp;
  412. light_exp *= light_exp;
  413. light_exp *= light_exp;
  414. light_exp *= light_exp;
  415. light_exp *= 256.f;
  416. light_exp = light_exp > 32.f ? light_exp : 32.f;
  417. LLGLSLShader* shader;
  418. F32 eyedepth = LLViewerCamera::getInstance()->getOrigin().mV[2] - gAgent.getRegion()->getWaterHeight();
  419. if (deferred_render)
  420. {
  421. shader = &gDeferredWaterProgram;
  422. }
  423. else if (eyedepth < 0.f && LLPipeline::sWaterReflections)
  424. {
  425. shader = &gUnderWaterProgram;
  426. }
  427. else
  428. {
  429. shader = &gWaterProgram;
  430. }
  431. if (deferred_render)
  432. {
  433. gPipeline.bindDeferredShader(*shader);
  434. }
  435. else
  436. {
  437. shader->bind();
  438. }
  439. sTime = (F32)LLFrameTimer::getElapsedSeconds()*0.5f;
  440. S32 reftex = shader->enableTexture(LLViewerShaderMgr::WATER_REFTEX);
  441. if (reftex > -1)
  442. {
  443. gGL.getTexUnit(reftex)->activate();
  444. gGL.getTexUnit(reftex)->bind(&gPipeline.mWaterRef);
  445. gGL.getTexUnit(0)->activate();
  446. }
  447. //bind normal map
  448. S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
  449. LLWaterParamManager * param_mgr = &LLWaterParamManager::instance();
  450. // change mWaterNormp if needed
  451. if (mWaterNormp->getID() != param_mgr->getNormalMapID())
  452. {
  453. mWaterNormp = LLViewerTextureManager::getFetchedTexture(param_mgr->getNormalMapID());
  454. }
  455. mWaterNormp->addTextureStats(1024.f*1024.f);
  456. gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;
  457. if (gSavedSettings.getBOOL("RenderWaterMipNormal"))
  458. {
  459. mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
  460. }
  461. else
  462. {
  463. mWaterNormp->setFilteringOption(LLTexUnit::TFO_POINT);
  464. }
  465. S32 screentex = shader->enableTexture(LLViewerShaderMgr::WATER_SCREENTEX);
  466. if (screentex > -1)
  467. {
  468. shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
  469. shader->uniform1f(LLViewerShaderMgr::WATER_FOGDENSITY,
  470. param_mgr->getFogDensity());
  471. gPipeline.mWaterDis.bindTexture(0, screentex);
  472. }
  473. stop_glerror();
  474. gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis);
  475. if (mVertexShaderLevel == 1)
  476. {
  477. sWaterFogColor.mV[3] = param_mgr->mDensitySliderValue;
  478. shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
  479. }
  480. F32 screenRes[] =
  481. {
  482. 1.f/gGLViewport[2],
  483. 1.f/gGLViewport[3]
  484. };
  485. shader->uniform2fv("screenRes", 1, screenRes);
  486. stop_glerror();
  487. S32 diffTex = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  488. stop_glerror();
  489. light_dir.normVec();
  490. sLightDir = light_dir;
  491. light_diffuse *= 6.f;
  492. //shader->uniformMatrix4fv("inverse_ref", 1, GL_FALSE, (GLfloat*) gGLObliqueProjectionInverse.mMatrix);
  493. shader->uniform1f(LLViewerShaderMgr::WATER_WATERHEIGHT, eyedepth);
  494. shader->uniform1f(LLViewerShaderMgr::WATER_TIME, sTime);
  495. shader->uniform3fv(LLViewerShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
  496. shader->uniform3fv(LLViewerShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
  497. shader->uniform1f(LLViewerShaderMgr::WATER_SPECULAR_EXP, light_exp);
  498. shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR1, 1, param_mgr->getWave1Dir().mV);
  499. shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR2, 1, param_mgr->getWave2Dir().mV);
  500. shader->uniform3fv(LLViewerShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);
  501. shader->uniform3fv("normScale", 1, param_mgr->getNormalScale().mV);
  502. shader->uniform1f("fresnelScale", param_mgr->getFresnelScale());
  503. shader->uniform1f("fresnelOffset", param_mgr->getFresnelOffset());
  504. shader->uniform1f("blurMultiplier", param_mgr->getBlurMultiplier());
  505. F32 sunAngle = llmax(0.f, light_dir.mV[2]);
  506. F32 scaledAngle = 1.f - sunAngle;
  507. shader->uniform1f("sunAngle", sunAngle);
  508. shader->uniform1f("scaledAngle", scaledAngle);
  509. shader->uniform1f("sunAngle2", 0.1f + 0.2f*sunAngle);
  510. LLColor4 water_color;
  511. LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
  512. F32 up_dot = camera_up * LLVector3::z_axis;
  513. if (LLViewerCamera::getInstance()->cameraUnderWater())
  514. {
  515. water_color.setVec(1.f, 1.f, 1.f, 0.4f);
  516. shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleBelow());
  517. }
  518. else
  519. {
  520. water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
  521. shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleAbove());
  522. }
  523. if (water_color.mV[3] > 0.9f)
  524. {
  525. water_color.mV[3] = 0.9f;
  526. }
  527. {
  528. LLGLEnable depth_clamp(gGLManager.mHasDepthClamp ? GL_DEPTH_CLAMP : 0);
  529. LLGLDisable cullface(GL_CULL_FACE);
  530. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  531. iter != mDrawFace.end(); iter++)
  532. {
  533. LLFace *face = *iter;
  534. if (voskyp->isReflFace(face))
  535. {
  536. continue;
  537. }
  538. LLVOWater* water = (LLVOWater*) face->getViewerObject();
  539. gGL.getTexUnit(diffTex)->bind(face->getTexture());
  540. sNeedsReflectionUpdate = TRUE;
  541. if (water->getUseTexture() || !water->getIsEdgePatch())
  542. {
  543. sNeedsDistortionUpdate = TRUE;
  544. face->renderIndexed();
  545. }
  546. else if (gGLManager.mHasDepthClamp || deferred_render)
  547. {
  548. face->renderIndexed();
  549. }
  550. else
  551. {
  552. LLGLSquashToFarClip far_clip(glh_get_current_projection());
  553. face->renderIndexed();
  554. }
  555. }
  556. }
  557. shader->disableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  558. shader->disableTexture(LLViewerShaderMgr::WATER_SCREENTEX);
  559. shader->disableTexture(LLViewerShaderMgr::BUMP_MAP);
  560. shader->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  561. shader->disableTexture(LLViewerShaderMgr::WATER_REFTEX);
  562. shader->disableTexture(LLViewerShaderMgr::WATER_SCREENDEPTH);
  563. if (deferred_render)
  564. {
  565. gPipeline.unbindDeferredShader(*shader);
  566. }
  567. else
  568. {
  569. shader->unbind();
  570. }
  571. gGL.getTexUnit(0)->activate();
  572. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  573. if (!deferred_render)
  574. {
  575. gGL.setColorMask(true, false);
  576. }
  577. }
  578. LLViewerTexture *LLDrawPoolWater::getDebugTexture()
  579. {
  580. return LLViewerFetchedTexture::sSmokeImagep;
  581. }
  582. LLColor3 LLDrawPoolWater::getDebugColor() const
  583. {
  584. return LLColor3(0.f, 1.f, 1.f);
  585. }