SL-10415, SL-10434

Further tweaking of directional shadow sampling to balance between peter-panning and shadow acne.

Move stars to just this side of the sky some to reduce parallax.

Remove decodeNormF and uses of decode_normal in favor of unified use of getNorm
(try to help the Intel HD x000 compiler learn to link correctly).

11 files changed, 117 insertions, 132 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
index 132364882b..f1b7a1312f 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/alphaF.glsl
@@ -71,7 +71,6 @@ vec4 applyWaterFogView(vec3 pos, vec4 color);
 #endif
 
 vec2 encode_normal (vec3 n);
-vec3 decode_normal (vec2 enc);
 vec3 scaleSoftClip(vec3 l);
 vec3 atmosFragAmbient(vec3 light, vec3 sunlit);
 vec3 atmosFragLighting(vec3 light, vec3 additive, vec3 atten);
@@ -170,7 +169,6 @@ void main()
     calcFragAtmospherics(pos.xyz, 1.0, sunlit, amblit, additive, atten);
 
     vec2 abnormal   = encode_normal(norm.xyz);
-         norm.xyz   = decode_normal(abnormal.xy);
 
     float sun_da  = dot(norm.xyz, sun_dir.xyz);
     float moon_da = dot(norm.xyz, moon_dir.xyz);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
index 812f375f42..596d0274af 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/blurLightF.glsl
@@ -46,7 +46,6 @@ VARYING vec2 vary_fragcoord;
 
 vec4 getPosition(vec2 pos_screen);
 vec3 getNorm(vec2 pos_screen);
-vec3 decode_normal (vec2 enc);
 
 void main() 
 {
diff --git a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
index 9d7a7f6556..e27bbce094 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/deferredUtil.glsl
@@ -29,8 +29,6 @@ uniform sampler2DRect   depthMap;
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
 
-vec3 decode_normal(vec2 enc);
-
 vec2 getScreenCoordinate(vec2 screenpos)
 {
     vec2 sc = screenpos.xy * 2.0;
@@ -43,8 +41,14 @@ vec2 getScreenCoordinate(vec2 screenpos)
 
 vec3 getNorm(vec2 screenpos)
 {
-   vec2 enc_norm = texture2DRect(normalMap, screenpos.xy).xy;
-   return decode_normal(enc_norm);
+   vec2 enc = texture2DRect(normalMap, screenpos.xy).xy;
+   vec2 fenc = enc*4-2;
+   float f = dot(fenc,fenc);
+   float g = sqrt(1-f/4);
+   vec3 n;
+   n.xy = fenc*g;
+   n.z = 1-f/2;
+   return n;
 }
 
 float getDepth(vec2 pos_screen)
diff --git a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
index 0f7c514e94..09bb6c5bb8 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/materialF.glsl
@@ -183,7 +183,6 @@ VARYING vec4 vertex_color;
 VARYING vec2 vary_texcoord0;
 
 vec2 encode_normal(vec3 n);
-vec3 decode_normal (vec2 enc);
 
 void main() 
 {
@@ -227,7 +226,6 @@ void main()
     norm.xyz = normalize(norm.xyz);
 
     vec2 abnormal   = encode_normal(norm.xyz);
-         norm.xyz   = decode_normal(abnormal.xy);
 
     vec4 final_color = diffcol;
     
diff --git a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
index e8eef9b94b..29298d7c07 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiPointLightF.glsl
@@ -36,7 +36,6 @@ out vec4 frag_color;
 uniform sampler2DRect depthMap;
 uniform sampler2DRect diffuseRect;
 uniform sampler2DRect specularRect;
-uniform sampler2DRect normalMap;
 uniform samplerCube environmentMap;
 uniform sampler2D noiseMap;
 uniform sampler2D lightFunc;
@@ -57,9 +56,8 @@ uniform float far_z;
 
 uniform mat4 inv_proj;
 
-vec3 decode_normal (vec2 enc);
-
 vec4 getPosition(vec2 pos_screen);
+vec3 getNorm(vec2 pos_screen);
 
 void main() 
 {
@@ -70,9 +68,8 @@ void main()
 		discard;
 	}
 	
-	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
-	norm = decode_normal(norm.xy); // unpack norm
-	norm = normalize(norm);
+	vec3 norm = getNorm(frag.xy);
+
 	vec4 spec = texture2DRect(specularRect, frag.xy);
 	vec3 diff = texture2DRect(diffuseRect, frag.xy).rgb;
 	
diff --git a/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
index 7438fac8fc..24804c3011 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/multiSpotLightF.glsl
@@ -71,8 +71,7 @@ VARYING vec4 vary_fragcoord;
 uniform vec2 screen_res;
 
 uniform mat4 inv_proj;
-
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 
 vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
 {
@@ -141,12 +140,9 @@ void main()
 		discard;
 	}
 		
-	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
-	float envIntensity = norm.z;
+	float envIntensity = texture2DRect(normalMap. frag.xy).z;
+	vec3 norm = getNorm(frag.xy);
 
-	norm = decode_normal(norm.xy);
-	
-	norm = normalize(norm);
 	float l_dist = -dot(lv, proj_n);
 	
 	vec4 proj_tc = (proj_mat * vec4(pos.xyz, 1.0));
diff --git a/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
index df48a66fab..f8264d971c 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/pointLightF.glsl
@@ -56,76 +56,75 @@ uniform vec2 screen_res;
 uniform mat4 inv_proj;
 uniform vec4 viewport;
 
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 vec4 getPosition(vec2 pos_screen);
 
 void main() 
 {
-	vec4 frag = vary_fragcoord;
-	frag.xyz /= frag.w;
-	frag.xyz = frag.xyz*0.5+0.5;
-	frag.xy *= screen_res;
-	
-	vec3 pos = getPosition(frag.xy).xyz;
-	vec3 lv = trans_center.xyz-pos;
-	float dist = length(lv);
-	dist /= size;
-	if (dist > 1.0)
-	{
-		discard;
-	}
-	
-	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
-	norm = decode_normal(norm.xy); // unpack norm
-	float da = dot(norm, lv);
-	if (da < 0.0)
-	{
-		discard;
-	}
-	
-	norm = normalize(norm);
-	lv = normalize(lv);
-	da = dot(norm, lv);
-	
-	float noise = texture2D(noiseMap, frag.xy/128.0).b;
-	
-	vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
-	float fa = falloff+1.0;
-	float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
-	dist_atten *= dist_atten;
-	dist_atten *= 2.0;
-	
-	float lit = da * dist_atten * noise;
+    vec4 frag = vary_fragcoord;
+    frag.xyz /= frag.w;
+    frag.xyz = frag.xyz*0.5+0.5;
+    frag.xy *= screen_res;
+    
+    vec3 pos = getPosition(frag.xy).xyz;
+    vec3 lv = trans_center.xyz-pos;
+    float dist = length(lv);
+    dist /= size;
+    if (dist > 1.0)
+    {
+        discard;
+    }
+    
+    vec3 norm = getNorm(frag.xy);
 
-	col = color.rgb*lit*col;
+    float da = dot(norm, lv);
+    if (da < 0.0)
+    {
+        discard;
+    }
+    
+    lv = normalize(lv);
+    da = dot(norm, lv);
+    
+    float noise = texture2D(noiseMap, frag.xy/128.0).b;
+    
+    vec3 col = texture2DRect(diffuseRect, frag.xy).rgb;
+    float fa = falloff+1.0;
+    float dist_atten = clamp(1.0-(dist-1.0*(1.0-fa))/fa, 0.0, 1.0);
+    dist_atten *= dist_atten;
+    dist_atten *= 2.0;
+    
+    float lit = da * dist_atten * noise;
 
-	vec4 spec = texture2DRect(specularRect, frag.xy);
-	if (spec.a > 0.0)
-	{
-		lit = min(da*6.0, 1.0) * dist_atten;
+    col = color.rgb*lit*col;
 
-		vec3 npos = -normalize(pos);
-		vec3 h = normalize(lv+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;
-		float gtdenom = 2 * nh;
-		float gt = max(0,(min(gtdenom * nv / vh, gtdenom * da / vh)));
+    vec4 spec = texture2DRect(specularRect, frag.xy);
+    if (spec.a > 0.0)
+    {
+        lit = min(da*6.0, 1.0) * dist_atten;
 
-		if (nh > 0.0)
-		{
-			float scol = fres*texture2D(lightFunc, vec2(nh, spec.a)).r*gt/(nh*da);
-			col += lit*scol*color.rgb*spec.rgb;
-		}
-	}
-	
-	if (dot(col, col) <= 0.0)
-	{
-		discard;
-	}
-		
-	frag_color.rgb = col;	
-	frag_color.a = 0.0;
+        vec3 npos = -normalize(pos);
+        vec3 h = normalize(lv+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;
+        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);
+            col += lit*scol*color.rgb*spec.rgb;
+        }
+    }
+    
+    if (dot(col, col) <= 0.0)
+    {
+        discard;
+    }
+        
+    frag_color.rgb = col;   
+    frag_color.a = 0.0;
 }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
index 70568bc75f..cef9938192 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/shadowUtil.glsl
@@ -48,44 +48,29 @@ uniform float shadow_bias;
 
 uniform float spot_shadow_bias;
 uniform float spot_shadow_offset;
-
+uniform float sun_up_factor;
 uniform mat4 inv_proj;
 uniform vec2 screen_res;
 
 vec3 decode_normal(vec2 enc);
 
-float pcfShadowLegacy(sampler2DShadow shadowMap, vec4 stc)
-{
-	stc.xyz /= stc.w;
-	stc.z += shadow_bias;
-		
-	stc.x = floor(stc.x*shadow_res.x + fract(stc.y*shadow_res.y*12345))/shadow_res.x; // add some chaotic jitter to X sample pos according to Y to disguise the snapping going on here
-	
-	float cs = shadow2D(shadowMap, stc.xyz).x;
-	float shadow = cs;
-	
-    shadow += shadow2D(shadowMap, stc.xyz+vec3(2.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
-    shadow += shadow2D(shadowMap, stc.xyz+vec3(1.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
-    shadow += shadow2D(shadowMap, stc.xyz+vec3(-1.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
-    shadow += shadow2D(shadowMap, stc.xyz+vec3(-2.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
-                       
-    return shadow*0.2;
-}
-
-float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float bias_scale, vec2 pos_screen)
+float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float bias_mul, vec2 pos_screen, vec3 light_dir)
 {
     stc.xyz /= stc.w;
-    stc.z += shadow_bias * bias_scale;
- 
-    stc.x = floor(stc.x*pos_screen.x + fract(stc.y*pos_screen.y*0.666666666))/shadow_res.x; // add some chaotic jitter to X sample pos according to Y to disguise the snapping going on here
+    float offset = max(0.75, light_dir.z);
+    stc.z += offset * shadow_bias * 3.33 * bias_mul;
+        
+    stc.x = floor(stc.x*shadow_res.x + fract(stc.y*pos_screen.y*3.14159))/shadow_res.x; // add some chaotic jitter to X sample pos according to Y to disguise the snapping going on here
     
     float cs = shadow2D(shadowMap, stc.xyz).x;
-    float shadow = cs;
+    float shadow = cs * 4.0;
+    
     shadow += shadow2D(shadowMap, stc.xyz+vec3(2.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
     shadow += shadow2D(shadowMap, stc.xyz+vec3(1.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
     shadow += shadow2D(shadowMap, stc.xyz+vec3(-1.0/shadow_res.x, 1.5/shadow_res.y, 0.0)).x;
     shadow += shadow2D(shadowMap, stc.xyz+vec3(-2.0/shadow_res.x, -1.5/shadow_res.y, 0.0)).x;
-    return shadow*0.2;
+                       
+    return shadow*0.125;
 }
 
 float pcfSpotShadow(sampler2DShadow shadowMap, vec4 stc, float bias_scale, vec2 pos_screen)
@@ -141,7 +126,7 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen)
             
             float w = 1.0;
             w -= max(spos.z-far_split.z, 0.0)/transition_domain.z;
-            shadow += pcfShadowLegacy(shadowMap3, lpos)*w;
+            shadow += pcfShadow(shadowMap3, lpos, 1.0, pos_screen, light_dir)*w;
             weight += w;
             shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
         }
@@ -153,7 +138,7 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen)
             float w = 1.0;
             w -= max(spos.z-far_split.y, 0.0)/transition_domain.y;
             w -= max(near_split.z-spos.z, 0.0)/transition_domain.z;
-            shadow += pcfShadowLegacy(shadowMap2, lpos)*w;
+            shadow += pcfShadow(shadowMap2, lpos, 1.0, pos_screen, light_dir)*w;
             weight += w;
         }
 
@@ -164,7 +149,7 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen)
             float w = 1.0;
             w -= max(spos.z-far_split.x, 0.0)/transition_domain.x;
             w -= max(near_split.y-spos.z, 0.0)/transition_domain.y;
-            shadow += pcfShadowLegacy(shadowMap1, lpos)*w;
+            shadow += pcfShadow(shadowMap1, lpos, 1.0, pos_screen, light_dir)*w;
             weight += w;
         }
 
@@ -175,14 +160,15 @@ float sampleDirectionalShadow(vec3 pos, vec3 norm, vec2 pos_screen)
             float w = 1.0;
             w -= max(near_split.x-spos.z, 0.0)/transition_domain.x;
                 
-            shadow += pcfShadowLegacy(shadowMap0, lpos)*w;
+            shadow += pcfShadow(shadowMap0, lpos, 1.0, pos_screen, light_dir)*w;
             weight += w;
         }
 
         shadow /= weight;
     }
 
-    return min(dp_directional_light, shadow);
+    shadow = min(dp_directional_light, shadow);
+    return shadow;
 }
 
 float sampleSpotShadow(vec3 pos, vec3 norm, int index, vec2 pos_screen)
@@ -201,11 +187,19 @@ float sampleSpotShadow(vec3 pos, vec3 norm, int index, vec2 pos_screen)
         float weight = 0.0;
 
         {
-            lpos = shadow_matrix[4 + index]*spos;
             float w = 1.0;
             w -= max(spos.z-far_split.z, 0.0)/transition_domain.z;
-        
-            shadow += pcfSpotShadow((index == 0) ? shadowMap4 : shadowMap5, lpos, 0.8, spos.xy)*w;
+
+            if (index == 0)
+            {        
+                lpos = shadow_matrix[4]*spos;
+                shadow += pcfSpotShadow(shadowMap4, lpos, 0.8, spos.xy)*w;
+            }
+            else
+            {
+                lpos = shadow_matrix[5]*spos;
+                shadow += pcfSpotShadow(shadowMap5, lpos, 0.8, spos.xy)*w;
+            }
             weight += w;
             shadow += max((pos.z+shadow_clip.z)/(shadow_clip.z-shadow_clip.w)*2.0-1.0, 0.0);
         }
diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index f0b038cc93..9e0079e0e9 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -66,7 +66,7 @@ uniform vec2 screen_res;
 vec4 applyWaterFogView(vec3 pos, vec4 color);
 #endif
 
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 vec3 atmosFragLighting(vec3 l, vec3 additive, vec3 atten);
 vec3 fullbrightAtmosTransportFrag(vec3 l, vec3 additive, vec3 atten);
 void calcFragAtmospherics(vec3 inPositionEye, float ambFactor, out vec3 sunlit, out vec3 amblit, out vec3 additive, out vec3 atten);
@@ -78,14 +78,14 @@ vec4 getPositionWithDepth(vec2 pos_screen, float depth);
 
 void main() 
 {
-	vec2 tc = vary_fragcoord.xy;
-	float depth = texture2DRect(depthMap, tc.xy).r;
-	vec4 pos = getPositionWithDepth(tc, depth);
-	vec4 norm = texture2DRect(normalMap, tc);
-	float envIntensity = norm.z;
-	norm.xyz = decode_normal(norm.xy); // unpack norm
-		
-	float da_sun  = dot(norm.xyz, normalize(sun_dir.xyz));
+    vec2 tc = vary_fragcoord.xy;
+    float depth = texture2DRect(depthMap, tc.xy).r;
+    vec4 pos = getPositionWithDepth(tc, depth);
+    vec4 norm = texture2DRect(normalMap, tc);
+    float envIntensity = norm.z;
+    norm.xyz = getNorm(tc);
+        
+    float da_sun  = dot(norm.xyz, normalize(sun_dir.xyz));
     float da_moon = dot(norm.xyz, normalize(moon_dir.xyz));
     float da = max(da_sun, da_moon);
 
diff --git a/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
index 22488944cd..d09bc25334 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/spotLightF.glsl
@@ -70,7 +70,7 @@ uniform vec2 screen_res;
 
 uniform mat4 inv_proj;
 
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 
 vec4 texture2DLodSpecular(sampler2D projectionMap, vec2 tc, float lod)
 {
@@ -142,7 +142,7 @@ void main()
 		
 	vec3 norm = texture2DRect(normalMap, frag.xy).xyz;
 	float envIntensity = norm.z;
-	norm = decode_normal(norm.xy);
+	norm = getNorm(frag.xy);
 	
 	norm = normalize(norm);
 	float l_dist = -dot(lv, proj_n);
diff --git a/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
index e98ab1f2eb..15f141cbe5 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/sunLightSSAOF.glsl
@@ -40,7 +40,7 @@ uniform sampler2DRect normalMap;
 // Inputs
 VARYING vec2 vary_fragcoord;
 
-vec3 decode_normal (vec2 enc);
+vec3 getNorm(vec2 pos_screen);
 vec4 getPosition(vec2 pos_screen);
 
 //calculate decreases in ambient lighting when crowded out (SSAO)
@@ -53,7 +53,7 @@ void main()
 	//try doing an unproject here
 	
 	vec4 pos  = getPosition(pos_screen);
-	vec3 norm = decode_normal(texture2DRect(normalMap, pos_screen).xy);
+	vec3 norm = getNorm(pos_screen);
 
 	frag_color[0] = 1.0;
 	frag_color[1] = calcAmbientOcclusion(pos, norm, pos_screen);