SL-10664, SL-10666

Fix up culling issues from perf work and fix Depth of Field rendering to get depth values properly.

Baseline for performance work.

24 files changed, 691 insertions, 507 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index 6e1f0f201b..9191787273 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -118,7 +118,7 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 diffuse, vec3 v, vec3 n, vec
         da *= spot*spot; // GL_SPOT_EXPONENT=2
 
         // to match spotLight (but not multiSpotLight) *sigh*
-        float lit = max(min(da, shadow) * dist_atten,0.0);
+        float lit = max(da * dist_atten,0.0);
         col = lit * light_col * diffuse;
 
         float amb_da = ambiance;
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index e2ebd928ef..4db2b9ae54 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -119,7 +119,7 @@ vec3 calcPointLightOrSpotLight(vec3 light_col, vec3 npos, vec3 diffuse, vec4 spe
         da *= clamp(da, 0.0, 1.0);
         da *= pow(da, 1.0 / 1.3);
         
-        float lit = max(min(da,shadow) * dist_atten, 0.0);
+        float lit = max(da * dist_atten, 0.0);
 
         col = light_col*lit*diffuse;
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index be5e3538a7..628f73da59 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -167,6 +167,8 @@ void main()
 
     vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz);
 
+color.rgb = max(fb.rgb, refcol.rgb);
+
     frag_data[0] = vec4(color.rgb, 1); // diffuse
     frag_data[1] = vec4(0);     // speccolor, spec
     frag_data[2] = vec4(encode_normal(screenspacewavef.xyz*0.5+0.5), 0.05, 0);// normalxy, 0, 0
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersF.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersF.glsl
index 3572331d74..10407eeb02 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersF.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersF.glsl
@@ -25,9 +25,11 @@
  
 uniform vec4 sunlight_color;
 uniform vec4 light_ambient;
+uniform int no_atmo;
 
 vec3 atmosAmbient(vec3 light)
 {
+    if (no_atmo == 1) return light + vec3(0.66);
     return light + light_ambient.rgb;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
index 7e4855b7c6..14034bccae 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/atmosphericsHelpersV.glsl
@@ -25,9 +25,11 @@
  
 uniform vec4 sunlight_color;
 uniform vec4 light_ambient;
+uniform int no_atmo;
 
 vec3 atmosAmbient(vec3 light)
 {
+    if (no_atmo == 1) return light + vec3(0.66);
     return light + light_ambient.rgb;
 }
 
diff --git a/indra/newview/app_settings/shaders/class1/windlight/gammaF.glsl b/indra/newview/app_settings/shaders/class1/windlight/gammaF.glsl
index 9917ba8d3b..667301443a 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/gammaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/gammaF.glsl
@@ -23,6 +23,7 @@
  * $/LicenseInfo$
  */
  
+uniform int no_atmo;
 uniform vec4 gamma;
 
 vec3 scaleSoftClipFrag(vec3 light)
diff --git a/indra/newview/app_settings/shaders/class1/windlight/transportF.glsl b/indra/newview/app_settings/shaders/class1/windlight/transportF.glsl
index f61194db6d..e2b391cb7a 100644
--- a/indra/newview/app_settings/shaders/class1/windlight/transportF.glsl
+++ b/indra/newview/app_settings/shaders/class1/windlight/transportF.glsl
@@ -23,6 +23,8 @@
  * $/LicenseInfo$
  */
 
+uniform int no_atmo;
+
 vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
     /* stub function for fallback compatibility on class1 hardware */
diff --git a/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
index 0f6bf38388..275bc829a7 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/multiSpotLightF.glsl
@@ -211,8 +211,10 @@ void main()
 			dlit = color.rgb * plcol.rgb * plcol.a;
 			
 			col = dlit*lit*diff_tex*shadow;
-			amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
-			amb_da = min(amb_da,shadow);
+            amb_da += (da*0.5) * proj_ambiance;
+            amb_da += (da*da*0.5 + 0.5) * proj_ambiance;
+			//amb_da += (da*0.5)*(1.0-shadow)*proj_ambiance;
+			//amb_da = min(amb_da,shadow);
 		}
 		
 		//float diff = clamp((proj_range-proj_focus)/proj_range, 0.0, 1.0);
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 415c894a43..d220bda332 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -120,7 +120,7 @@ void main()
     
         calcFragAtmospherics(pos.xyz, ambocc, sunlit, amblit, additive, atten);
 
-        float ambient = min(abs(da), 1.0);
+        float ambient = abs(da);
         ambient *= 0.5;
         ambient *= ambient;
         ambient = 1.0 - ambient * smoothstep(0.0, 0.3, scol);
@@ -155,6 +155,8 @@ void main()
             col = mix(col.rgb, refcol, envIntensity); 
         }
                 
+
+vec3 a = col.rgb;
         if (norm.w < 0.5)
         {
             col = mix(atmosFragLighting(col, additive, atten), fullbrightAtmosTransportFrag(col, additive, atten), diffuse.a);
@@ -166,8 +168,9 @@ void main()
             col = fogged.rgb;
             bloom = fogged.a;
         #endif
-    }
 
+//col.rgb = a;
+    }
     frag_color.rgb = col.rgb;
     frag_color.a = bloom;
 }
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
index ebb06e0f23..565c00ba79 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsF.glsl
@@ -43,12 +43,17 @@ uniform float max_y;
 uniform vec4 glow;
 uniform float scene_light_strength;
 uniform mat3 ssao_effect_mat;
+uniform int no_atmo;
 uniform float sun_moon_glow_factor;
 
 vec3 scaleSoftClipFrag(vec3 light);
 
 vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten)
 {
+    if (no_atmo == 1)
+    {
+        return light;
+    }
     light *= atten.r;
     light += additive;
     return light * 2.0;
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersF.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersF.glsl
index c836ca98c5..86743dc306 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersF.glsl
@@ -26,9 +26,11 @@
 // Output variables
 
 uniform float scene_light_strength;
+uniform int no_atmo;
 
 vec3 atmosFragAmbient(vec3 light, vec3 amblit)
 {
+    if (no_atmo == 1) return light;
     return amblit + light / 2.0;
 }
 
diff --git a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersV.glsl b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersV.glsl
index 589c95bc96..95b4a76880 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersV.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/atmosphericsHelpersV.glsl
@@ -33,9 +33,11 @@ vec3 getAtmosAttenuation();
 vec3 getPositionEye();
 
 uniform float scene_light_strength;
+uniform int no_atmo;
 
 vec3 atmosAmbient(vec3 light)
 {
+    if (no_atmo == 1) return light + vec3(0.66);
     return getAmblitColor() + light / 2.0;
 }
 
diff --git a/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl b/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
index e985c50c67..c0439006f7 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/gammaF.glsl
@@ -26,12 +26,17 @@
 
 
 uniform vec4 gamma;
+uniform int no_atmo;
 
 vec3 getAtmosAttenuation();
 vec3 getAdditiveColor();
 
 vec3 scaleSoftClipFrag(vec3 light)
 {
+    if (no_atmo == 1)
+    {
+        return light;
+    }
     //soft clip effect:
     light = 1. - clamp(light, vec3(0.), vec3(1.));
     light = 1. - pow(light, gamma.xxx);
@@ -45,7 +50,8 @@ vec3 scaleSoftClip(vec3 light)
 
 vec3 fullbrightScaleSoftClipFrag(vec3 light, vec3 add, vec3 atten)
 {
-    return mix(scaleSoftClipFrag(light.rgb), add, atten);
+    //return mix(scaleSoftClipFrag(light.rgb), add, atten);
+    return scaleSoftClipFrag(light.rgb);
 }
 
 vec3 fullbrightScaleSoftClip(vec3 light)
diff --git a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
index d799453712..df731662e8 100644
--- a/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
+++ b/indra/newview/app_settings/shaders/class2/windlight/transportF.glsl
@@ -30,21 +30,34 @@
 vec3 getAdditiveColor();
 vec3 getAtmosAttenuation();
 
+uniform int no_atmo;
+
 vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
+    if (no_atmo == 1)
+    {
+        return light;
+    }
     light *= atten.r;
-    light += additive;
-    return light * 2.0;
+    light += additive * 2.0;
+    return light;
 }
 
 vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
+    if (no_atmo == 1)
+    {
+        return light;
+    }
     float brightness = dot(light.rgb, vec3(0.33333));
     return mix(atmosTransportFrag(light.rgb, additive, atten), light.rgb + additive.rgb, brightness * brightness);
 }
 
-vec3 fullbrightShinyAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
-{
+vec3 fullbrightShinyAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten) {
+    if (no_atmo == 1)
+    {
+        return light;
+    }
     float brightness = dot(light.rgb, vec3(0.33333));
     return mix(atmosTransportFrag(light.rgb, additive, atten), (light.rgb + additive.rgb) * (2.0 - brightness), brightness * brightness);
 }
diff --git a/indra/newview/app_settings/shaders/class3/windlight/transportF.glsl b/indra/newview/app_settings/shaders/class3/windlight/transportF.glsl
index 7f74122665..90ab5d2793 100644
--- a/indra/newview/app_settings/shaders/class3/windlight/transportF.glsl
+++ b/indra/newview/app_settings/shaders/class3/windlight/transportF.glsl
@@ -30,21 +30,35 @@
 vec3 getAdditiveColor();
 vec3 getAtmosAttenuation();
 
+uniform int no_atmo;
+
 vec3 atmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
-    return (light + additive) * atten * 2.0;
+    if (no_atmo == 1)
+	{
+        return light;
+    }
+	return (light + additive) * atten * 2.0;
 }
 
 vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
-    float brightness = dot(light.rgb, vec3(0.33333));
-    return mix(atmosTransportFrag(light.rgb, additive,atten), light.rgb + additive.rgb, brightness * brightness);
+    if (no_atmo == 1)
+    {
+		return light;
+	}
+	float brightness = dot(light.rgb, vec3(0.33333));
+	return mix(atmosTransportFrag(light.rgb, additive,atten), light.rgb + additive.rgb, brightness * brightness);
 }
 
 vec3 fullbrightShinyAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten)
 {
-    float brightness = dot(light.rgb, vec3(0.33333));
-    return mix(atmosTransportFrag(light.rgb, additive, atten), (light.rgb + additive.rgb) * (2.0 - brightness), brightness * brightness);
+    if (no_atmo == 1)
+    {
+		return light;
+	}
+	float brightness = dot(light.rgb, vec3(0.33333));
+	return mix(atmosTransportFrag(light.rgb, additive, atten), (light.rgb + additive.rgb) * (2.0 - brightness), brightness * brightness);
 }
 
 vec3 atmosTransport(vec3 light)
diff --git a/indra/newview/lldrawpoolalpha.cpp b/indra/newview/lldrawpoolalpha.cpp
index 5396a8fdd2..be57e5afde 100644
--- a/indra/newview/lldrawpoolalpha.cpp
+++ b/indra/newview/lldrawpoolalpha.cpp
@@ -105,6 +105,32 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 { 
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DEFERRED);
 
+    if (LLPipeline::sRenderDeferred)
+    {
+		emissive_shader = &gDeferredEmissiveProgram;
+    }
+    else
+    {
+		if (LLPipeline::sUnderWaterRender)
+		{
+			emissive_shader = &gObjectEmissiveWaterProgram;
+		}
+		else
+		{
+			emissive_shader = &gObjectEmissiveProgram;
+		}
+    }
+
+    emissive_shader->bind();
+	if (LLPipeline::sRenderingHUDs)
+	{
+		emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		emissive_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
+
 	if (pass == 0)
 	{
 		if (LLPipeline::sImpostorRender)
@@ -128,13 +154,13 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		fullbright_shader->bind();
 		fullbright_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f); 
 		fullbright_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
-	    fullbright_shader->setMinimumAlpha(LLPipeline::sImpostorRender ? 0.5f : 0.0f);
-        fullbright_shader->unbind();
+        fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, LLPipeline::sRenderingHUDs ? 1 : 0);
+		fullbright_shader->unbind();
 
 		//prime simple shader (loads shadow relevant uniforms)
 		gPipeline.bindDeferredShader(*simple_shader);
-		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));       
-        simple_shader->setMinimumAlpha(LLPipeline::sImpostorRender ? 0.5f : 0.0f);
+
+		simple_shader->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
 	else if (!LLPipeline::sImpostorRender)
 	{
@@ -148,23 +174,6 @@ void LLDrawPoolAlpha::beginPostDeferredPass(S32 pass)
 		gObjectFullbrightAlphaMaskProgram.setMinimumAlpha(0.33f);
 	}
 
-
-    if (LLPipeline::sRenderDeferred)
-    {
-		emissive_shader = &gDeferredEmissiveProgram;
-    }
-    else
-    {
-		if (LLPipeline::sUnderWaterRender)
-		{
-			emissive_shader = &gObjectEmissiveWaterProgram;
-		}
-		else
-		{
-			emissive_shader = &gObjectEmissiveProgram;
-		}
-    }
-
 	deferred_render = TRUE;
 	if (mShaderLevel > 0)
 	{
@@ -279,15 +288,47 @@ void LLDrawPoolAlpha::render(S32 pass)
 			{
 				fullbright_shader->bind();
 				fullbright_shader->setMinimumAlpha(0.5f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 				simple_shader->bind();
 				simple_shader->setMinimumAlpha(0.5f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 			}				
 			else
 			{
 				fullbright_shader->bind();
 				fullbright_shader->setMinimumAlpha(0.f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 				simple_shader->bind();
 				simple_shader->setMinimumAlpha(0.f);
+                if (LLPipeline::sRenderingHUDs)
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	            }
+	            else
+	            {
+		            simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	            }
 			}
 		}
 		else
@@ -395,320 +436,267 @@ void LLDrawPoolAlpha::renderAlpha(U32 mask, S32 pass)
 	BOOL light_enabled = TRUE;
 	
 	BOOL use_shaders = gPipeline.canUseVertexShaders();
+		
+	for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
+	{
+		LLSpatialGroup* group = *i;
+		llassert(group);
+        if (!group)
+        {
+            continue;
+        }
+        LLSpatialPartition* partition = group->getSpatialPartition();
+		llassert(partition);        
+        if (!partition)
+        {
+            continue;
+        }
 
-    {
-        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GROUP_LOOP);
-
-	    for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
-	    {
-		    LLSpatialGroup* group = *i;
-		    llassert(group);
-		    llassert(group->getSpatialPartition());
-
-		    if (group->getSpatialPartition()->mRenderByGroup &&
-		        !group->isDead())
-		    {
-			    bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
-													      || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
-
-			    bool disable_cull = is_particle_or_hud_particle;
-			    LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
-
-			    LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
-
-			    for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
-			    {
-				    LLDrawInfo& params = **k;
-
-				    if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
-				    { //FIXME!
-					    LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
-									    << " present: " << (params.mVertexBuffer->getTypeMask() & mask)
-									    << ". Skipping render batch." << LL_ENDL;
-					    continue;
-				    }
-
-				    // Fix for bug - NORSPEC-271
-				    // If the face is more than 90% transparent, then don't update the Depth buffer for Dof
-				    // We don't want the nearly invisible objects to cause of DoF effects
-				    if(pass == 1 && !LLPipeline::sImpostorRender)
-				    {
-					    LLFace*	face = params.mFace;
-					    if(face)
-					    {
-						    const LLTextureEntry* tep = face->getTextureEntry();
-						    if(tep)
-						    {
-							    if(tep->getColor().mV[3] < 0.1f)
-								    continue;
-						    }
-					    }
-				    }
-
-				    LLRenderPass::applyModelMatrix(params);
-
-				    LLMaterial* mat = NULL;
-
-				    if (deferred_render)
-				    {
-					    mat = params.mMaterial;
-				    }
+		if (partition->mRenderByGroup &&
+		    !group->isDead())
+		{
+			bool is_particle_or_hud_particle = partition->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
+								            || partition->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
+
+			bool draw_glow_for_this_partition = mShaderLevel > 0; // no shaders = no glow.
+
+			LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GROUP_LOOP);
+
+			bool disable_cull = is_particle_or_hud_particle;
+			LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
+
+			LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
+
+			for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
+			{
+				LLDrawInfo& params = **k;
+
+				if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
+				{ //FIXME!
+					LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
+									<< " present: " << (params.mVertexBuffer->getTypeMask() & mask)
+									<< ". Skipping render batch." << LL_ENDL;
+					continue;
+				}
+
+				// Fix for bug - NORSPEC-271
+				// If the face is more than 90% transparent, then don't update the Depth buffer for Dof
+				// We don't want the nearly invisible objects to cause of DoF effects
+				if(pass == 1 && !LLPipeline::sImpostorRender)
+				{
+					LLFace*	face = params.mFace;
+					if(face)
+					{
+						const LLTextureEntry* tep = face->getTextureEntry();
+						if(tep)
+						{
+							if(tep->getColor().mV[3] < 0.1f)
+								continue;
+						}
+					}
+				}
+
+				LLRenderPass::applyModelMatrix(params);
+
+				LLMaterial* mat = NULL;
+
+				if (deferred_render)
+				{
+					mat = params.mMaterial;
+				}
 				
-				    if (params.mFullbright)
-				    {
-					    // Turn off lighting if it hasn't already been so.
-					    if (light_enabled || !initialized_lighting)
-					    {
-						    initialized_lighting = TRUE;
-						    if (use_shaders) 
-						    {
-							    target_shader = fullbright_shader;
-						    }
-						    else
-						    {
-							    gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
-						    }
-						    light_enabled = FALSE;
-					    }
-				    }
-				    // Turn on lighting if it isn't already.
-				    else if (!light_enabled || !initialized_lighting)
-				    {
-					    initialized_lighting = TRUE;
-					    if (use_shaders) 
-					    {
-						    target_shader = simple_shader;
-					    }
-					    else
-					    {
-						    gPipeline.enableLightsDynamic();
-					    }
-					    light_enabled = TRUE;
-				    }
-
-				    if (deferred_render && mat)
-				    {
-					    U32 mask = params.mShaderMask;
-
-					    llassert(mask < LLMaterial::SHADER_COUNT);
-					    target_shader = &(gDeferredMaterialProgram[mask]);
-
-					    if (LLPipeline::sUnderWaterRender)
-					    {
-						    target_shader = &(gDeferredMaterialWaterProgram[mask]);
-					    }
-
-					    if (current_shader != target_shader)
-					    {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DEFERRED_SHADER_BINDS);
-						    gPipeline.bindDeferredShader(*target_shader);
-                            current_shader = target_shader;
-					    }
-				    }
-				    else if (!params.mFullbright)
-				    {
-					    target_shader = simple_shader;
-				    }
-				    else
-				    {
-					    target_shader = fullbright_shader;
-				    }
+				if (params.mFullbright)
+				{
+					// Turn off lighting if it hasn't already been so.
+					if (light_enabled || !initialized_lighting)
+					{
+						initialized_lighting = TRUE;
+						if (use_shaders) 
+						{
+							target_shader = fullbright_shader;
+						}
+						else
+						{
+							gPipeline.enableLightsFullbright(LLColor4(1,1,1,1));
+						}
+						light_enabled = FALSE;
+					}
+				}
+				// Turn on lighting if it isn't already.
+				else if (!light_enabled || !initialized_lighting)
+				{
+					initialized_lighting = TRUE;
+					if (use_shaders) 
+					{
+						target_shader = simple_shader;
+					}
+					else
+					{
+						gPipeline.enableLightsDynamic();
+					}
+					light_enabled = TRUE;
+				}
+
+				if (deferred_render && mat)
+				{
+					U32 mask = params.mShaderMask;
+
+					llassert(mask < LLMaterial::SHADER_COUNT);
+					target_shader = &(gDeferredMaterialProgram[mask]);
+
+					if (LLPipeline::sUnderWaterRender)
+					{
+						target_shader = &(gDeferredMaterialWaterProgram[mask]);
+					}
+
+					if (current_shader != target_shader)
+					{
+						gPipeline.bindDeferredShader(*target_shader);
+					}
+				}
+				else if (!params.mFullbright)
+				{
+					target_shader = simple_shader;
+				}
+				else
+				{
+					target_shader = fullbright_shader;
+				}
 				
-				    if(use_shaders && (current_shader != target_shader))
-				    {// If we need shaders, and we're not ALREADY using the proper shader, then bind it
-				    // (this way we won't rebind shaders unnecessarily).
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_SHADER_BINDS);
-
-					    current_shader = target_shader;
-					    current_shader->bind();
-				    }
-				    else if (!use_shaders && current_shader != NULL)
-				    {
-					    LLGLSLShader::bindNoShader();
-					    current_shader = NULL;
-				    }
-
-				    if (use_shaders && mat)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MATS);
-
-					    // We have a material.  Supply the appropriate data here.
-					    if (LLPipeline::sRenderDeferred)
-					    {
-						    current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, params.mSpecColor.mV[0], params.mSpecColor.mV[1], params.mSpecColor.mV[2], params.mSpecColor.mV[3]);						
-						    current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, params.mEnvIntensity);
-						    current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, params.mFullbright ? 1.f : 0.f);
-
-						    if (params.mNormalMap)
-						    {
-							    params.mNormalMap->addTextureStats(params.mVSize);
-							    current_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
-						    } 
-						
-						    if (params.mSpecularMap)
-						    {
-							    params.mSpecularMap->addTextureStats(params.mVSize);
-							    current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap);
-						    } 
-					    }
-
-				    }
-                    else if (LLPipeline::sRenderDeferred && current_shader && (current_shader == simple_shader))
-				    {
-					    current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, 1.0f, 1.0f, 1.0f, 1.0f);						
-					    current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, 0.0f);			
-					    LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(params.mVSize);
-					    current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);						
-					    LLViewerFetchedTexture::sWhiteImagep->addTextureStats(params.mVSize);
-					    current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
-				    }
-
-				    if (params.mGroup)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MESH_REBUILD);
-
-					    params.mGroup->rebuildMesh();
-				    }
-
-				    bool tex_setup = false;
-
-				    if (use_shaders && params.mTextureList.size() > 1)
-				    {
-                        LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_TEX_BINDS);
-					    for (U32 i = 0; i < params.mTextureList.size(); ++i)
-					    {
-						    if (params.mTextureList[i].notNull())
-						    {
-							    gGL.getTexUnit(i)->bind(params.mTextureList[i], TRUE);
-						    }
-					    }
-				    }
-				    else
-				    { //not batching textures or batch has only 1 texture -- might need a texture matrix
-					    if (params.mTexture.notNull())
-					    {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_TEX_BINDS);
-
-						    params.mTexture->addTextureStats(params.mVSize);
-						    if (use_shaders && mat)
-						    {
-							    current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, params.mTexture);
-						    }
-						    else
-						    {
-						        gGL.getTexUnit(0)->bind(params.mTexture, TRUE) ;
-						    }
+				if(use_shaders && (current_shader != target_shader))
+				{// If we need shaders, and we're not ALREADY using the proper shader, then bind it
+				// (this way we won't rebind shaders unnecessarily).
+					current_shader = target_shader;
+					current_shader->bind();
+				}
+				else if (!use_shaders && current_shader != NULL)
+				{
+					LLGLSLShader::bindNoShader();
+					current_shader = NULL;
+				}
+
+				if (use_shaders && mat)
+				{
+					// We have a material.  Supply the appropriate data here.
+					if (LLPipeline::sRenderDeferred)
+					{
+						current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, params.mSpecColor.mV[0], params.mSpecColor.mV[1], params.mSpecColor.mV[2], params.mSpecColor.mV[3]);						
+						current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, params.mEnvIntensity);
+						current_shader->uniform1f(LLShaderMgr::EMISSIVE_BRIGHTNESS, params.mFullbright ? 1.f : 0.f);
+
+						if (params.mNormalMap)
+						{
+							params.mNormalMap->addTextureStats(params.mVSize);
+							current_shader->bindTexture(LLShaderMgr::BUMP_MAP, params.mNormalMap);
+						} 
 						
-						    if (params.mTextureMatrix)
-						    {
-							    tex_setup = true;
-							    gGL.getTexUnit(0)->activate();
-							    gGL.matrixMode(LLRender::MM_TEXTURE);
-							    gGL.loadMatrix((GLfloat*) params.mTextureMatrix->mMatrix);
-							    gPipeline.mTextureMatrixOps++;
-						    }
-					    }
-					    else
-					    {
-						    gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-					    }
-				    }
-
-				    {
-					    LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_PUSH);
-
-					    LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
-
-                        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_SETBUFFER);
-					        gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
-					        params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
-                        }
-
-                        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_DRAW);
-					        params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-                        }
-
-					    gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
-				    }
-				
-				    if (tex_setup)
-				    {
-					    gGL.getTexUnit(0)->activate();
-					    gGL.loadIdentity();
-					    gGL.matrixMode(LLRender::MM_MODELVIEW);
-				    }
-			    }
-		    }
-	    }
-
-        bool draw_glow_for_this_partition = mShaderLevel > 0; // no shaders = no glow.
-
-        if (use_shaders && draw_glow_for_this_partition)
-        {
-            // install glow-accumulating blend mode
-			gGL.blendFunc(LLRender::BF_ZERO, LLRender::BF_ONE, // don't touch color
-			LLRender::BF_ONE, LLRender::BF_ONE); // add to alpha (glow)
+						if (params.mSpecularMap)
+						{
+							params.mSpecularMap->addTextureStats(params.mVSize);
+							current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, params.mSpecularMap);
+						} 
+					}
+
+				} else if (LLPipeline::sRenderDeferred && current_shader && (current_shader == simple_shader))
+				{
+					current_shader->uniform4f(LLShaderMgr::SPECULAR_COLOR, 1.0f, 1.0f, 1.0f, 1.0f);						
+					current_shader->uniform1f(LLShaderMgr::ENVIRONMENT_INTENSITY, 0.0f);			
+					LLViewerFetchedTexture::sFlatNormalImagep->addTextureStats(params.mVSize);
+					current_shader->bindTexture(LLShaderMgr::BUMP_MAP, LLViewerFetchedTexture::sFlatNormalImagep);						
+					LLViewerFetchedTexture::sWhiteImagep->addTextureStats(params.mVSize);
+					current_shader->bindTexture(LLShaderMgr::SPECULAR_MAP, LLViewerFetchedTexture::sWhiteImagep);
+				}
 
-			emissive_shader->bind();
+				if (params.mGroup)
+				{
+					params.mGroup->rebuildMesh();
+				}
 
-            for (LLCullResult::sg_iterator i = gPipeline.beginAlphaGroups(); i != gPipeline.endAlphaGroups(); ++i)
-	        {
-		        LLSpatialGroup* group = *i;
-		        llassert(group);
-		        llassert(group->getSpatialPartition());
+				bool tex_setup = false;
 
-                if (group->getSpatialPartition()->mRenderByGroup &&
-		            !group->isDead())
-		        {
-			        bool is_particle_or_hud_particle = group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_PARTICLE
-													      || group->getSpatialPartition()->mPartitionType == LLViewerRegion::PARTITION_HUD_PARTICLE;
+				if (use_shaders && params.mTextureList.size() > 1)
+				{
+					for (U32 i = 0; i < params.mTextureList.size(); ++i)
+					{
+						if (params.mTextureList[i].notNull())
+						{
+							gGL.getTexUnit(i)->bind(params.mTextureList[i], TRUE);
+						}
+					}
+				}
+				else
+				{ //not batching textures or batch has only 1 texture -- might need a texture matrix
+					if (params.mTexture.notNull())
+					{
+						params.mTexture->addTextureStats(params.mVSize);
+						if (use_shaders && mat)
+						{
+							current_shader->bindTexture(LLShaderMgr::DIFFUSE_MAP, params.mTexture);
+						}
+						else
+						{
+						gGL.getTexUnit(0)->bind(params.mTexture, TRUE) ;
+						}
+						
+						if (params.mTextureMatrix)
+						{
+							tex_setup = true;
+							gGL.getTexUnit(0)->activate();
+							gGL.matrixMode(LLRender::MM_TEXTURE);
+							gGL.loadMatrix((GLfloat*) params.mTextureMatrix->mMatrix);
+							gPipeline.mTextureMatrixOps++;
+						}
+					}
+					else
+					{
+						gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+					}
+				}
 
-			
+				{
+					LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_PUSH);
 
-			        bool disable_cull = is_particle_or_hud_particle;
-			        LLGLDisable cull(disable_cull ? GL_CULL_FACE : 0);
+					LLGLEnableFunc stencil_test(GL_STENCIL_TEST, params.mSelected, &LLGLCommonFunc::selected_stencil_test);
 
-			        LLSpatialGroup::drawmap_elem_t& draw_info = group->mDrawMap[LLRenderPass::PASS_ALPHA];
+					gGL.blendFunc((LLRender::eBlendFactor) params.mBlendFuncSrc, (LLRender::eBlendFactor) params.mBlendFuncDst, mAlphaSFactor, mAlphaDFactor);
+					params.mVertexBuffer->setBuffer(mask & ~(params.mFullbright ? (LLVertexBuffer::MAP_TANGENT | LLVertexBuffer::MAP_TEXCOORD1 | LLVertexBuffer::MAP_TEXCOORD2) : 0));
 
-			        for (LLSpatialGroup::drawmap_elem_t::iterator k = draw_info.begin(); k != draw_info.end(); ++k)	
-			        {
-				        LLDrawInfo& params = **k;
+					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+					gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
+				}
+				
+				// If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
+				if (current_shader && 
+                    emissive_shader &&
+					draw_glow_for_this_partition &&
+					params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
+				{
+					// install glow-accumulating blend mode
+					gGL.blendFunc(LLRender::BF_ZERO, LLRender::BF_ONE, // don't touch color
+					LLRender::BF_ONE, LLRender::BF_ONE); // add to alpha (glow)
 
-				        if ((params.mVertexBuffer->getTypeMask() & mask) != mask)
-				        { //FIXME!
-					        LL_WARNS_ONCE() << "Missing required components, expected mask: " << mask
-									        << " present: " << (params.mVertexBuffer->getTypeMask() & mask)
-									        << ". Skipping render batch." << LL_ENDL;
-					        continue;
-				        }
+					emissive_shader->bind();
+					params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
 
-				        LLRenderPass::applyModelMatrix(params);
-				
-				        // If this alpha mesh has glow, then draw it a second time to add the destination-alpha (=glow).  Interleaving these state-changing calls could be expensive, but glow must be drawn Z-sorted with alpha.
-				        if (emissive_shader && 
-					        draw_glow_for_this_partition &&
-					        params.mVertexBuffer->hasDataType(LLVertexBuffer::TYPE_EMISSIVE))
-				        {
-                            LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_GLOW);
-
-					        params.mVertexBuffer->setBuffer((mask & ~LLVertexBuffer::MAP_COLOR) | LLVertexBuffer::MAP_EMISSIVE);
-					
-					        // do the actual drawing, again
-					        params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
-					        gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
-				        }
-			        }
-                }
-		    }
-
-            // restore our alpha blend mode
-		    gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
-
-            emissive_shader->unbind();
-	    }
-    }
+					// do the actual drawing, again
+					params.mVertexBuffer->drawRange(params.mDrawMode, params.mStart, params.mEnd, params.mCount, params.mOffset);
+					gPipeline.addTrianglesDrawn(params.mCount, params.mDrawMode);
+
+					// restore our alpha blend mode
+					gGL.blendFunc(mColorSFactor, mColorDFactor, mAlphaSFactor, mAlphaDFactor);
+
+					current_shader->bind();
+				}
+			
+				if (tex_setup)
+				{
+					gGL.getTexUnit(0)->activate();
+					gGL.loadIdentity();
+					gGL.matrixMode(LLRender::MM_MODELVIEW);
+				}
+			}
+		}
+	}
 
 	gGL.setSceneBlendType(LLRender::BT_ALPHA);
 
diff --git a/indra/newview/lldrawpoolavatar.cpp b/indra/newview/lldrawpoolavatar.cpp
index 3a083fd50d..e96e7cbe6c 100644
--- a/indra/newview/lldrawpoolavatar.cpp
+++ b/indra/newview/lldrawpoolavatar.cpp
@@ -696,6 +696,14 @@ void LLDrawPoolAvatar::beginRigid()
 		{	//eyeballs render with the specular shader
 			sVertexProgram->bind();
 			sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
+            if (LLPipeline::sRenderingHUDs)
+	        {
+		        sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	        }
+	        else
+	        {
+		        sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	        }
 		}
 	}
 	else
@@ -746,6 +754,14 @@ void LLDrawPoolAvatar::beginDeferredRigid()
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
 	sVertexProgram->bind();
 	sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
+    if (LLPipeline::sRenderingHUDs)
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 }
 
 void LLDrawPoolAvatar::endDeferredRigid()
@@ -789,6 +805,14 @@ void LLDrawPoolAvatar::beginSkinned()
 
 		sVertexProgram->bind();
 		sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 		gGL.getTexUnit(0)->activate();
 	}
 	else
@@ -798,6 +822,14 @@ void LLDrawPoolAvatar::beginSkinned()
 			// software skinning, use a basic shader for windlight.
 			// TODO: find a better fallback method for software skinning.
 			sVertexProgram->bind();
+            if (LLPipeline::sRenderingHUDs)
+	        {
+		        sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	        }
+	        else
+	        {
+		        sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	        }
 		}
 	}
 
@@ -860,6 +892,14 @@ void LLDrawPoolAvatar::beginRiggedSimple()
 	{
 		sDiffuseChannel = 0;
 		sVertexProgram->bind();
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 }
 
@@ -926,6 +966,15 @@ void LLDrawPoolAvatar::beginRiggedGlow()
 
 		sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, LLPipeline::sRenderDeferred ? 2.2f : 1.1f);
 
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
+
 		F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 		sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 	}
@@ -976,10 +1025,12 @@ void LLDrawPoolAvatar::beginRiggedFullbright()
         if (LLPipeline::sRenderingHUDs)
         {            
             sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+            sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
         }
 		else if (LLPipeline::sRenderDeferred)
 		{
             sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+            sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
 			F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 			sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
 		} 
@@ -1029,6 +1080,14 @@ void LLDrawPoolAvatar::beginRiggedShinySimple()
 	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
 	{
 		sVertexProgram->bind();
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 		LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
 	}
 }
@@ -1079,22 +1138,32 @@ void LLDrawPoolAvatar::beginRiggedFullbrightShiny()
 	if (sShaderLevel > 0 || gPipeline.canUseVertexShaders())
 	{
 		sVertexProgram->bind();
-
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 		LLDrawPoolBump::bindCubeMap(sVertexProgram, 2, sDiffuseChannel, cube_channel, false);
 
         if (LLPipeline::sRenderingHUDs)
 		{
 			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+            sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
         }
 		else if (LLPipeline::sRenderDeferred)
 		{
             sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
 			F32 gamma = gSavedSettings.getF32("RenderDeferredDisplayGamma");
 			sVertexProgram->uniform1f(LLShaderMgr::DISPLAY_GAMMA, (gamma > 0.1f) ? 1.0f / gamma : (1.0f/2.2f));
+            sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
         }
         else
         {
 			sVertexProgram->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+            sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
 		}
 	}
 }
@@ -1115,7 +1184,15 @@ void LLDrawPoolAvatar::beginDeferredRiggedSimple()
 {
 	sVertexProgram = &gDeferredSkinnedDiffuseProgram;
 	sDiffuseChannel = 0;
-	sVertexProgram->bind();    
+	sVertexProgram->bind();
+    if (LLPipeline::sRenderingHUDs)
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 }
 
 void LLDrawPoolAvatar::endDeferredRiggedSimple()
@@ -1129,6 +1206,14 @@ void LLDrawPoolAvatar::beginDeferredRiggedBump()
 {
 	sVertexProgram = &gDeferredSkinnedBumpProgram;
 	sVertexProgram->bind();
+    if (LLPipeline::sRenderingHUDs)
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
 }
@@ -1161,6 +1246,14 @@ void LLDrawPoolAvatar::beginDeferredRiggedMaterial(S32 pass)
 	}
 
 	sVertexProgram->bind();
+    if (LLPipeline::sRenderingHUDs)
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 	normal_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::BUMP_MAP);
 	specular_channel = sVertexProgram->enableTexture(LLViewerShaderMgr::SPECULAR_MAP);
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
@@ -1194,6 +1287,14 @@ void LLDrawPoolAvatar::beginDeferredSkinned()
 
 	sVertexProgram->bind();
 	sVertexProgram->setMinimumAlpha(LLDrawPoolAvatar::sMinimumAlpha);
+	if (LLPipeline::sRenderingHUDs)
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		sVertexProgram->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 
 	sDiffuseChannel = sVertexProgram->enableTexture(LLViewerShaderMgr::DIFFUSE_MAP);
 	gGL.getTexUnit(0)->activate();
diff --git a/indra/newview/lldrawpoolbump.cpp b/indra/newview/lldrawpoolbump.cpp
index 3f36fd04ae..14069fa6c2 100644
--- a/indra/newview/lldrawpoolbump.cpp
+++ b/indra/newview/lldrawpoolbump.cpp
@@ -351,6 +351,14 @@ void LLDrawPoolBump::beginShiny(bool invisible)
 			shader = &gObjectShinyProgram;
 		}
 		shader->bind();
+        if (LLPipeline::sRenderingHUDs)
+        {
+            shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+        }
+        else
+        {
+            shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+        }
 	}
 	else
 	{
@@ -534,6 +542,14 @@ void LLDrawPoolBump::beginFullbrightShiny()
 					 LLVector4(gGLModelView+8),
 					 LLVector4(gGLModelView+12));
 		shader->bind();
+        if (LLPipeline::sRenderingHUDs)
+        {
+            shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+        }
+        else
+        {
+            shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+        }
 
 		LLVector3 vec = LLVector3(gShinyOrigin) * mat;
 		LLVector4 vec4(vec, gShinyOrigin.mV[3]);
diff --git a/indra/newview/lldrawpoolmaterials.cpp b/indra/newview/lldrawpoolmaterials.cpp
index a9e948c16a..05b0c1f1a9 100644
--- a/indra/newview/lldrawpoolmaterials.cpp
+++ b/indra/newview/lldrawpoolmaterials.cpp
@@ -81,6 +81,15 @@ void LLDrawPoolMaterials::beginDeferredPass(S32 pass)
 
 	mShader->bind();
 
+    if (LLPipeline::sRenderingHUDs)
+    {
+        mShader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+    }
+    else
+    {
+        mShader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+    }
+
 	diffuse_channel = mShader->enableTexture(LLShaderMgr::DIFFUSE_MAP);
 		
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_MATERIALS);
diff --git a/indra/newview/lldrawpoolsimple.cpp b/indra/newview/lldrawpoolsimple.cpp
index 606e44185f..f653920662 100644
--- a/indra/newview/lldrawpoolsimple.cpp
+++ b/indra/newview/lldrawpoolsimple.cpp
@@ -47,6 +47,14 @@ void LLDrawPoolGlow::beginPostDeferredPass(S32 pass)
 {
 	gDeferredEmissiveProgram.bind();
 	gDeferredEmissiveProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+    if (LLPipeline::sRenderingHUDs)
+	{
+		gDeferredEmissiveProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		gDeferredEmissiveProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 }
 
 static LLTrace::BlockTimerStatHandle FTM_RENDER_GLOW_PUSH("Glow Push");
@@ -119,6 +127,15 @@ void LLDrawPoolGlow::render(S32 pass)
 		shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.f);
 	}	
 
+    if (LLPipeline::sRenderingHUDs)
+	{
+		shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
+
 	LLGLDepthTest depth(GL_TRUE, GL_FALSE);
 	gGL.setColorMask(false, true);
 
@@ -170,6 +187,15 @@ void LLDrawPoolSimple::beginRenderPass(S32 pass)
 	if (mShaderLevel > 0)
 	{
 		simple_shader->bind();
+
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 	else 
 	{
@@ -263,6 +289,15 @@ void LLDrawPoolAlphaMask::beginRenderPass(S32 pass)
 	if (mShaderLevel > 0)
 	{
 		simple_shader->bind();
+
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 	else 
 	{
@@ -296,6 +331,15 @@ void LLDrawPoolAlphaMask::render(S32 pass)
 		simple_shader->bind();
 		simple_shader->setMinimumAlpha(0.33f);
 
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
+
 		pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 		pushMaskBatches(LLRenderPass::PASS_MATERIAL_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 		pushMaskBatches(LLRenderPass::PASS_SPECMAP_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
@@ -336,6 +380,15 @@ void LLDrawPoolFullbrightAlphaMask::beginRenderPass(S32 pass)
 	if (mShaderLevel > 0)
 	{
 		simple_shader->bind();
+
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 	else 
 	{
@@ -372,10 +425,12 @@ void LLDrawPoolFullbrightAlphaMask::render(S32 pass)
 
             if (LLPipeline::sRenderingHUDs)
 	        {
+		        simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
                 simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
 	        }
 	        else
 	        {
+		        simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
                 if (LLPipeline::sRenderDeferred)
 			    {
                     simple_shader->uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);				    
@@ -407,6 +462,15 @@ void LLDrawPoolSimple::beginDeferredPass(S32 pass)
 {
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_SIMPLE_DEFERRED);
 	gDeferredDiffuseProgram.bind();
+
+    if (LLPipeline::sRenderingHUDs)
+	{
+		gDeferredDiffuseProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		gDeferredDiffuseProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
 }
 
 void LLDrawPoolSimple::endDeferredPass(S32 pass)
@@ -445,6 +509,16 @@ void LLDrawPoolAlphaMask::renderDeferred(S32 pass)
 	LL_RECORD_BLOCK_TIME(FTM_RENDER_ALPHA_MASK_DEFERRED);
 	gDeferredDiffuseAlphaMaskProgram.bind();
 	gDeferredDiffuseAlphaMaskProgram.setMinimumAlpha(0.33f);
+
+    if (LLPipeline::sRenderingHUDs)
+	{
+		gDeferredDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
+	}
+	else
+	{
+		gDeferredDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+	}
+
 	pushMaskBatches(LLRenderPass::PASS_ALPHA_MASK, getVertexDataMask() | LLVertexBuffer::MAP_TEXTURE_INDEX, TRUE, TRUE);
 	gDeferredDiffuseAlphaMaskProgram.unbind();			
 }
@@ -481,6 +555,14 @@ void LLDrawPoolGrass::beginRenderPass(S32 pass)
 	{
 		simple_shader->bind();
 		simple_shader->setMinimumAlpha(0.5f);
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    simple_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 	else 
 	{
@@ -537,7 +619,16 @@ void LLDrawPoolGrass::renderDeferred(S32 pass)
 		LL_RECORD_BLOCK_TIME(FTM_RENDER_GRASS_DEFERRED);
 		gDeferredNonIndexedDiffuseAlphaMaskProgram.bind();
 		gDeferredNonIndexedDiffuseAlphaMaskProgram.setMinimumAlpha(0.5f);
-        gDeferredNonIndexedDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    gDeferredNonIndexedDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    gDeferredNonIndexedDiffuseAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
+
 		//render grass
 		LLRenderPass::renderTexture(LLRenderPass::PASS_GRASS, getVertexDataMask());
 	}			
@@ -564,6 +655,15 @@ void LLDrawPoolFullbright::beginPostDeferredPass(S32 pass)
 	else
 	{
 		gDeferredFullbrightProgram.bind();
+
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    gDeferredFullbrightProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    gDeferredFullbrightProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
 	}
 	
 }
@@ -632,6 +732,15 @@ void LLDrawPoolFullbright::render(S32 pass)
 		fullbright_shader->uniform1f(LLViewerShaderMgr::FULLBRIGHT, 1.f);
 		fullbright_shader->uniform1f(LLViewerShaderMgr::TEXTURE_GAMMA, 1.f);
 
+        if (LLPipeline::sRenderingHUDs)
+	    {
+		    fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 1);
+	    }
+	    else
+	    {
+		    fullbright_shader->uniform1i(LLShaderMgr::NO_ATMO, 0);
+	    }
+
 		U32 fullbright_mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_COLOR | LLVertexBuffer::MAP_TEXTURE_INDEX;
 		pushBatches(LLRenderPass::PASS_FULLBRIGHT, fullbright_mask, TRUE, TRUE);
 		pushBatches(LLRenderPass::PASS_MATERIAL_ALPHA_EMISSIVE, fullbright_mask, TRUE, TRUE);
@@ -666,6 +775,7 @@ void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
     {
         gObjectFullbrightAlphaMaskProgram.bind();
 		gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+        gObjectFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
     }
 	else if (LLPipeline::sRenderDeferred)
 	{
@@ -673,17 +783,20 @@ void LLDrawPoolFullbrightAlphaMask::beginPostDeferredPass(S32 pass)
 		{
 			gDeferredFullbrightAlphaMaskWaterProgram.bind();
 			gDeferredFullbrightAlphaMaskWaterProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+            gDeferredFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 1);
 		}
 		else
 		{
 			gDeferredFullbrightAlphaMaskProgram.bind();
 			gDeferredFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 2.2f);
+            gDeferredFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
 		}
     }
     else
     {
 		gObjectFullbrightAlphaMaskProgram.bind();
 		gObjectFullbrightAlphaMaskProgram.uniform1f(LLShaderMgr::TEXTURE_GAMMA, 1.0f);
+        gObjectFullbrightAlphaMaskProgram.uniform1i(LLShaderMgr::NO_ATMO, 0);
 	}
 }
 
diff --git a/indra/newview/lldrawpoolwater.cpp b/indra/newview/lldrawpoolwater.cpp
index abda2d45fb..5760a28049 100644
--- a/indra/newview/lldrawpoolwater.cpp
+++ b/indra/newview/lldrawpoolwater.cpp
@@ -634,7 +634,7 @@ void LLDrawPoolWater::shade2(bool edge, LLGLSLShader* shader, const LLColor3& li
                         bool edge_patch = water->getIsEdgePatch();
                         if (edge_patch)
                         {
-                            //sNeedsReflectionUpdate = TRUE;
+                            sNeedsReflectionUpdate = TRUE;
                             face->renderIndexed();
                         }
                     }
diff --git a/indra/newview/llviewershadermgr.cpp b/indra/newview/llviewershadermgr.cpp
index 1f5778db61..26254bd8a3 100644
--- a/indra/newview/llviewershadermgr.cpp
+++ b/indra/newview/llviewershadermgr.cpp
@@ -1979,7 +1979,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredWaterProgram.mFeatures.hasGamma = true;
         gDeferredWaterProgram.mFeatures.hasTransport = true;
         gDeferredWaterProgram.mFeatures.encodesNormal = true;
-        gDeferredWaterProgram.mFeatures.hasShadows = true;
+        //gDeferredWaterProgram.mFeatures.hasShadows = true;
 
         gDeferredWaterProgram.mShaderFiles.clear();
         gDeferredWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER_ARB));
@@ -2000,7 +2000,7 @@ BOOL LLViewerShaderMgr::loadShadersDeferred()
         gDeferredUnderWaterProgram.mFeatures.hasTransport = true;
         gDeferredUnderWaterProgram.mFeatures.hasSrgb = true;
         gDeferredUnderWaterProgram.mFeatures.encodesNormal = true;
-        gDeferredUnderWaterProgram.mFeatures.hasShadows = true;
+        //gDeferredUnderWaterProgram.mFeatures.hasShadows = true;
 
         gDeferredUnderWaterProgram.mShaderFiles.clear();
         gDeferredUnderWaterProgram.mShaderFiles.push_back(make_pair("deferred/waterV.glsl", GL_VERTEX_SHADER_ARB));
diff --git a/indra/newview/pipeline.cpp b/indra/newview/pipeline.cpp
index 7e8e401470..c81d66527f 100644
--- a/indra/newview/pipeline.cpp
+++ b/indra/newview/pipeline.cpp
@@ -882,7 +882,6 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
 
     if (LLPipeline::sRenderDeferred)
     {
-        U32 water_buffer_res = (U32) llmax(gSavedSettings.getS32("RenderWaterRefResolution"), 512);
         S32 shadow_detail = RenderShadowDetail;
         bool ssao = RenderDeferredSSAO;
         
@@ -894,16 +893,6 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
         if (!mOcclusionDepth.allocate(resX/occlusion_divisor, resY/occlusion_divisor, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
         if (!addDeferredAttachments(mDeferredScreen)) return false;
 
-        bool materials_in_water = gSavedSettings.getS32("RenderWaterMaterials");
-
-        if(materials_in_water)
-        {
-            if (!mWaterDeferredScreen.allocate(water_buffer_res, water_buffer_res, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
-            if (!mWaterDeferredDepth.allocate(water_buffer_res,  water_buffer_res, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
-            if (!mWaterOcclusionDepth.allocate(water_buffer_res >> 1, water_buffer_res >> 1, 0, TRUE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE, samples)) return false;
-            if (!addDeferredAttachments(mWaterDeferredScreen)) return false;
-        }
-
         GLuint screenFormat = GL_RGBA16;
         if (gGLManager.mIsATI)
         {
@@ -928,12 +917,10 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
         if (shadow_detail > 0 || ssao || RenderDepthOfField || samples > 0)
         { //only need mDeferredLight for shadows OR ssao OR dof OR fxaa
             if (!mDeferredLight.allocate(resX, resY, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;
-            if (!mWaterDeferredLight.allocate(water_buffer_res, water_buffer_res, GL_RGBA, FALSE, FALSE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;
         }
         else
         {
             mDeferredLight.release();
-            mWaterDeferredLight.release();
         }
 
         F32 scale = RenderShadowResolutionScale;
@@ -1011,7 +998,6 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
     else
     {
         mDeferredLight.release();
-        mWaterDeferredLight.release();
 
         releaseShadowTargets();
 
@@ -1019,9 +1005,6 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
         mScreen.release();
         mDeferredScreen.release(); //make sure to release any render targets that share a depth buffer with mDeferredScreen first
         mDeferredDepth.release();
-        mWaterDeferredScreen.release(); //make sure to release any render targets that share a depth buffer with mWaterDeferredScreen first
-        mWaterDeferredDepth.release();
-        mWaterOcclusionDepth.release();
         mOcclusionDepth.release();
                         
         if (!mScreen.allocate(resX, resY, GL_RGBA, TRUE, TRUE, LLTexUnit::TT_RECT_TEXTURE, FALSE)) return false;        
@@ -1210,11 +1193,7 @@ void LLPipeline::releaseScreenBuffers()
     mPhysicsDisplay.release();
     mDeferredScreen.release();
     mDeferredDepth.release();
-    mWaterDeferredScreen.release();
-    mWaterDeferredDepth.release();
     mDeferredLight.release();
-    mWaterDeferredLight.release();
-    mWaterOcclusionDepth.release();
     mOcclusionDepth.release();
     releaseShadowTargets();
 }
@@ -2402,11 +2381,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
 
     if (to_texture)
     {
-        if (LLPipeline::sRenderDeferred && LLPipeline::sReflectionRender)
-        {
-            mWaterOcclusionDepth.bindTarget();
-        }
-        else if (LLPipeline::sRenderDeferred)
+        if (LLPipeline::sRenderDeferred && can_use_occlusion)
         {
             mOcclusionDepth.bindTarget();
         }
@@ -2545,11 +2520,7 @@ void LLPipeline::updateCull(LLCamera& camera, LLCullResult& result, S32 water_cl
 
     if (to_texture)
     {
-        if (LLPipeline::sRenderDeferred && LLPipeline::sReflectionRender)    
-        {
-            mWaterOcclusionDepth.flush();
-        }
-        else if (LLPipeline::sRenderDeferred)
+        if (LLPipeline::sRenderDeferred && can_use_occlusion)
         {
             mOcclusionDepth.flush();
         }
@@ -4730,7 +4701,7 @@ void LLPipeline::renderGeomPostDeferred(LLCamera& camera, bool do_occlusion)
             gGL.loadMatrix(gGLModelView);
             LLGLSLShader::bindNoShader();
 
-            doOcclusion(camera, mScreen, sReflectionRender ? mWaterOcclusionDepth : mOcclusionDepth, sReflectionRender ? &mWaterDeferredDepth : &mDeferredDepth);
+            doOcclusion(camera, mScreen, mOcclusionDepth, &mDeferredDepth);
             gGL.setColorMask(true, false);
         }
 
@@ -7552,7 +7523,7 @@ static LLTrace::BlockTimerStatHandle FTM_RENDER_BLOOM("Bloom");
 
 void LLPipeline::renderBloom(bool for_snapshot, F32 zoom_factor, int subfield)
 {
-    LLRenderTarget* deferred_light_target = LLPipeline::sReflectionRender ? &mWaterDeferredLight : &mDeferredLight;
+    LLRenderTarget* deferred_light_target = &mDeferredLight;
 
     if (!(gPipeline.canUseVertexShaders() &&
         sRenderGlow))
@@ -8211,9 +8182,9 @@ void LLPipeline::bindDeferredShader(LLGLSLShader& shader, LLRenderTarget* light_
 {
     LL_RECORD_BLOCK_TIME(FTM_BIND_DEFERRED);
 
-    LLRenderTarget* deferred_target       = LLPipeline::sReflectionRender ? &mWaterDeferredScreen : &mDeferredScreen;
-    LLRenderTarget* deferred_depth_target = LLPipeline::sReflectionRender ? &mWaterDeferredDepth  : &mDeferredDepth;
-    LLRenderTarget* deferred_light_target = LLPipeline::sReflectionRender ? &mWaterDeferredLight  : &mDeferredLight;
+    LLRenderTarget* deferred_target       = &mDeferredScreen;
+    LLRenderTarget* deferred_depth_target = &mDeferredDepth;
+    LLRenderTarget* deferred_light_target = &mDeferredLight;
 
     shader.bind();
     S32 channel = 0;
@@ -8491,9 +8462,9 @@ void LLPipeline::renderDeferredLighting(LLRenderTarget* screen_target)
         return;
     }
 
-    LLRenderTarget* deferred_target       = LLPipeline::sReflectionRender ? &mWaterDeferredScreen : &mDeferredScreen;
-    LLRenderTarget* deferred_depth_target = LLPipeline::sReflectionRender ? &mWaterDeferredDepth  : &mDeferredDepth;
-    LLRenderTarget* deferred_light_target = LLPipeline::sReflectionRender ? &mWaterDeferredLight  : &mDeferredLight;
+    LLRenderTarget* deferred_target       = &mDeferredScreen;
+    LLRenderTarget* deferred_depth_target = &mDeferredDepth;
+    LLRenderTarget* deferred_light_target = &mDeferredLight;
 
     {
         LL_RECORD_BLOCK_TIME(FTM_RENDER_DEFERRED);
@@ -9251,9 +9222,9 @@ void LLPipeline::setupSpotLight(LLGLSLShader& shader, LLDrawable* drawablep)
 
 void LLPipeline::unbindDeferredShader(LLGLSLShader &shader)
 {
-    LLRenderTarget* deferred_target       = LLPipeline::sReflectionRender ? &mWaterDeferredScreen : &mDeferredScreen;
-    LLRenderTarget* deferred_depth_target = LLPipeline::sReflectionRender ? &mWaterDeferredDepth  : &mDeferredDepth;
-    LLRenderTarget* deferred_light_target = LLPipeline::sReflectionRender ? &mWaterDeferredLight : &mDeferredLight;
+    LLRenderTarget* deferred_target       = &mDeferredScreen;
+    LLRenderTarget* deferred_depth_target = &mDeferredDepth;
+    LLRenderTarget* deferred_light_target = &mDeferredLight;
 
     stop_glerror();
     shader.disableTexture(LLShaderMgr::DEFERRED_NORMAL, deferred_target->getUsage());
@@ -9308,8 +9279,6 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
 {
     if (LLPipeline::sWaterReflections && assertInitialized() && LLDrawPoolWater::sNeedsReflectionUpdate)
     {
-        LLPlane restore_plane = LLViewerCamera::getInstance()->getUserClipPlane();
-
         bool skip_avatar_update = false;
         if (!isAgentAvatarValid() || gAgentCamera.getCameraAnimating() || gAgentCamera.getCameraMode() != CAMERA_MODE_MOUSELOOK || !LLVOAvatar::sVisibleInFirstPerson)
         {
@@ -9329,6 +9298,8 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
         LLCamera camera = camera_in;
         camera.setFar(camera.getFar()*0.87654321f);
 
+        bool camera_is_underwater = LLViewerCamera::getInstance()->cameraUnderWater();
+
         LLPipeline::sReflectionRender = true;       
 
         gPipeline.pushRenderTypeMask();
@@ -9337,7 +9308,6 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
         glh::matrix4f mat;
 
         S32 detail = RenderReflectionDetail;
-        bool materials_in_water = LLPipeline::sRenderDeferred && gSavedSettings.getS32("RenderWaterMaterials");
 
         F32 water_height      = gAgent.getRegion()->getWaterHeight(); 
         F32 camera_height     = camera_in.getOrigin().mV[2];
@@ -9355,7 +9325,7 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
         LLPlane plane;
         LLVector3 pnorm;
         S32 water_clip = 0;
-        if (!LLViewerCamera::getInstance()->cameraUnderWater())
+        if (!camera_is_underwater)
         { //camera is above water, clip plane points up
             pnorm.setVec(0,0,1);
             plane.setVec(pnorm, -water_height);
@@ -9370,24 +9340,13 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
 
         S32 occlusion = LLPipeline::sUseOcclusion;
 
+        //disable occlusion culling for reflection map for now
         LLPipeline::sUseOcclusion = 0;
 
         if (!LLViewerCamera::getInstance()->cameraUnderWater())
         {   //generate planar reflection map
-            //disable occlusion culling for reflection map for now
-            gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-            glClearColor(0,0,0,0);
-
-            mWaterRef.bindTarget();
-
+            
             LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WATER0;
-            gGL.setColorMask(true, true);
-            mWaterRef.clear();
-            gGL.setColorMask(true, false);
-
-            mWaterRef.getViewport(gGLViewport);
-
-            stop_glerror();
 
             gGL.matrixMode(LLRender::MM_MODELVIEW);
             gGL.pushMatrix();
@@ -9395,7 +9354,7 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
             glh::matrix4f current = get_current_modelview();
 
             glh::matrix4f mat;
-            camera.getOpenGLTransform(mat.m);            
+            camera.getOpenGLTransform(mat.m);
 
             glh::matrix4f scal;
             scal.set_scale(glh::vec3f(1, 1, -1));
@@ -9415,6 +9374,15 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
 
             if (LLDrawPoolWater::sNeedsReflectionUpdate)
             {
+                gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
+                glClearColor(0,0,0,0);
+                mWaterRef.bindTarget();
+
+                gGL.setColorMask(true, true);
+                mWaterRef.clear();
+                gGL.setColorMask(true, false);
+                mWaterRef.getViewport(gGLViewport);
+
                 //initial sky pass (no user clip plane)
                 { //mask out everything but the sky
                     gPipeline.pushRenderTypeMask();
@@ -9423,32 +9391,15 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
                         LLPipeline::RENDER_TYPE_CLOUDS,
                         LLPipeline::END_RENDER_TYPES);
 
-                    gGL.setColorMask(true, true);
-                    glClearColor(0,0,0,0);
-
                     updateCull(camera, mSky);
                     stateSort(camera, mSky);
                     gPipeline.grabReferences(mSky);
 
-                    if (materials_in_water)
-                    {
-                        gPipeline.mWaterDeferredDepth.bindTarget();
-                        gPipeline.mWaterDeferredDepth.clear();
-                        gPipeline.mWaterDeferredScreen.bindTarget();
-                        gPipeline.mWaterDeferredScreen.clear();
-                        renderGeomDeferred(camera);
-                        renderGeomPostDeferred(camera);
-                    }
-                    else
-                    {
-                        renderGeom(camera, TRUE);
-                    }                   
+                    renderGeom(camera, TRUE);
 
                     gPipeline.popRenderTypeMask();
                 }
 
-                gGL.setColorMask(true, false);
-
                 gPipeline.pushRenderTypeMask();
 
                 clearRenderTypeMask(LLPipeline::RENDER_TYPE_WATER,
@@ -9473,64 +9424,39 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
                         }
                     }
 
+                    LLGLUserClipPlane clip_plane(plane, mat, projection);
+                    LLGLDisable cull(GL_CULL_FACE);
+                    updateCull(camera, mReflectedObjects, -water_clip, &plane);
+                    stateSort(camera, mReflectedObjects);
+                    gPipeline.grabReferences(mReflectedObjects);                
+                    renderGeom(camera);
                     
-                }   
-
-                if (LLDrawPoolWater::sNeedsDistortionUpdate)
-                {
-                    if (detail > 0)
-                    {
-                        LLGLDisable cull(GL_CULL_FACE);
-                        LLGLUserClipPlane clip_plane(plane, mat, projection);
-
-                        updateCull(camera, mReflectedObjects);
-                        stateSort(camera, mReflectedObjects);
-                        gPipeline.grabReferences(mReflectedObjects);
-
-                        if (materials_in_water)
-                        {                           
-                            renderGeomDeferred(camera);
-                            renderGeomPostDeferred(camera);
-                            gPipeline.mWaterDeferredScreen.flush();
-                            gPipeline.mWaterDeferredDepth.flush();
-                            mWaterRef.copyContents(gPipeline.mWaterDeferredScreen, 0, 0, gPipeline.mWaterDeferredScreen.getWidth(), gPipeline.mWaterDeferredScreen.getHeight(),
-                                0, 0, gPipeline.mWaterRef.getWidth(), gPipeline.mWaterRef.getHeight(), GL_COLOR_BUFFER_BIT, GL_NEAREST);    
-                        }
-                        else
-                        {
-                            renderGeom(camera);
-                        }
-                    }   
-                }   
-
+                }
                 gPipeline.popRenderTypeMask();
+                mWaterRef.flush();
             }   
 
             glCullFace(GL_BACK);
             gGL.matrixMode(LLRender::MM_MODELVIEW);
             gGL.popMatrix();
-            mWaterRef.flush();
+            
             set_current_modelview(current);         
         }
 
-        // SL-10566 re-enable occlusion for refracted object set
-        // this bloated the scene by 3k calls when disabled
-        LLPipeline::sUseOcclusion = occlusion;
+        //LLPipeline::sUseOcclusion = occlusion;
 
         camera.setOrigin(camera_in.getOrigin());
-
         //render distortion map
         static bool last_update = true;
-
         if (last_update)
         {
+            gPipeline.pushRenderTypeMask();
+
             camera.setFar(camera_in.getFar());
             clearRenderTypeMask(LLPipeline::RENDER_TYPE_WATER,
                                 LLPipeline::RENDER_TYPE_VOIDWATER,
                                 LLPipeline::RENDER_TYPE_GROUND,
                                 END_RENDER_TYPES);  
-            stop_glerror();
-
             
             bool camera_is_underwater = LLViewerCamera::getInstance()->cameraUnderWater();
 
@@ -9549,29 +9475,29 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
 
             gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
             
-            if (!LLPipeline::sUnderWaterRender || LLDrawPoolWater::sNeedsDistortionUpdate)
+            if (LLPipeline::sUnderWaterRender || LLDrawPoolWater::sNeedsDistortionUpdate)
             {
                 LLPipeline::sDistortionRender = true;
 
                 LLColor3 col = LLEnvironment::instance().getCurrentWater()->getWaterFogColor();
                 glClearColor(col.mV[0], col.mV[1], col.mV[2], 0.f);
-                mWaterDis.bindTarget();
+
                 LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WATER1;
-            
+
+                mWaterDis.bindTarget();
                 mWaterDis.getViewport(gGLViewport);
 
                 //clip out geometry on the same side of water as the camera w/ enough margin to not include the water geo itself,
                 // but not so much as to clip out parts of avatars that should be seen under the water in the distortion map
                 LLPlane plane(pnorm, -water_height * LLPipeline::sDistortionWaterClipPlaneMargin);
-                mat = get_current_modelview();
-                LLGLUserClipPlane clip_plane(plane, mat, projection);
+                LLGLUserClipPlane clip_plane(plane, mReflectionModelView, projection);
 
                 gGL.setColorMask(true, true);
                 mWaterDis.clear();
                 gGL.setColorMask(true, false);
 
                 // ignore clip plane if we're underwater and viewing distortion map of objects above waterline
-                if (camera_is_underwater && materials_in_water)
+                if (camera_is_underwater)
                 {
                     clip_plane.disable();
                 }
@@ -9580,65 +9506,45 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
                 stateSort(camera, mRefractedObjects);
                 gPipeline.grabReferences(mRefractedObjects);
 
-                if (materials_in_water)
+                renderGeom(camera);
+
+                if (LLGLSLShader::sNoFixedFunction)
                 {
-                    mWaterDis.flush();
-                    gGL.setColorMask(true, true);
-                    glClearColor(col.mV[0], col.mV[1], col.mV[2], 0.f);
-                    gPipeline.mWaterDeferredDepth.bindTarget();
-                    gPipeline.mWaterDeferredDepth.clear();
-                    gPipeline.mWaterDeferredScreen.bindTarget();
-                    gPipeline.mWaterDeferredScreen.clear();
-                    gGL.setColorMask(true, false);
-                    renderGeomDeferred(camera);
-                    renderGeomPostDeferred(camera);
+                    gUIProgram.bind();
                 }
-                else
-                {
-                    renderGeom(camera);
-
-                    if (LLGLSLShader::sNoFixedFunction)
-                    {
-                        gUIProgram.bind();
-                    }
                     
-                    LLWorld::getInstance()->renderPropertyLines();
+                LLWorld::getInstance()->renderPropertyLines();
                     
-                    if (LLGLSLShader::sNoFixedFunction)
-                    {
-                        gUIProgram.unbind();
-                    }
-                }
-
-                if (materials_in_water)
+                if (LLGLSLShader::sNoFixedFunction)
                 {
-                    gPipeline.mWaterDeferredScreen.flush();
-                    gPipeline.mWaterDeferredDepth.flush();
-                    mWaterDis.copyContents(gPipeline.mWaterDeferredScreen, 0, 0, gPipeline.mWaterDeferredScreen.getWidth(), gPipeline.mWaterDeferredScreen.getHeight(),
-                            0, 0, gPipeline.mWaterDis.getWidth(), gPipeline.mWaterDis.getHeight(), GL_COLOR_BUFFER_BIT, GL_NEAREST);    
+                    gUIProgram.unbind();
                 }
+
                 mWaterDis.flush();
             }
 
             LLPipeline::sDistortionRender = false;
+
+            gPipeline.popRenderTypeMask();
         }
         last_update = LLDrawPoolWater::sNeedsReflectionUpdate && LLDrawPoolWater::sNeedsDistortionUpdate;
 
-        LLPipeline::sUseOcclusion = occlusion;
+        gPipeline.popRenderTypeMask();
 
+        LLPipeline::sUseOcclusion     = occlusion;
         LLPipeline::sUnderWaterRender = false;
         LLPipeline::sReflectionRender = false;
 
+        LLDrawPoolWater::sNeedsReflectionUpdate = FALSE;
+        LLDrawPoolWater::sNeedsDistortionUpdate = FALSE;
+
         if (!LLRenderTarget::sUseFBO)
         {
             glClear(GL_DEPTH_BUFFER_BIT);
         }
         glClearColor(0.f, 0.f, 0.f, 0.f);
         gViewerWindow->setup3DViewport();
-        gPipeline.popRenderTypeMask();
-        LLDrawPoolWater::sNeedsReflectionUpdate = FALSE;
-        LLDrawPoolWater::sNeedsDistortionUpdate = FALSE;
-        
+
         LLGLState::checkStates();
 
         if (!skip_avatar_update)
@@ -9647,8 +9553,6 @@ void LLPipeline::generateWaterReflection(LLCamera& camera_in)
         }
 
         LLViewerCamera::sCurCameraID = LLViewerCamera::CAMERA_WORLD;
-
-		LLViewerCamera::getInstance()->setUserClipPlane(restore_plane);
     }
 }
 
diff --git a/indra/newview/pipeline.h b/indra/newview/pipeline.h
index c41fd0189c..e38655f44d 100644
--- a/indra/newview/pipeline.h
+++ b/indra/newview/pipeline.h
@@ -645,10 +645,7 @@ public:
 
 	//water reflection texture
 	LLRenderTarget				mWaterRef;
-    LLRenderTarget				mWaterDeferredScreen;
-    LLRenderTarget				mWaterDeferredDepth;
-    LLRenderTarget				mWaterOcclusionDepth;
-    LLRenderTarget			    mWaterDeferredLight;
+
 	//water distortion texture (refraction)
 	LLRenderTarget				mWaterDis;