1 files changed, 78 insertions, 439 deletions

diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index 45b5c9509b..14f3142e1b 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -41,7 +41,6 @@
 #include "llsky.h"
 #include "llviewertexturelist.h"
 #include "llviewerregion.h"
-#include "llvosky.h"
 #include "llvowater.h"
 #include "llworld.h"
 #include "pipeline.h"
@@ -50,13 +49,13 @@
 #include "llsettingssky.h"
 #include "llsettingswater.h"
 
-BOOL deferred_render = FALSE;
-
 BOOL LLDrawPoolWater::sSkipScreenCopy = FALSE;
 BOOL LLDrawPoolWater::sNeedsReflectionUpdate = TRUE;
 BOOL LLDrawPoolWater::sNeedsDistortionUpdate = TRUE;
 F32 LLDrawPoolWater::sWaterFogEnd = 0.f;
 
+extern BOOL gCubeSnapshot;
+
 LLDrawPoolWater::LLDrawPoolWater() : LLFacePool(POOL_WATER)
 {
 }
@@ -90,423 +89,72 @@ void LLDrawPoolWater::setNormalMaps(const LLUUID& normalMapId, const LLUUID& nex
     mWaterNormp[1]->addTextureStats(1024.f*1024.f);
 }
 
-//static
-void LLDrawPoolWater::restoreGL()
-{
-	/*LLSettingsWater::ptr_t pwater = LLEnvironment::instance().getCurrentWater();
-    if (pwater)
-    {
-        setTransparentTextures(pwater->getTransparentTextureID(), pwater->getNextTransparentTextureID());
-        setOpaqueTexture(pwater->GetDefaultOpaqueTextureAssetId());
-        setNormalMaps(pwater->getNormalMapID(), pwater->getNextNormalMapID());
-    }*/
-}
-
 void LLDrawPoolWater::prerender()
 {
-	mShaderLevel = (gGLManager.mHasCubeMap && LLCubeMap::sUseCubeMaps) ? LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;
-}
-
-S32 LLDrawPoolWater::getNumPasses()
-{
-	if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)
-	{
-		return 1;
-	}
-
-	return 0;
-}
-
-void LLDrawPoolWater::beginPostDeferredPass(S32 pass)
-{
-	beginRenderPass(pass);
-	deferred_render = TRUE;
+	mShaderLevel = LLCubeMap::sUseCubeMaps ? LLViewerShaderMgr::instance()->getShaderLevel(LLViewerShaderMgr::SHADER_WATER) : 0;
 }
 
-void LLDrawPoolWater::endPostDeferredPass(S32 pass)
+S32 LLDrawPoolWater::getNumPostDeferredPasses()
 {
-	endRenderPass(pass);
-	deferred_render = FALSE;
-}
-
-//===============================
-//DEFERRED IMPLEMENTATION
-//===============================
-void LLDrawPoolWater::renderDeferred(S32 pass)
-{
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_WATER);
-
-    if (!LLPipeline::sRenderTransparentWater)
+    if (LLViewerCamera::getInstance()->getOrigin().mV[2] < 1024.f)
     {
-        // Will render opaque water without use of ALM
-        render(pass);
-        return;
+        return 1;
     }
 
-	deferred_render = TRUE;
-	renderWater();
-	deferred_render = FALSE;
+    return 0;
 }
 
-//=========================================
-
-void LLDrawPoolWater::render(S32 pass)
-{
-	LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL; //LL_RECORD_BLOCK_TIME(FTM_RENDER_WATER);
-	if (mDrawFace.empty() || LLDrawable::getCurrentFrame() <= 1)
-	{
-		return;
-	}
-
-	//do a quick 'n dirty depth sort
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-			 iter != mDrawFace.end(); iter++)
-	{
-		LLFace* facep = *iter;
-		facep->mDistance = -facep->mCenterLocal.mV[2];
-	}
-
-	std::sort(mDrawFace.begin(), mDrawFace.end(), LLFace::CompareDistanceGreater());
-
-	// See if we are rendering water as opaque or not
-	if (!LLPipeline::sRenderTransparentWater)
-	{
-		// render water for low end hardware
-		renderOpaqueLegacyWater();
-		return;
-	}
-
-	LLGLEnable blend(GL_BLEND);
-
-	if ((mShaderLevel > 0) && !sSkipScreenCopy)
-	{
-		renderWater();
-		return;
-	}
-
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	stop_glerror();
-
-	if (!gGLManager.mHasMultitexture)
-	{
-		// Ack!  No multitexture!  Bail!
-		return;
-	}
-
-	LLFace* refl_face = voskyp->getReflFace();
-
-	gPipeline.disableLights();
-	
-	LLGLDepthTest gls_depth(GL_TRUE, GL_FALSE);
-
-	LLGLDisable cullFace(GL_CULL_FACE);
-	
-	// Set up second pass first
-	gGL.getTexUnit(1)->activate();
-	gGL.getTexUnit(1)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->bind(mWaterImagep[0]) ;
-
-    gGL.getTexUnit(2)->activate();
-	gGL.getTexUnit(2)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(2)->bind(mWaterImagep[1]) ;
-
-	LLVector3 camera_up = LLViewerCamera::getInstance()->getUpAxis();
-	F32 up_dot = camera_up * LLVector3::z_axis;
-
-	LLColor4 water_color;
-	if (LLViewerCamera::getInstance()->cameraUnderWater())
-	{
-		water_color.setVec(1.f, 1.f, 1.f, 0.4f);
-	}
-	else
-	{
-		water_color.setVec(1.f, 1.f, 1.f, 0.5f*(1.f + up_dot));
-	}
-
-	gGL.diffuseColor4fv(water_color.mV);
-
-	// Automatically generate texture coords for detail map
-#if GL_VERSION_1_1
-	glEnable(GL_TEXTURE_GEN_S); //texture unit 1
-	glEnable(GL_TEXTURE_GEN_T); //texture unit 1
-	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-#endif
-
-	// Slowly move over time.
-	F32 offset = fmod(gFrameTimeSeconds*2.f, 100.f);
-	F32 tp0[4] = {16.f/256.f, 0.0f, 0.0f, offset*0.01f};
-	F32 tp1[4] = {0.0f, 16.f/256.f, 0.0f, offset*0.01f};
-#if GL_VERSION_1_1
-	glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
-	glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
-#endif
-
-	gGL.getTexUnit(0)->activate();
-	
-	glClearStencil(1);
-	glClear(GL_STENCIL_BUFFER_BIT);
-	LLGLEnable gls_stencil(GL_STENCIL_TEST);
-	glStencilOp(GL_KEEP, GL_REPLACE, GL_KEEP);
-	glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFF);
-
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-		 iter != mDrawFace.end(); iter++)
-	{
-		LLFace *face = *iter;
-		if (voskyp->isReflFace(face))
-		{
-			continue;
-		}
-		gGL.getTexUnit(0)->bind(face->getTexture());
-		face->renderIndexed();
-	}
-
-	// Now, disable texture coord generation on texture state 1
-	gGL.getTexUnit(1)->activate();
-	gGL.getTexUnit(1)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(1)->disable();
-
-#if GL_VERSION_1_1
-    glDisable(GL_TEXTURE_GEN_S); //texture unit 1
-	glDisable(GL_TEXTURE_GEN_T); //texture unit 1
-#endif
-
-    gGL.getTexUnit(2)->activate();
-	gGL.getTexUnit(2)->unbind(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(2)->disable();
-
-#if GL_VERSION_1_1
-	glDisable(GL_TEXTURE_GEN_S); //texture unit 1
-	glDisable(GL_TEXTURE_GEN_T); //texture unit 1
-#endif
-
-	// Disable texture coordinate and color arrays
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-	stop_glerror();
-	
-	if (gSky.mVOSkyp->getCubeMap())
-	{
-		gSky.mVOSkyp->getCubeMap()->enable(0);
-		gSky.mVOSkyp->getCubeMap()->bind();
-
-		gGL.matrixMode(LLRender::MM_TEXTURE);
-		gGL.loadIdentity();
-		LLMatrix4 camera_mat = LLViewerCamera::getInstance()->getModelview();
-		LLMatrix4 camera_rot(camera_mat.getMat3());
-		camera_rot.invert();
-
-		gGL.loadMatrix((F32 *)camera_rot.mMatrix);
-
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-		LLOverrideFaceColor overrid(this, 1.f, 1.f, 1.f,  0.5f*up_dot);
-
-		for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-			 iter != mDrawFace.end(); iter++)
-		{
-			LLFace *face = *iter;
-			if (voskyp->isReflFace(face))
-			{
-				//refl_face = face;
-				continue;
-			}
-
-			if (face->getGeomCount() > 0)
-			{					
-				face->renderIndexed();
-			}
-		}
-
-		gSky.mVOSkyp->getCubeMap()->disable();
-		
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-		gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-		gGL.matrixMode(LLRender::MM_TEXTURE);
-		gGL.loadIdentity();
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-		
-	}
-
-	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
-
-    if (refl_face)
-	{
-		glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
-		renderReflection(refl_face);
-	}
-}
-
-// for low end hardware
-void LLDrawPoolWater::renderOpaqueLegacyWater()
+void LLDrawPoolWater::beginPostDeferredPass(S32 pass)
 {
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
-    LLVOSky *voskyp = gSky.mVOSkyp;
+    LL_PROFILE_GPU_ZONE("water beginPostDeferredPass")
+    gGL.setColorMask(true, true);
 
-    if (voskyp == NULL)
+    if (LLPipeline::sRenderTransparentWater)
     {
-        return;
-    }
+        // copy framebuffer contents so far to a texture to be used for
+        // reflections and refractions
+        LLGLDepthTest depth(GL_TRUE, GL_TRUE, GL_ALWAYS);
 
-	LLGLSLShader* shader = NULL;
-	if (LLPipeline::sUnderWaterRender)
-	{
-		shader = &gObjectSimpleNonIndexedTexGenWaterProgram;
-	}
-	else
-	{
-		shader = &gObjectSimpleNonIndexedTexGenProgram;
-	}
+        LLRenderTarget& src = gPipeline.mRT->screen;
+        LLRenderTarget& depth_src = gPipeline.mRT->deferredScreen;
+        LLRenderTarget& dst = gPipeline.mWaterDis;
 
-	shader->bind();
+        dst.bindTarget();
+        gCopyDepthProgram.bind();
 
-	stop_glerror();
+        S32 diff_map = gCopyDepthProgram.getTextureChannel(LLShaderMgr::DIFFUSE_MAP);
+        S32 depth_map = gCopyDepthProgram.getTextureChannel(LLShaderMgr::DEFERRED_DEPTH);
 
-	// Depth sorting and write to depth buffer
-	// since this is opaque, we should see nothing
-	// behind the water.  No blending because
-	// of no transparency.  And no face culling so
-	// that the underside of the water is also opaque.
-	LLGLDepthTest gls_depth(GL_TRUE, GL_TRUE);
-	LLGLDisable no_cull(GL_CULL_FACE);
-	LLGLDisable no_blend(GL_BLEND);
+        gGL.getTexUnit(diff_map)->bind(&src);
+        gGL.getTexUnit(depth_map)->bind(&depth_src, true);
 
-	gPipeline.disableLights();
+        gPipeline.mScreenTriangleVB->setBuffer();
+        gPipeline.mScreenTriangleVB->drawArrays(LLRender::TRIANGLES, 0, 3);
 
-	// Activate the texture binding and bind one
-	// texture since all images will have the same texture
-	gGL.getTexUnit(0)->activate();
-	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-	gGL.getTexUnit(0)->bind(mOpaqueWaterImagep);
-
-	// Automatically generate texture coords for water texture
-	if (!shader)
-	{
-#if GL_VERSION_1_1
-		glEnable(GL_TEXTURE_GEN_S); //texture unit 0
-		glEnable(GL_TEXTURE_GEN_T); //texture unit 0
-		glTexGenf(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-		glTexGenf(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
-#endif
-	}
-
-	// Use the fact that we know all water faces are the same size
-	// to save some computation
-
-	// Slowly move texture coordinates over time so the watter appears
-	// to be moving.
-	F32 movement_period_secs = 50.f;
-
-	F32 offset = fmod(gFrameTimeSeconds, movement_period_secs);
-
-	if (movement_period_secs != 0)
-	{
-	 	offset /= movement_period_secs;
-	}
-	else
-	{
-		offset = 0;
-	}
-
-	F32 tp0[4] = { 16.f / 256.f, 0.0f, 0.0f, offset };
-	F32 tp1[4] = { 0.0f, 16.f / 256.f, 0.0f, offset };
-
-	if (!shader)
-	{
-#if GL_VERSION_1_1
-		glTexGenfv(GL_S, GL_OBJECT_PLANE, tp0);
-		glTexGenfv(GL_T, GL_OBJECT_PLANE, tp1);
-#endif
-	}
-	else
-	{
-		shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_S, 1, tp0);
-		shader->uniform4fv(LLShaderMgr::OBJECT_PLANE_T, 1, tp1);
-	}
-
-	gGL.diffuseColor3f(1.f, 1.f, 1.f);
-
-	for (std::vector<LLFace*>::iterator iter = mDrawFace.begin();
-		 iter != mDrawFace.end(); iter++)
-	{
-		LLFace *face = *iter;
-		if (voskyp->isReflFace(face))
-		{
-			continue;
-		}
-
-		face->renderIndexed();
-	}
-
-	stop_glerror();
-
-	if (!shader)
-	{
-		// Reset the settings back to expected values
-#if GL_VERSION_1_1
-		glDisable(GL_TEXTURE_GEN_S); //texture unit 0
-		glDisable(GL_TEXTURE_GEN_T); //texture unit 0
-#endif
-	}
-
-	gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-}
-
-
-void LLDrawPoolWater::renderReflection(LLFace* face)
-{
-    LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
-	LLVOSky *voskyp = gSky.mVOSkyp;
-
-	if (!voskyp)
-	{
-		return;
-	}
-
-	if (!face->getGeomCount())
-	{
-		return;
-	}
-	
-	S8 dr = voskyp->getDrawRefl();
-	if (dr < 0)
-	{
-		return;
-	}
-
-#if GL_VERSION_1_1
-	LLGLSNoFog noFog;
-#endif
-
-	gGL.getTexUnit(0)->bind((dr == 0) ? voskyp->getSunTex() : voskyp->getMoonTex());
-
-	LLOverrideFaceColor override(this, LLColor4(face->getFaceColor().mV));
-	face->renderIndexed();
+        dst.flush();
+    }
 }
 
-void LLDrawPoolWater::renderWater()
+void LLDrawPoolWater::renderPostDeferred(S32 pass) 
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_DRAWPOOL;
-    if (!deferred_render)
-    {
-        gGL.setColorMask(true, true);
-    }
-
     LLGLDisable blend(GL_BLEND);
+    
+    gGL.setColorMask(true, true);
 
     LLColor3 light_diffuse(0, 0, 0);
     F32      light_exp = 0.0f;
 
-    LLEnvironment &        environment     = LLEnvironment::instance();
-    LLSettingsWater::ptr_t pwater          = environment.getCurrentWater();
-    LLSettingsSky::ptr_t   psky            = environment.getCurrentSky();
+    LLEnvironment& environment = LLEnvironment::instance();
+    LLSettingsWater::ptr_t pwater = environment.getCurrentWater();
+    LLSettingsSky::ptr_t   psky   = environment.getCurrentSky();
     LLVector3              light_dir       = environment.getLightDirection();
     bool                   sun_up          = environment.getIsSunUp();
     bool                   moon_up         = environment.getIsMoonUp();
     bool                   has_normal_mips = gSavedSettings.getBOOL("RenderWaterMipNormal");
     bool                   underwater      = LLViewerCamera::getInstance()->cameraUnderWater();
+    LLColor4               fog_color       = LLColor4(pwater->getWaterFogColor(), 0.f);
+    LLColor3               fog_color_linear = linearColor3(fog_color);
 
     if (sun_up)
     {
@@ -524,56 +172,48 @@ void LLDrawPoolWater::renderWater()
     F32 ground_proj_sq = light_dir.mV[0] * light_dir.mV[0] + light_dir.mV[1] * light_dir.mV[1];
     light_exp          = llmax(32.f, 256.f * powf(ground_proj_sq, 16.0f));
     if (0.f < light_diffuse.normalize())  // Normalizing a color? Puzzling...
-    {
+	{
         light_diffuse *= (1.5f + (6.f * ground_proj_sq));
     }
 
     // set up normal maps filtering
     for (auto norm_map : mWaterNormp)
-    {
+	    {
         if (norm_map) norm_map->setFilteringOption(has_normal_mips ? LLTexUnit::TFO_ANISOTROPIC : LLTexUnit::TFO_POINT);
-    }
+	    }
 
     LLColor4      specular(sun_up ? psky->getSunlightColor() : psky->getMoonlightColor());
     F32           phase_time = (F32) LLFrameTimer::getElapsedSeconds() * 0.5f;
     LLGLSLShader *shader     = nullptr;
 
     // two passes, first with standard water shader bound, second with edge water shader bound
-    for( int edge = 0 ; edge < 2; edge++ )
+    for (int edge = 0; edge < 2; edge++)
     {
         // select shader
-        if (underwater && LLPipeline::sWaterReflections)
+        if (underwater)
         {
-            shader = deferred_render ? &gDeferredUnderWaterProgram : &gUnderWaterProgram;
+            shader = &gUnderWaterProgram;
         }
         else
         {
-            if (edge && !deferred_render)
+            if (edge)
             {
                 shader = &gWaterEdgeProgram;
             }
             else
             {
-                shader = deferred_render ? &gDeferredWaterProgram : &gWaterProgram;
+                shader = &gWaterProgram;
             }
         }
-        shader->bind();
 
-        // bind textures for water rendering
-        S32 reftex = shader->enableTexture(LLShaderMgr::WATER_REFTEX);
-        if (reftex > -1)
-        {
-            gGL.getTexUnit(reftex)->activate();
-            gGL.getTexUnit(reftex)->bind(&gPipeline.mWaterRef);
-            gGL.getTexUnit(0)->activate();
-        }
+        gPipeline.bindDeferredShader(*shader);
 
-        // bind normal map
-        S32 bumpTex  = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
+        //bind normal map
+        S32 bumpTex = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP);
         S32 bumpTex2 = shader->enableTexture(LLViewerShaderMgr::BUMP_MAP2);
 
-        LLViewerTexture *tex_a = mWaterNormp[0];
-        LLViewerTexture *tex_b = mWaterNormp[1];
+        LLViewerTexture* tex_a = mWaterNormp[0];
+        LLViewerTexture* tex_b = mWaterNormp[1];
 
         F32 blend_factor = pwater->getBlendFactor();
 
@@ -583,12 +223,12 @@ void LLDrawPoolWater::renderWater()
         if (tex_a && (!tex_b || (tex_a == tex_b)))
         {
             gGL.getTexUnit(bumpTex)->bind(tex_a);
-            blend_factor = 0;  // only one tex provided, no blending
+            blend_factor = 0; // only one tex provided, no blending
         }
         else if (tex_b && !tex_a)
         {
             gGL.getTexUnit(bumpTex)->bind(tex_b);
-            blend_factor = 0;  // only one tex provided, no blending
+            blend_factor = 0; // only one tex provided, no blending
         }
         else if (tex_b != tex_a)
         {
@@ -597,25 +237,16 @@ void LLDrawPoolWater::renderWater()
         }
 
         // bind reflection texture from RenderTarget
-        S32 screentex   = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX);
-        F32 screenRes[] = {1.f / gGLViewport[2], 1.f / gGLViewport[3]};
+        S32 screentex = shader->enableTexture(LLShaderMgr::WATER_SCREENTEX);
+        S32 screenDepth = shader->enableTexture(LLShaderMgr::WATER_SCREENDEPTH);
 
-        S32 diffTex = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
+        F32 screenRes[] = { 1.f / gGLViewport[2], 1.f / gGLViewport[3] };
 
-        // set uniforms for shader
-        if (deferred_render)
-        {
-            if (shader->getUniformLocation(LLShaderMgr::DEFERRED_NORM_MATRIX) >= 0)
-            {
-                glh::matrix4f norm_mat = get_current_modelview().inverse().transpose();
-                shader->uniformMatrix4fv(LLShaderMgr::DEFERRED_NORM_MATRIX, 1, FALSE, norm_mat.m);
-            }
-        }
+        S32 diffTex = shader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
 
         shader->uniform2fv(LLShaderMgr::DEFERRED_SCREEN_RES, 1, screenRes);
         shader->uniform1f(LLShaderMgr::BLEND_FACTOR, blend_factor);
 
-        LLColor4 fog_color(pwater->getWaterFogColor(), 0.0f);
         F32      fog_density = pwater->getModifiedWaterFogDensity(underwater);
 
         if (screentex > -1)
@@ -624,12 +255,17 @@ void LLDrawPoolWater::renderWater()
             gGL.getTexUnit(screentex)->bind(&gPipeline.mWaterDis);
         }
 
+        if (screenDepth > -1)
+        {
+            gGL.getTexUnit(screenDepth)->bind(&gPipeline.mWaterDis, true);
+        }
+
         if (mShaderLevel == 1)
         {
             fog_color.mV[VW] = log(fog_density) / log(2);
         }
 
-        F32 water_height  = environment.getWaterHeight();
+        F32 water_height = environment.getWaterHeight();
         F32 camera_height = LLViewerCamera::getInstance()->getOrigin().mV[2];
         shader->uniform1f(LLShaderMgr::WATER_WATERHEIGHT, camera_height - water_height);
         shader->uniform1f(LLShaderMgr::WATER_TIME, phase_time);
@@ -637,6 +273,7 @@ void LLDrawPoolWater::renderWater()
 
         shader->uniform4fv(LLShaderMgr::SPECULAR_COLOR, 1, specular.mV);
         shader->uniform4fv(LLShaderMgr::WATER_FOGCOLOR, 1, fog_color.mV);
+        shader->uniform3fv(LLShaderMgr::WATER_FOGCOLOR_LINEAR, 1, fog_color_linear.mV);
 
         shader->uniform3fv(LLShaderMgr::WATER_SPECULAR, 1, light_diffuse.mV);
         shader->uniform1f(LLShaderMgr::WATER_SPECULAR_EXP, light_exp);
@@ -651,7 +288,7 @@ void LLDrawPoolWater::renderWater()
         shader->uniform1f(LLShaderMgr::WATER_FRESNEL_OFFSET, pwater->getFresnelOffset());
         shader->uniform1f(LLShaderMgr::WATER_BLUR_MULTIPLIER, pwater->getBlurMultiplier());
 
-        F32 sunAngle    = llmax(0.f, light_dir.mV[1]);
+        F32 sunAngle = llmax(0.f, light_dir.mV[1]);
         F32 scaledAngle = 1.f - sunAngle;
 
         shader->uniform1i(LLShaderMgr::SUN_UP_FACTOR, sun_up ? 1 : 0);
@@ -660,8 +297,11 @@ void LLDrawPoolWater::renderWater()
         shader->uniform1f(LLShaderMgr::WATER_SUN_ANGLE2, 0.1f + 0.2f * sunAngle);
         shader->uniform1i(LLShaderMgr::WATER_EDGE_FACTOR, edge ? 1 : 0);
 
-        LLVector4 rotated_light_direction = LLEnvironment::instance().getRotatedLightNorm();
-        shader->uniform4fv(LLViewerShaderMgr::LIGHTNORM, 1, rotated_light_direction.mV);
+        // SL-15861 This was changed from getRotatedLightNorm() as it was causing
+        // lightnorm in shaders\class1\windlight\atmosphericsFuncs.glsl in have inconsistent additive lighting for 180 degrees of the FOV.
+        LLVector4 rotated_light_direction = LLEnvironment::instance().getClampedLightNorm();
+        shader->uniform3fv(LLViewerShaderMgr::LIGHTNORM, 1, rotated_light_direction.mV);
+
         shader->uniform3fv(LLShaderMgr::WL_CAMPOSLOCAL, 1, LLViewerCamera::getInstance()->getOrigin().mV);
 
         if (LLViewerCamera::getInstance()->cameraUnderWater())
@@ -675,16 +315,16 @@ void LLDrawPoolWater::renderWater()
 
         LLGLDisable cullface(GL_CULL_FACE);
 
-        LLVOWater *water = nullptr;
-        for (LLFace *const &face : mDrawFace)
+        LLVOWater* water = nullptr;
+        for (LLFace* const& face : mDrawFace)
         {
             if (!face) continue;
-            water = static_cast<LLVOWater *>(face->getViewerObject());
+            water = static_cast<LLVOWater*>(face->getViewerObject());
             if (!water) continue;
 
             gGL.getTexUnit(diffTex)->bind(face->getTexture());
 
-            if ((bool)edge == (bool) water->getIsEdgePatch())
+            if ((bool)edge == (bool)water->getIsEdgePatch())
             {
                 face->renderIndexed();
 
@@ -705,22 +345,21 @@ void LLDrawPoolWater::renderWater()
         shader->disableTexture(LLShaderMgr::WATER_SCREENDEPTH);
 
         // clean up
-        shader->unbind();
+        gPipeline.unbindDeferredShader(*shader);
+
         gGL.getTexUnit(bumpTex)->unbind(LLTexUnit::TT_TEXTURE);
         gGL.getTexUnit(bumpTex2)->unbind(LLTexUnit::TT_TEXTURE);
     }
 
-    gGL.getTexUnit(0)->activate();
-    gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
-    if (!deferred_render)
-    {
-        gGL.setColorMask(true, false);
-    }
+	gGL.getTexUnit(0)->activate();
+	gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
+	
+    gGL.setColorMask(true, false);
 }
 
 LLViewerTexture *LLDrawPoolWater::getDebugTexture()
 {
-	return LLViewerFetchedTexture::sSmokeImagep;
+    return LLViewerTextureManager::getFetchedTexture(IMG_SMOKE);
 }
 
 LLColor3 LLDrawPoolWater::getDebugColor() const