WIP - Make EEP match production.

5 files changed, 169 insertions, 222 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
 }