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

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

游戏引擎

开发平台：

C++ Builder

lldrawpoolwater.cpp：源码内容
  1. /** 
  2.  * @file lldrawpoolwater.cpp
  3.  * @brief LLDrawPoolWater class implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2002-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"
  34. #include "llfeaturemanager.h"
  35. #include "lldrawpoolwater.h"
  37. #include "llviewercontrol.h"
  38. #include "lldir.h"
  39. #include "llerror.h"
  40. #include "m3math.h"
  41. #include "llrender.h"
  43. #include "llagent.h" // for gAgent for getRegion for getWaterHeight
  44. #include "llcubemap.h"
  45. #include "lldrawable.h"
  46. #include "llface.h"
  47. #include "llsky.h"
  48. #include "llviewertexturelist.h"
  49. #include "llviewerregion.h"
  50. #include "llvosky.h"
  51. #include "llvowater.h"
  52. #include "llworld.h"
  53. #include "pipeline.h"
  54. #include "llviewershadermgr.h"
  55. #include "llwaterparammanager.h"
  57. const LLUUID WATER_TEST("2bfd3884-7e27-69b9-ba3a-3e673f680004");
  59. static float sTime;
  61. BOOL deferred_render = FALSE;
  63. BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;
  64. BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;
  65. BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;
  66. LLColor4 LLDrawPoolWater::sWaterFogColor = LLColor4(0.2f, 0.5f, 0.5f, 0.f);
  67. LLVector3 LLDrawPoolWater::sLightDir;
  69. LLDrawPoolWater::LLDrawPoolWater() :
  70. LLFacePool(POOL_WATER)
  71. {
  72. mHBTex[0] = LLViewerTextureManager::getFetchedTexture(gSunTextureID, TRUE, LLViewerTexture::BOOST_UI);
  73. gGL.getTexUnit(0)->bind(mHBTex[0]) ;
  74. mHBTex[0]->setAddressMode(LLTexUnit::TAM_CLAMP);
  76. mHBTex[1] = LLViewerTextureManager::getFetchedTexture(gMoonTextureID, TRUE, LLViewerTexture::BOOST_UI);
  77. gGL.getTexUnit(0)->bind(mHBTex[1]);
  78. mHBTex[1]->setAddressMode(LLTexUnit::TAM_CLAMP);
  80. mWaterImagep = LLViewerTextureManager::getFetchedTexture(WATER_TEST);
  81. mWaterImagep->setNoDelete() ;
  82. mWaterNormp = LLViewerTextureManager::getFetchedTexture(DEFAULT_WATER_NORMAL);
  83. mWaterNormp->setNoDelete() ;
  85. restoreGL();
  86. }
  88. LLDrawPoolWater::~LLDrawPoolWater()
  89. {
  90. }
  92. //static
  93. void LLDrawPoolWater::restoreGL()
  94. {
  96. }
  98. LLDrawPool *LLDrawPoolWater::instancePool()
  99. {
  100. llerrs << "Should never be calling instancePool on a water pool!" << llendl;
  101. return NULL;
  102. }
  105. void LLDrawPoolWater::prerender()
  106. {
  107. mVertexShaderLevel = (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps) ?
  108. LLViewerShaderMgr::instance()->getVertexShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;
  110. // got rid of modulation by light color since it got a little too
  111. // green at sunset and sl-57047 (underwater turns black at 8:00)
  112. sWaterFogColor = LLWaterParamManager::instance()->getFogColor();
  113. sWaterFogColor.mV[3] = 0;
  115. }
  117. S32 LLDrawPoolWater::getNumPasses()
  118. {
  119. if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)
  120. {
  121. return 1;
  122. }
  124. return 0;
  125. }
  127. void LLDrawPoolWater::beginPostDeferredPass(S32 pass)
  128. {
  129. beginRenderPass(pass);
  130. deferred_render = TRUE;
  131. }
  133. void LLDrawPoolWater::endPostDeferredPass(S32 pass)
  134. {
  135. endRenderPass(pass);
  136. deferred_render = FALSE;
  137. }
  139. //===============================
  140. //DEFERRED IMPLEMENTATION
  141. //===============================
  142. void LLDrawPoolWater::renderDeferred(S32 pass)
  143. {
  144. LLFastTimer t(FTM_RENDER_WATER);
  145. deferred_render = TRUE;
  146. shade();
  147. deferred_render = FALSE;
  148. }
  150. //=========================================
  152. void LLDrawPoolWater::render(S32 pass)
  153. {
  154. LLFastTimer ftm(FTM_RENDER_WATER);
  155. if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)
  156. {
  157. return;
  158. }
  160. //do a quick 'n dirty depth sort
  161. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  162.  iter != mDrawFace.end(); iter++)
  163. {
  164. LLFace* facep = *iter;
  165. facep->mDistance = -facep->mCenterLocal.mV[2];
  166. }
  168. std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());
  170. LLGLEnable blend(GL_BLEND);
  172. if ((mVertexShaderLevel > 0) && !sSkipScreenCopy)
  173. {
  174. shade();
  175. return;
  176. }
  178. LLVOSky *voskyp = gSky.mVOSkyp;
  180. stop_glerror();
  182. if (!gGLManager.mHasMultitexture)
  183. {
  184. // Ack!  No multitexture!  Bail!
  185. return;
  186. }
  188. LLFace* refl_face = voskyp->getReflFace();
  190. gPipeline.disableLights();
  192. LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
  194. LLGLDisable cullFace(GL_CULL_FACE);
  196. // Set up second pass first
  197. mWaterImagep->addTextureStats(1024.f*1024.f);
  198. gGL.getTexUnit(1)->activate();
  199. gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
  200. gGL.getTexUnit(1)->bind(mWaterImagep) ;
  202. LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
  203. F32 up_dot = camera_up * LLVector3::z_axis;
  205. LLColor4 water_color;
  206. if (LLViewerCamera::getInstance()->cameraUnderWater())
  207. {
  208. water_color.setVec(1.f, 1.f, 1.f, 0.4f);
  209. }
  210. else
  211. {
  212. water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
  213. }
  215. glColor4fv(water_color.mV);
  217. // Automatically generate texture coords for detail map
  218. glEnable(GL_TEXTURE_GEN_S); //texture unit 1
  219. glEnable(GL_TEXTURE_GEN_T); //texture unit 1
  220. glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  221. glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
  223. // Slowly move over time.
  224. F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);
  225. F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};
  226. F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};
  227. glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
  228. glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
  230. gGL.getTexUnit(1)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_PREV_COLOR);
  231. gGL.getTexUnit(1)->setTextureAlphaBlend(LLTexUnit::TBO_REPLACE, LLTexUnit::TBS_PREV_ALPHA);
  233. gGL.getTexUnit(0)->activate();
  235. glClearStencil(1);
  236. glClear(GL_STENCIL_BUFFER_BIT);
  237. LLGLEnable gls_stencil(GL_STENCIL_TEST);
  238. glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);
  239. glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
  241. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  242.  iter != mDrawFace.end(); iter++)
  243. {
  244. LLFace *face = *iter;
  245. if (voskyp->isReflFace(face))
  246. {
  247. continue;
  248. }
  249. gGL.getTexUnit(0)->bind(face->getTexture());
  250. face->renderIndexed();
  251. }
  253. // Now, disable texture coord generation on texture state 1
  254. gGL.getTexUnit(1)->activate();
  255. gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
  256. gGL.getTexUnit(1)->disable();
  257. glDisable(GL_TEXTURE_GEN_S); //texture unit 1
  258. glDisable(GL_TEXTURE_GEN_T); //texture unit 1
  260. // Disable texture coordinate and color arrays
  261. gGL.getTexUnit(0)->activate();
  262. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  264. stop_glerror();
  266. if (gSky.mVOSkyp->getCubeMap())
  267. {
  268. gSky.mVOSkyp->getCubeMap()->enable(0);
  269. gSky.mVOSkyp->getCubeMap()->bind();
  271. glMatrixMode(GL_TEXTURE);
  272. glLoadIdentity();
  273. LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
  274. LLMatrix4 camera_rot(camera_mat.getMat3());
  275. camera_rot.invert();
  277. glLoadMatrixf((F32 *)camera_rot.mMatrix);
  279. glMatrixMode(GL_MODELVIEW);
  280. LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f,  0.5f*up_dot);
  282. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  284. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  285.  iter != mDrawFace.end(); iter++)
  286. {
  287. LLFace *face = *iter;
  288. if (voskyp->isReflFace(face))
  289. {
  290. //refl_face = face;
  291. continue;
  292. }
  294. if (face->getGeomCount() > 0)
  295. {
  296. face->renderIndexed();
  297. }
  298. }
  300. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  302. gSky.mVOSkyp->getCubeMap()->disable();
  304. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  305. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  306. glMatrixMode(GL_TEXTURE);
  307. glLoadIdentity();
  308. glMatrixMode(GL_MODELVIEW);
  310. }
  312. glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
  314.     if (refl_face)
  315. {
  316. glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
  317. renderReflection(refl_face);
  318. }
  320. gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
  321. }
  323. void LLDrawPoolWater::renderReflection(LLFace* face)
  324. {
  325. LLVOSky *voskyp = gSky.mVOSkyp;
  327. if (!voskyp)
  328. {
  329. return;
  330. }
  332. if (!face->getGeomCount())
  333. {
  334. return;
  335. }
  337. S8 dr = voskyp->getDrawRefl();
  338. if (dr < 0)
  339. {
  340. return;
  341. }
  343. LLGLSNoFog noFog;
  345. gGL.getTexUnit(0)->bind(mHBTex[dr]);
  347. LLOverrideFaceColor override(this, face->getFaceColor().mV);
  348. face->renderIndexed();
  349. }
  351. void LLDrawPoolWater::shade()
  352. {
  353. if (!deferred_render)
  354. {
  355. gGL.setColorMask(true, true);
  356. }
  358. LLVOSky *voskyp = gSky.mVOSkyp;
  360. if(voskyp == NULL) 
  361. {
  362. return;
  363. }
  365. LLGLDisable blend(GL_BLEND);
  367. LLColor3 light_diffuse(0,0,0);
  368. F32 light_exp = 0.0f;
  369. LLVector3 light_dir;
  370. LLColor3 light_color;
  372. if (gSky.getSunDirection().mV[2] > LLSky::NIGHTTIME_ELEVATION_COS)   
  373.     {   
  374.         light_dir  = gSky.getSunDirection();   
  375.         light_dir.normVec(); 
  376. light_color = gSky.getSunDiffuseColor();
  377. if(gSky.mVOSkyp) {
  378.         light_diffuse = gSky.mVOSkyp->getSun().getColorCached();   
  379. light_diffuse.normVec();   
  380. }
  381.         light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0);   
  382.         light_diffuse *= light_exp + 0.25f;   
  383.     }   
  384.     else    
  385.     {   
  386.         light_dir       = gSky.getMoonDirection();   
  387.         light_dir.normVec();   
  388. light_color = gSky.getMoonDiffuseColor();
  389.         light_diffuse   = gSky.mVOSkyp->getMoon().getColorCached();   
  390.         light_diffuse.normVec();   
  391.         light_diffuse *= 0.5f;   
  392.         light_exp = light_dir * LLVector3(light_dir.mV[0], light_dir.mV[1], 0);   
  393.     }
  395. light_exp *= light_exp;
  396. light_exp *= light_exp;
  397. light_exp *= light_exp;
  398. light_exp *= light_exp;
  399. light_exp *= 256.f;
  400. light_exp = light_exp > 32.f ? light_exp : 32.f;
  402. LLGLSLShader* shader;
  404. F32 eyedepth = LLViewerCamera::getInstance()->getOrigin().mV[2] - gAgent.getRegion()->getWaterHeight();
  406. if (deferred_render)
  407. {
  408. shader = &gDeferredWaterProgram;
  409. }
  410. else if (eyedepth < 0.f && LLPipeline::sWaterReflections)
  411. {
  412. shader = &gUnderWaterProgram;
  413. }
  414. else
  415. {
  416. shader = &gWaterProgram;
  417. }
  419. if (deferred_render)
  420. {
  421. gPipeline.bindDeferredShader(*shader);
  422. }
  423. else
  424. {
  425. shader->bind();
  426. }
  428. sTime = (F32)LLFrameTimer::getElapsedSeconds()*0.5f;
  430. S32 reftex = shader->enableTexture(LLViewerShaderMgr::WATER_REFTEX);
  432. if (reftex > -1)
  433. {
  434. gGL.getTexUnit(reftex)->activate();
  435. gGL.getTexUnit(reftex)->bind(&gPipeline.mWaterRef);
  436. gGL.getTexUnit(0)->activate();
  437. }
  439. //bind normal map
  440. S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
  442. LLWaterParamManager * param_mgr = LLWaterParamManager::instance();
  444. // change mWaterNormp if needed
  445. if (mWaterNormp->getID() != param_mgr->getNormalMapID())
  446. {
  447. mWaterNormp = LLViewerTextureManager::getFetchedTexture(param_mgr->getNormalMapID());
  448. }
  450. mWaterNormp->addTextureStats(1024.f*1024.f);
  451. gGL.getTexUnit(bumpTex)->bind(mWaterNormp) ;
  452. if (gSavedSettings.getBOOL("RenderWaterMipNormal"))
  453. {
  454. mWaterNormp->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
  455. }
  456. else 
  457. {
  458. mWaterNormp->setFilteringOption(LLTexUnit::TFO_POINT);
  459. }
  461. S32 screentex = shader->enableTexture(LLViewerShaderMgr::WATER_SCREENTEX);
  463. if (screentex > -1)
  464. {
  465. shader->uniform4fv(LLViewerShaderMgr::WATER_FOGCOLOR, 1, sWaterFogColor.mV);
  466. shader->uniform1f(LLViewerShaderMgr::WATER_FOGDENSITY, 
  467. param_mgr->getFogDensity());
  468. gPipeline.mWaterDis.bindTexture(0, screentex);
  469. }
  471. stop_glerror();
  473. 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. }
  481. F32 screenRes[] = 
  482. {
  483. 1.f/gGLViewport[2],
  484. 1.f/gGLViewport[3]
  485. };
  486. shader->uniform2fv("screenRes", 1, screenRes);
  487. stop_glerror();
  489. S32 diffTex = shader->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  490. stop_glerror();
  492. light_dir.normVec();
  493. sLightDir = light_dir;
  495. light_diffuse *= 6.f;
  497. //shader->uniformMatrix4fv("inverse_ref", 1, GL_FALSE, (GLfloat*) gGLObliqueProjectionInverse.mMatrix);
  498. shader->uniform1f(LLViewerShaderMgr::WATER_WATERHEIGHT, eyedepth);
  499. shader->uniform1f(LLViewerShaderMgr::WATER_TIME, sTime);
  500. shader->uniform3fv(LLViewerShaderMgr::WATER_EYEVEC, 1, LLViewerCamera::getInstance()->getOrigin().mV);
  501. shader->uniform3fv(LLViewerShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
  502. shader->uniform1f(LLViewerShaderMgr::WATER_SPECULAR_EXP, light_exp);
  503. shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR1, 1, param_mgr->getWave1Dir().mV);
  504. shader->uniform2fv(LLViewerShaderMgr::WATER_WAVE_DIR2, 1, param_mgr->getWave2Dir().mV);
  505. shader->uniform3fv(LLViewerShaderMgr::WATER_LIGHT_DIR, 1, light_dir.mV);
  507. shader->uniform3fv("normScale", 1, param_mgr->getNormalScale().mV);
  508. shader->uniform1f("fresnelScale", param_mgr->getFresnelScale());
  509. shader->uniform1f("fresnelOffset", param_mgr->getFresnelOffset());
  510. shader->uniform1f("blurMultiplier", param_mgr->getBlurMultiplier());
  512. F32 sunAngle = llmax(0.f, light_dir.mV[2]);
  513. F32 scaledAngle = 1.f - sunAngle;
  515. shader->uniform1f("sunAngle", sunAngle);
  516. shader->uniform1f("scaledAngle", scaledAngle);
  517. shader->uniform1f("sunAngle2", 0.1f + 0.2f*sunAngle);
  519. LLColor4 water_color;
  520. LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
  521. F32 up_dot = camera_up * LLVector3::z_axis;
  522. if (LLViewerCamera::getInstance()->cameraUnderWater())
  523. {
  524. water_color.setVec(1.f, 1.f, 1.f, 0.4f);
  525. shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleBelow());
  526. }
  527. else
  528. {
  529. water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
  530. shader->uniform1f(LLViewerShaderMgr::WATER_REFSCALE, param_mgr->getScaleAbove());
  531. }
  533. if (water_color.mV[3] > 0.9f)
  534. {
  535. water_color.mV[3] = 0.9f;
  536. }
  538. glColor4fv(water_color.mV);
  540. {
  541. LLGLDisable cullface(GL_CULL_FACE);
  542. for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
  543. iter != mDrawFace.end(); iter++)
  544. {
  545. LLFace *face = *iter;
  547. if (voskyp->isReflFace(face))
  548. {
  549. continue;
  550. }
  552. LLVOWater* water = (LLVOWater*) face->getViewerObject();
  553. gGL.getTexUnit(diffTex)->bind(face->getTexture());
  555. sNeedsReflectionUpdate = TRUE;
  557. if (water->getUseTexture())
  558. {
  559. sNeedsDistortionUpdate = TRUE;
  560. face->renderIndexed();
  561. }
  562. else
  563. { //smash background faces to far clip plane
  564. if (water->getIsEdgePatch())
  565. {
  566. if (deferred_render)
  567. {
  568. face->renderIndexed();
  569. }
  570. else
  571. {
  572. LLGLClampToFarClip far_clip(glh_get_current_projection());
  573. face->renderIndexed();
  574. }
  575. }
  576. else
  577. {
  578. sNeedsDistortionUpdate = TRUE;
  579. face->renderIndexed();
  580. }
  581. }
  582. }
  583. }
  585. shader->disableTexture(LLViewerShaderMgr::ENVIRONMENT_MAP, LLTexUnit::TT_CUBE_MAP);
  586. shader->disableTexture(LLViewerShaderMgr::WATER_SCREENTEX);
  587. shader->disableTexture(LLViewerShaderMgr::BUMP_MAP);
  588. shader->disableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
  589. shader->disableTexture(LLViewerShaderMgr::WATER_REFTEX);
  590. shader->disableTexture(LLViewerShaderMgr::WATER_SCREENDEPTH);
  592. if (deferred_render)
  593. {
  594. gPipeline.unbindDeferredShader(*shader);
  595. }
  596. else
  597. {
  598. shader->unbind();
  599. }
  601. gGL.getTexUnit(0)->activate();
  602. gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
  603. if (!deferred_render)
  604. {
  605. gGL.setColorMask(true, false);
  606. }
  608. }
  610. void LLDrawPoolWater::renderForSelect()
  611. {
  612. // Can't select water!
  613. return;
  614. }
  616. LLViewerTexture *LLDrawPoolWater::getDebugTexture()
  617. {
  618. return LLViewerFetchedTexture::sSmokeImagep;
  619. }
  621. LLColor3 LLDrawPoolWater::getDebugColor() const
  622. {
  623. return LLColor3(0.f, 1.f, 1.f);
  624. }