WIP - Make EEP match production.

7 files changed, 262 insertions, 312 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
index 46ec20c8b0..57420158ca 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightF.glsl
@@ -79,8 +79,6 @@ void main()
 	color.rgb = fogged.rgb;
 	color.a   = fogged.a;
 #else
-    color.rgb = fullbrightAtmosTransport(color.rgb);
-	color.rgb = fullbrightScaleSoftClip(color.rgb);
     color.a   = final_alpha;
 #endif
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
index 523e7f9e04..af903eeda8 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/fullbrightShinyF.glsl
@@ -51,12 +51,12 @@ void main()
 #else
 	vec4 color = texture2D(diffuseMap, vary_texcoord0.xy);
 #endif
-
+	
 	
 	color.rgb *= vertex_color.rgb;
 	
 	vec3 envColor = textureCube(environmentMap, vary_texcoord1.xyz).rgb;	
-	color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a*0.75); // MAGIC NUMBER SL-12574; ALM: Off, Quality > Low
+	color.rgb = mix(color.rgb, envColor.rgb, vertex_color.a);
 
 	color.rgb = pow(color.rgb,vec3(2.2f,2.2f,2.2f));
 	
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index a8a5cc22db..85d664ea1f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -216,98 +216,63 @@ void main()
 {
     vec2 pos_screen = vary_texcoord0.xy;
 
-    vec4 diffuse_srgb = texture2D(diffuseMap, vary_texcoord0.xy);
-    diffuse_srgb.rgb *= vertex_color.rgb;
-    
-    // For some reason the Transparency slider sets vertex_color.a to 0.0 both for
-    // fully opaque and for fully transparent objects. This code assumes the 0 alpha
-    // is always from the opaque end of the scale. TODO: Remove the conditional once
-    // the root cause of the slider ambiguity is fixed.
-    if (vertex_color.a > 0.0)
-    {
-        diffuse_srgb.a *= vertex_color.a;
-    }
-    vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
+    vec4 diffcol = texture2D(diffuseMap, vary_texcoord0.xy);
+	diffcol.rgb *= vertex_color.rgb;
 
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_MASK)
-    if (diffuse_linear.a < minimum_alpha)
+    if (diffcol.a < minimum_alpha)
     {
         discard;
     }
 #endif
 
-#ifdef HAS_SPECULAR_MAP
+#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
+	vec3 gamma_diff = diffcol.rgb;
+	diffcol.rgb = srgb_to_linear(diffcol.rgb);
+#endif
+
+#if HAS_SPECULAR_MAP != 0
     vec4 spec = texture2D(specularMap, vary_texcoord2.xy);
     spec.rgb *= specular_color.rgb;
 #else
     vec4 spec = vec4(specular_color.rgb, 1.0);
 #endif
 
-    vec3 norm = vec3(0);
-    float bmap_specular = 1.0;
+#if HAS_NORMAL_MAP
+	vec4 norm = texture2D(bumpMap, vary_texcoord1.xy);
 
-#ifdef HAS_NORMAL_MAP
-    vec4 bump_sample = texture2D(bumpMap, vary_texcoord1.xy);
-    norm = (bump_sample.xyz * 2) - vec3(1);
-    bmap_specular = bump_sample.w;
-
-    // convert sampled normal to tangent space normal
-    norm = vec3(dot(norm, vary_mat0),
-        dot(norm, vary_mat1),
-        dot(norm, vary_mat2));
+	norm.xyz = norm.xyz * 2 - 1;
+
+	vec3 tnorm = vec3(dot(norm.xyz,vary_mat0),
+			  dot(norm.xyz,vary_mat1),
+			  dot(norm.xyz,vary_mat2));
 #else
-    norm = vary_normal;
+	vec4 norm = vec4(0,0,0,1.0);
+	vec3 tnorm = vary_normal;
 #endif
 
-    norm = normalize(norm);
-
-    vec2 abnormal = encode_normal(norm);
+    norm.xyz = normalize(tnorm.xyz);
 
-    vec4 final_color = vec4(diffuse_linear.rgb, 0.0);
-
-#if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_EMISSIVE)
-    final_color.a = diffuse_linear.a * 0.5; // SL-12171
-#endif
+    vec2 abnormal = encode_normal(norm.xyz);
 
-    final_color.a = max(final_color.a, emissive_brightness);
-
-    // Texture
-    //     [x] Full Bright (emissive_brightness >= 1.0)
-    //     Shininess (specular)
-    //       [X] Texture
-    //       Environment Intensity = 1
-    // NOTE: There are two shaders that are used depending on the EI byte value:
-    //     EI = 0        fullbright
-    //     EI > 0 .. 255 material
-    // When it is passed to us it is normalized.
-    // We can either modify the output environment intensity
-    //   OR
-    // adjust the final color via:
-    //     final_color *= 0.666666;
-    // We don't remap the environment intensity but adjust the final color to closely simulate what non-EEP is doing.
-    vec4 final_normal = vec4(abnormal, env_intensity, 0.0);
-
-    vec3 color = vec3(0.0);
-    float al = 0;
+    vec4 final_color = diffcol;
 
-#ifdef HAS_SPECULAR_MAP
-    if (emissive_brightness >= 1.0) // ie, if fullbright
-    {
-        float ei = env_intensity*0.5 + 0.5;
-        final_normal = vec4(abnormal, ei, 0.0);
-    }
+#if (DIFFUSE_ALPHA_MODE != DIFFUSE_ALPHA_MODE_EMISSIVE)
+	final_color.a = emissive_brightness;
+#else
+	final_color.a = max(final_color.a, emissive_brightness);
 #endif
 
     vec4 final_specular = spec;
-
-    final_specular.a = specular_color.a;
-
-#ifdef HAS_SPECULAR_MAP
-    final_specular.a *= bmap_specular;
-    final_normal.z *= spec.a;
+    
+#if HAS_SPECULAR_MAP != 0
+    vec4 final_normal = vec4(encode_normal(normalize(tnorm)), env_intensity * spec.a, 0.0);
+	final_specular.a = specular_color.a * norm.a;
+#else
+	vec4 final_normal = vec4(encode_normal(normalize(tnorm)), env_intensity, 0.0);
+	final_specular.a = specular_color.a;
 #endif
 
-
 #if (DIFFUSE_ALPHA_MODE == DIFFUSE_ALPHA_MODE_BLEND)
 
     //forward rendering, output just lit sRGBA
@@ -316,13 +281,15 @@ void main()
     float shadow = 1.0f;
 
 #ifdef HAS_SUN_SHADOW
-    shadow = sampleDirectionalShadow(pos.xyz, norm, pos_screen);
+    shadow = sampleDirectionalShadow(pos.xyz, norm.xyz, pos_screen);
 #endif
 
     spec = final_specular;
-
+    vec4 diffuse = final_color;
     float envIntensity = final_normal.z;
 
+    vec3 color = vec3(0,0,0);
+
     vec3 light_dir = (sun_up_factor == 1) ? sun_dir : moon_dir;
 
     float bloom = 0.0;
@@ -333,117 +300,118 @@ void main()
 
     calcAtmosphericVars(pos.xyz, light_dir, 1.0, sunlit, amblit, additive, atten, false);
     
-    if (emissive_brightness >= 1.0)	// fullbright, skip lighting calculations
-    {
-        color = fullbrightAtmosTransportFrag(diffuse_srgb.rgb, additive, atten);
-        color = fullbrightScaleSoftClip(color);
 
-        al = diffuse_srgb.a;
-    }
-    else // not fullbright, calculate lighting
-    {
-        vec3 refnormpersp = normalize(reflect(pos.xyz, norm));
-
-        //we're in sRGB space, so gamma correct this dot product so 
-        // lighting from the sun stays sharp
-        float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
-        da = pow(da, 1.0 / 1.3);
-
-        //darken ambient for normals perpendicular to light vector so surfaces in shadow 
-        // and facing away from light still have some definition to them.
-        // do NOT gamma correct this dot product so ambient lighting stays soft
-        float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
-        ambient *= 0.5;
-        ambient *= ambient;
-        ambient = (1.0 - ambient);
-
-        vec3 sun_contrib = min(da, shadow) * sunlit;
-
-#if !defined(AMBIENT_KILL)
-        color = amblit;
-        color *= ambient;
-#endif
+    vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
 
-#if !defined(SUNLIGHT_KILL)
-        color += sun_contrib;
-#endif
-        color *= diffuse_srgb.rgb;
+    //we're in sRGB space, so gamma correct this dot product so 
+    // lighting from the sun stays sharp
+    float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
+    da = pow(da, 1.0 / 1.3);
 
-        float glare = 0.0;
+    color = amblit;
 
-        if (spec.a > 0.0) // specular reflection
-        {
-            vec3 npos = -normalize(pos.xyz);
+    //darken ambient for normals perpendicular to light vector so surfaces in shadow 
+    // and facing away from light still have some definition to them.
+    // do NOT gamma correct this dot product so ambient lighting stays soft
+    float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
+    ambient *= 0.5;
+    ambient *= ambient;
+    ambient = (1.0 - ambient);
 
-            //vec3 ref = dot(pos+lv, norm);
-            vec3 h = normalize(light_dir.xyz + npos);
-            float nh = dot(norm, h);
-            float nv = dot(norm, npos);
-            float vh = dot(npos, h);
-            float sa = nh;
-            float fres = pow(1 - dot(h, npos), 5)*0.4 + 0.5;
+    vec3 sun_contrib = min(da, shadow) * sunlit;
+    
+    color *= ambient;
 
-            float gtdenom = 2 * nh;
-            float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
+    color += sun_contrib;
 
-            if (nh > 0.0)
-            {
-                float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt / (nh*da);
-                vec3 sp = sun_contrib*scol / 6.0f;
-                sp = clamp(sp, vec3(0), vec3(1));
-                bloom = dot(sp, sp) / 4.0;
-#if !defined(SUNLIGHT_KILL)
-                color += sp * spec.rgb;
-#endif
-            }
-        }
+    color *= gamma_diff.rgb;
 
-        if (envIntensity > 0.0)
-        {
-            //add environmentmap
-            vec3 env_vec = env_mat * refnormpersp;
+    float glare = 0.0;
 
-            vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
+    if (spec.a > 0.0) // specular reflection
+    {
+#if 1 //EEP
 
-#if !defined(SUNLIGHT_KILL)
-            color = mix(color, reflected_color, envIntensity);
-#endif
-            float cur_glare = max(reflected_color.r, reflected_color.g);
-            cur_glare = max(cur_glare, reflected_color.b);
-            cur_glare *= envIntensity*4.0;
-            glare += cur_glare;
+        vec3 npos = -normalize(pos.xyz);
+
+        //vec3 ref = dot(pos+lv, norm);
+        vec3 h = normalize(light_dir.xyz + npos);
+        float nh = dot(norm.xyz, h);
+        float nv = dot(norm.xyz, npos);
+        float vh = dot(npos, h);
+        float sa = nh;
+        float fres = pow(1 - dot(h, npos), 5)*0.4 + 0.5;
+
+        float gtdenom = 2 * nh;
+        float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
+
+        if (nh > 0.0)
+        {
+            float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt / (nh*da);
+            vec3 sp = sun_contrib*scol / 6.0f;
+            sp = clamp(sp, vec3(0), vec3(1));
+            bloom = dot(sp, sp) / 4.0;
+            color += sp * spec.rgb;
         }
+#else // PRODUCTION
+        float sa = dot(refnormpersp, sun_dir.xyz);
+		vec3 dumbshiny = sunlit*shadow*(texture2D(lightFunc, vec2(sa, spec.a)).r);
+							
+		// add the two types of shiny together
+		vec3 spec_contrib = dumbshiny * spec.rgb;
+		bloom = dot(spec_contrib, spec_contrib) / 6;
+
+		glare = max(spec_contrib.r, spec_contrib.g);
+		glare = max(glare, spec_contrib.b);
+
+		color += spec_contrib;
+#endif
+    }
 
-        color = atmosFragLighting(color, additive, atten);
-        color = scaleSoftClipFrag(color);
+    color = mix(color.rgb, diffcol.rgb, diffuse.a);
+    
+    if (envIntensity > 0.0)
+    {
+        //add environmentmap
+        vec3 env_vec = env_mat * refnormpersp;
 
-        vec3 npos = normalize(-pos.xyz);
+        vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
 
-        vec3 light = vec3(0, 0, 0);
+        color = mix(color, reflected_color, envIntensity);
 
-        //convert to linear before adding local lights
-        color = srgb_to_linear(color);
+        float cur_glare = max(reflected_color.r, reflected_color.g);
+        cur_glare = max(cur_glare, reflected_color.b);
+        cur_glare *= envIntensity*4.0;
+        glare += cur_glare;
+    }
 
-#define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, npos, diffuse_linear.rgb, final_specular, pos.xyz, norm, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, glare, light_attenuation[i].w );
+    color = atmosFragLighting(color, additive, atten);
+    color = scaleSoftClipFrag(color);
 
-        LIGHT_LOOP(1)
-            LIGHT_LOOP(2)
-            LIGHT_LOOP(3)
-            LIGHT_LOOP(4)
-            LIGHT_LOOP(5)
-            LIGHT_LOOP(6)
-            LIGHT_LOOP(7)
+    //convert to linear before adding local lights
+    color = srgb_to_linear(color);
 
-            glare = min(glare, 1.0);
-        al = max(diffuse_linear.a, glare)*vertex_color.a;
+    vec3 npos = normalize(-pos.xyz);
 
-#if !defined(LOCAL_LIGHT_KILL)
-        color += light;
-#endif
+    vec3 light = vec3(0, 0, 0);
+    
+#define LIGHT_LOOP(i) light.rgb += calcPointLightOrSpotLight(light_diffuse[i].rgb, npos, diffuse.rgb, final_specular, pos.xyz, norm.xyz, light_position[i], light_direction[i].xyz, light_attenuation[i].x, light_attenuation[i].y, light_attenuation[i].z, glare, light_attenuation[i].w );
 
-        //convert to srgb as this color is being written post gamma correction
-        color = linear_to_srgb(color);
-    }
+    LIGHT_LOOP(1)
+        LIGHT_LOOP(2)
+        LIGHT_LOOP(3)
+        LIGHT_LOOP(4)
+        LIGHT_LOOP(5)
+        LIGHT_LOOP(6)
+        LIGHT_LOOP(7)
+
+    color += light;
+
+    glare = min(glare, 1.0);
+    float al = max(diffcol.a, glare)*vertex_color.a;
+
+    //convert to srgb as this color is being written post gamma correction
+    color = linear_to_srgb(color);
 
 #ifdef WATER_FOG
     vec4 temp = applyWaterFogView(pos, vec4(color, al));
@@ -451,13 +419,12 @@ void main()
     al = temp.a;
 #endif
 
-    // Don't allow alpha to exceed input value - SL-12592
-    frag_color = vec4(color, min(al, diffuse_srgb.a));
+    frag_color = vec4(color, al);
 
 #else // mode is not DIFFUSE_ALPHA_MODE_BLEND, encode to gbuffer 
 
     // deferred path
-    frag_data[0] = vec4(linear_to_srgb(final_color.rgb), final_color.a); //gbuffer is sRGB
+    frag_data[0] = final_color; //gbuffer is sRGB
     frag_data[1] = final_specular; // XYZ = Specular color. W = Specular exponent.
     frag_data[2] = final_normal; // XY = Normal.  Z = Env. intensity.
 #endif
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 20ac78947b..5b94baf7e6 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -63,6 +63,8 @@ void calcAtmosphericVars(vec3 inPositionEye, vec3 light_dir, float ambFactor, ou
 float getAmbientClamp();
 vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
 vec3 scaleSoftClipFrag(vec3 l);
+vec3 fullbrightAtmosTransportFrag(vec3 light, vec3 additive, vec3 atten);
+vec3 fullbrightScaleSoftClip(vec3 light);
 
 vec3 linear_to_srgb(vec3 c);
 vec3 srgb_to_linear(vec3 c);
@@ -81,11 +83,13 @@ void main()
     norm.xyz = getNorm(tc);
     
     vec3 light_dir = (sun_up_factor == 1) ? sun_dir : moon_dir;
-    float da = clamp(dot(normalize(norm.xyz), light_dir.xyz), 0.0, 1.0);
-    da = pow(da, 1.0/1.3);
+    float da = clamp(dot(norm.xyz, light_dir.xyz), 0.0, 1.0);
+    //da = pow(da, 1.0/1.3);
+    
+    vec4 diffuse = texture2DRect(diffuseRect, tc);
 
-    vec4 diffuse_srgb = texture2DRect(diffuseRect, tc);
-    vec4 diffuse_linear = vec4(srgb_to_linear(diffuse_srgb.rgb), diffuse_srgb.a);
+    //convert to gamma space
+    //diffuse.rgb = linear_to_srgb(diffuse.rgb);
 
     vec4 spec = texture2DRect(specularRect, vary_fragcoord.xy);
     vec3 color = vec3(0);
@@ -100,34 +104,27 @@ void main()
     
         calcAtmosphericVars(pos.xyz, light_dir, ambocc, sunlit, amblit, additive, atten, false);
 
+        color.rgb = amblit;
+
         float ambient = min(abs(dot(norm.xyz, sun_dir.xyz)), 1.0);
         ambient *= 0.5;
         ambient *= ambient;
         ambient = (1.0 - ambient);
 
-        vec3 sun_contrib = da * sunlit;
-
-#if !defined(AMBIENT_KILL)
-        color.rgb = amblit;
         color.rgb *= ambient;
-#endif
 
-vec3 post_ambient = color.rgb;
+        vec3 sun_contrib = da * sunlit;
 
-#if !defined(SUNLIGHT_KILL)
         color.rgb += sun_contrib;
-#endif
-
-vec3 post_sunlight = color.rgb;
 
-        color.rgb *= diffuse_srgb.rgb;
-
-vec3 post_diffuse = color.rgb;
+        color.rgb *= diffuse.rgb;
 
         vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
 
         if (spec.a > 0.0) // specular reflection
         {
+
+#if 1 //EEP
             vec3 npos = -normalize(pos.xyz);
 
             //vec3 ref = dot(pos+lv, norm);
@@ -140,71 +137,55 @@ vec3 post_diffuse = color.rgb;
 
             float gtdenom = 2 * nh;
             float gt = max(0, min(gtdenom * nv / vh, gtdenom * da / vh));
-                                    
+            
             if (nh > 0.0)
             {
                 float scontrib = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
                 vec3 sp = sun_contrib*scontrib / 6.0;
                 sp = clamp(sp, vec3(0), vec3(1));
                 bloom += dot(sp, sp) / 4.0;
-#if !defined(SUNLIGHT_KILL)
                 color += sp * spec.rgb;
-#endif
             }
+#else //PRODUCTION
+            float sa = dot(refnormpersp, light_dir.xyz);
+            vec3 dumbshiny = sunlit*(texture2D(lightFunc, vec2(sa, spec.a)).r);
+            
+            // add the two types of shiny together
+            vec3 spec_contrib = dumbshiny * spec.rgb;
+            bloom = dot(spec_contrib, spec_contrib) / 6;
+            color.rgb += spec_contrib;
+#endif
+
         }
        
- vec3 post_spec = color.rgb;
+       color.rgb = mix(color.rgb, diffuse.rgb, diffuse.a);
 
         if (envIntensity > 0.0)
         { //add environmentmap
             vec3 env_vec = env_mat * refnormpersp;
             vec3 reflected_color = textureCube(environmentMap, env_vec).rgb;
-#if !defined(SUNLIGHT_KILL)
-            color = mix(color.rgb, reflected_color, envIntensity*0.75); // MAGIC NUMBER SL-12574; ALM: On, Quality <= Mid+
-#endif
+            color = mix(color.rgb, reflected_color, envIntensity);
         }
-        else
-        {
-            color.rgb = mix(color.rgb, diffuse_srgb.rgb, diffuse_srgb.a);
-        }
-
-vec3 post_env = color.rgb;
-
-        if (norm.w < 1)
+       
+        if (norm.w < 0.5)
         {
-#if !defined(SUNLIGHT_KILL)
-            color = atmosFragLighting(color, additive, atten);
-            color = scaleSoftClipFrag(color);
-#endif
+            color = mix(atmosFragLighting(color, additive, atten), fullbrightAtmosTransportFrag(color, additive, atten), diffuse.a);
+            color = mix(scaleSoftClipFrag(color), fullbrightScaleSoftClip(color), diffuse.a);
         }
 
-vec3 post_atmo = color.rgb;
-
         #ifdef WATER_FOG
             vec4 fogged = applyWaterFogView(pos.xyz,vec4(color, bloom));
             color = fogged.rgb;
             bloom = fogged.a;
         #endif
 
-// srgb colorspace debuggables
-//color.rgb = amblit;
-//color.rgb = sunlit;
-//color.rgb = post_ambient;
-//color.rgb = sun_contrib;
-//color.rgb = post_sunlight;
-//color.rgb = diffuse_srgb.rgb;
-//color.rgb = post_diffuse;
-//color.rgb = post_spec;
-//color.rgb = post_env;
-//color.rgb = post_atmo;
-
     }
 
 // linear debuggables
 //color.rgb = vec3(final_da);
 //color.rgb = vec3(ambient);
 //color.rgb = vec3(scol);
-//color.rgb = diffuse_linear.rgb;
+//color.rgb = diffuse_srgb.rgb;
 
     // convert to linear as fullscreen lights need to sum in linear colorspace
     // and will be gamma (re)corrected downstream...
diff --git a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
index b86867c460..ceb4b8033d 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/waterF.glsl
@@ -164,14 +164,15 @@ void main()
 	
 	color.rgb += spec * specular;
 
-	//color.rgb = atmosTransport(color.rgb);
+	color.rgb = atmosTransport(color.rgb);
 	color.rgb = scaleSoftClip(color.rgb);
     
 	color.a   = spec * sunAngle2;
     
 	vec3 screenspacewavef = normalize((norm_mat*vec4(wavef, 1.0)).xyz);
 
-	frag_data[0] = vec4(color.rgb, color); // diffuse
-	frag_data[1] = vec4(0);		// speccolor, spec
-	frag_data[2] = vec4(encode_normal(screenspacewavef.xyz*0.5+0.5), 0.0, 0);// normalxy, 0, 0
+	//frag_data[0] = color;
+    frag_data[0] = color;
+    frag_data[1] = vec4(0);		// speccolor, spec
+	frag_data[2] = vec4(encode_normal(screenspacewavef.xyz), 0.05, 0);// normalxy, 0, 0
 }
diff --git a/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl b/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
index bbfec3b532..e53bb46177 100644
--- a/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/environment/terrainWaterF.glsl
@@ -39,6 +39,8 @@ uniform sampler2D detail_2;
 uniform sampler2D detail_3;
 uniform sampler2D alpha_ramp;
 
+vec3 atmosLighting(vec3 light);
+
 vec4 applyWaterFog(vec4 color);
 
 void main()
@@ -55,10 +57,10 @@ void main()
 	float alpha2 = texture2D(alpha_ramp,vary_texcoord1.xy).a;
 	float alphaFinal = texture2D(alpha_ramp, vary_texcoord1.zw).a;
 	vec4 outColor = mix( mix(color3, color2, alpha2), mix(color1, color0, alpha1), alphaFinal );
-
-    outColor.rgb *= vertex_color.rgb;	
+	
+	/// Add WL Components
+	outColor.rgb = atmosLighting(outColor.rgb * vertex_color.rgb);
+	
 	outColor = applyWaterFog(outColor);
-
 	frag_color = outColor;
 }
-
diff --git a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
index b3ae64bd82..d1e6c7da1a 100644
--- a/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
+++ b/indra/newview/app_settings/shaders/class1/environment/waterF.glsl
@@ -1,5 +1,5 @@
 /** 
- * @file class1/environment/waterF.glsl
+ * @file waterF.glsl
  *
  * $LicenseInfo:firstyear=2007&license=viewerlgpl$
  * Second Life Viewer Source Code
@@ -32,7 +32,7 @@ out vec4 frag_color;
 vec3 scaleSoftClip(vec3 inColor);
 vec3 atmosTransport(vec3 inColor);
 
-uniform sampler2D bumpMap;   
+uniform sampler2D bumpMap;
 uniform sampler2D bumpMap2;
 uniform float     blend_factor;
 uniform sampler2D screenTex;
@@ -50,7 +50,7 @@ uniform vec3 normScale;
 uniform float fresnelScale;
 uniform float fresnelOffset;
 uniform float blurMultiplier;
-uniform int water_edge;
+
 
 //bigWave is (refCoord.w, view.w);
 VARYING vec4 refCoord;
@@ -59,27 +59,27 @@ VARYING vec4 view;
 
 vec3 BlendNormal(vec3 bump1, vec3 bump2)
 {
-    //vec3 normal   = bump1.xyz * vec3( 2.0,  2.0, 2.0) - vec3(1.0, 1.0,  0.0);
-    //vec3 normal2  = bump2.xyz * vec3(-2.0, -2.0, 2.0) + vec3(1.0, 1.0, -1.0);
-    //vec3 n        = normalize(normal * dot(normal, normal2) - (normal2 * normal.z));
-    vec3 n = normalize(mix(bump1, bump2, blend_factor));
+    vec3 n = mix(bump1, bump2, blend_factor);
     return n;
 }
 
+
 void main() 
 {
-    vec4 color;
-    
-    float dist = length(view.xy);
-    
-    //normalize view vector
-    vec3 viewVec = normalize(view.xyz);
-    
-    //get wave normals
+	vec4 color;
+	
+	float dist = length(view.xy);
+	
+	//normalize view vector
+	vec3 viewVec = normalize(view.xyz);
+	
+	//get wave normals
+	//get wave normals
     vec3 wave1_a = texture2D(bumpMap, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
     vec3 wave2_a = texture2D(bumpMap, littleWave.xy).xyz*2.0-1.0;
     vec3 wave3_a = texture2D(bumpMap, littleWave.zw).xyz*2.0-1.0;
 
+
     vec3 wave1_b = texture2D(bumpMap2, vec2(refCoord.w, view.w)).xyz*2.0-1.0;
     vec3 wave2_b = texture2D(bumpMap2, littleWave.xy).xyz*2.0-1.0;
     vec3 wave3_b = texture2D(bumpMap2, littleWave.zw).xyz*2.0-1.0;
@@ -88,80 +88,81 @@ void main()
     vec3 wave2 = BlendNormal(wave2_a, wave2_b);
     vec3 wave3 = BlendNormal(wave3_a, wave3_b);
 
-    //get base fresnel components   
-    
-    vec3 df = vec3(
-                    dot(viewVec, wave1),
-                    dot(viewVec, (wave2 + wave3) * 0.5),
-                    dot(viewVec, wave3)
-                 ) * fresnelScale + fresnelOffset;
-    df *= df;
-            
-    vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
-    
-    float dist2 = dist;
-    dist = max(dist, 5.0);
-    
-    float dmod = sqrt(dist);
-    
-    vec2 dmod_scale = vec2(dmod*dmod, dmod);
-    
-    //get reflected color
-    vec2 refdistort1 = wave1.xy*normScale.x;
-    vec2 refvec1 = distort+refdistort1/dmod_scale;
-    vec4 refcol1 = texture2D(refTex, refvec1);
-    
-    vec2 refdistort2 = wave2.xy*normScale.y;
-    vec2 refvec2 = distort+refdistort2/dmod_scale;
-    vec4 refcol2 = texture2D(refTex, refvec2);
-    
-    vec2 refdistort3 = wave3.xy*normScale.z;
-    vec2 refvec3 = distort+refdistort3/dmod_scale;
-    vec4 refcol3 = texture2D(refTex, refvec3);
-
-    vec4 refcol = refcol1 + refcol2 + refcol3;
-    float df1 = df.x + df.y + df.z;
-    df1 *= 0.666666f;
-    refcol *= df1;
-    
-    vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
-    
-    wavef.z *= max(-viewVec.z, 0.1);
-    wavef = normalize(wavef);
-    
-    float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
-    
-    vec2 refdistort4 = wavef.xy*0.125;
-    refdistort4.y -= abs(refdistort4.y);
-    vec2 refvec4 = distort+refdistort4/dmod;
-    float dweight = min(dist2*blurMultiplier, 1.0);
-    vec4 baseCol = texture2D(refTex, refvec4);
-    refcol = mix(baseCol*df2, refcol, dweight);
-
-    //get specular component
-    float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
-        
-    //harden specular
-    spec = pow(spec, 128.0);
-
-    //figure out distortion vector (ripply)   
-    vec2 distort2 = distort+wavef.xy*refScale*0.16/max(dmod*df1, 1.0);
-        
-    vec4 fb = texture2D(screenTex, distort2);
-    
-    //mix with reflection
-    // Note we actually want to use just df1, but multiplying by 0.999999 gets around and nvidia compiler bug
-    color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.9999999);
-    color.rgb += spec * specular;
-
-    color.a = spec * sunAngle2;
-
-    //color.rgb = atmosTransport(color.rgb);
+
+	//get base fresnel components	
+	
+	vec3 df = vec3(
+					dot(viewVec, wave1),
+					dot(viewVec, (wave2 + wave3) * 0.5),
+					dot(viewVec, wave3)
+				 ) * fresnelScale + fresnelOffset;
+	df *= df;
+		    
+	vec2 distort = (refCoord.xy/refCoord.z) * 0.5 + 0.5;
+	
+	float dist2 = dist;
+	dist = max(dist, 5.0);
+	
+	float dmod = sqrt(dist);
+	
+	vec2 dmod_scale = vec2(dmod*dmod, dmod);
+	
+	//get reflected color
+	vec2 refdistort1 = wave1.xy*normScale.x;
+	vec2 refvec1 = distort+refdistort1/dmod_scale;
+	vec4 refcol1 = texture2D(refTex, refvec1);
+	
+	vec2 refdistort2 = wave2.xy*normScale.y;
+	vec2 refvec2 = distort+refdistort2/dmod_scale;
+	vec4 refcol2 = texture2D(refTex, refvec2);
+	
+	vec2 refdistort3 = wave3.xy*normScale.z;
+	vec2 refvec3 = distort+refdistort3/dmod_scale;
+	vec4 refcol3 = texture2D(refTex, refvec3);
+
+	vec4 refcol = refcol1 + refcol2 + refcol3;
+	float df1 = df.x + df.y + df.z;
+	refcol *= df1 * 0.333;
+	
+	vec3 wavef = (wave1 + wave2 * 0.4 + wave3 * 0.6) * 0.5;
+	
+	wavef.z *= max(-viewVec.z, 0.1);
+	wavef = normalize(wavef);
+	
+	float df2 = dot(viewVec, wavef) * fresnelScale+fresnelOffset;
+	
+	vec2 refdistort4 = wavef.xy*0.125;
+	refdistort4.y -= abs(refdistort4.y);
+	vec2 refvec4 = distort+refdistort4/dmod;
+	float dweight = min(dist2*blurMultiplier, 1.0);
+	vec4 baseCol = texture2D(refTex, refvec4);
+	refcol = mix(baseCol*df2, refcol, dweight);
+
+	//get specular component
+	float spec = clamp(dot(lightDir, (reflect(viewVec,wavef))),0.0,1.0);
+		
+	//harden specular
+	spec = pow(spec, 128.0);
+
+	//figure out distortion vector (ripply)   
+	vec2 distort2 = distort+wavef.xy*refScale/max(dmod*df1, 1.0);
+		
+	vec4 fb = texture2D(screenTex, distort2);
+	
+	//mix with reflection
+	// Note we actually want to use just df1, but multiplying by 0.999999 gets around and nvidia compiler bug
+	color.rgb = mix(fb.rgb, refcol.rgb, df1 * 0.99999);
+	color.rgb += spec * specular;
+	
+	color.rgb = atmosTransport(color.rgb);
 	color.rgb = scaleSoftClip(color.rgb);
+	color.a = spec * sunAngle2;
+	
+	frag_color = color;
 
 #if defined(WATER_EDGE)
     gl_FragDepth = 0.9999847f;
 #endif
-
-    frag_color = color;
+	
 }
+