Merge

5 files changed, 84 insertions, 33 deletions

diff --git a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
index 155f03fdcf..158eef9319 100644
--- a/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class1/deferred/softenLightF.glsl
@@ -282,12 +282,13 @@ void main()
 	{
 		// the old infinite-sky shiny reflection
 		//
-		vec3 refnorm = normalize(reflect(pos.xyz, norm.xyz));
-		float sa = dot(refnorm, vary_light.xyz);
+		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+		float sa = dot(refnormpersp, vary_light.xyz);
 		vec3 dumbshiny = vary_SunlitColor*scol_ambocc.r*texture2D(lightFunc, vec2(sa, spec.a)).a;
 
 		// screen-space cheap fakey reflection map
 		//
+		vec3 refnorm = normalize(reflect(vec3(0,0,-1), norm.xyz));
 		depth -= 0.5; // unbias depth
 		// first figure out where we'll make our 2D guess from
 		vec2 ref2d = (0.25 * screen_res.y) * (refnorm.xy) * abs(refnorm.z) / depth;
@@ -298,22 +299,33 @@ void main()
 		// The goal of the blur is to soften reflections in surfaces
 		// with low shinyness, and also to disguise our lameness.
 		float checkerboard = floor(mod(tc.x+tc.y, 2.0)); // 0.0, 1.0
-		ref2d += normalize(ref2d)*14.0*(1.0-spec.a)*(checkerboard-0.5);
+		vec2 checkoffset = normalize(ref2d)*5.0*(1.0-spec.a)*(checkerboard-0.5);
+		ref2d += checkoffset;
 		ref2d += tc.xy; // use as offset from destination
-		// get attributes from the 2D guess point
+		// Get attributes from the 2D guess point.
+		// We average two samples of diffuse (not of anything else) per
+		// pixel to try to reduce aliasing some more.
+		// ---------------------
+		//     ^   ^ ^ ^   ^
+		//     a . b o c . d    check=0:avg(a,b) check=1:avg(c,d)
+		vec3 refcol = 0.5 * (texture2DRect(diffuseRect, ref2d).rgb +
+				     texture2DRect(diffuseRect, ref2d + checkoffset*2.0).rgb);
 		float refdepth = texture2DRect(depthMap, ref2d).a;
 		vec3 refpos = getPosition_d(ref2d, refdepth).xyz;
-		vec3 refcol = texture2DRect(diffuseRect, ref2d).rgb;
 		vec3 refn = normalize(texture2DRect(normalMap, ref2d).rgb * 2.0 - 1.0);
 		// figure out how appropriate our guess actually was
 		float refapprop = max(0.0, dot(-refnorm, normalize(pos - refpos)));
 		// darken reflections from points which face away from the reflected ray - our guess was a back-face
 		//refapprop *= step(dot(refnorm, refn), 0.0);
 		refapprop = min(refapprop, max(0.0, -dot(refnorm, refn))); // more conservative variant
-		// get appropriate light strength for guess-point
-		float reflit = max(dot(refn, lightnorm.xyz), 0.0);
+		// get appropriate light strength for guess-point.
+		// reflect light direction to increase the illusion that
+		// these are reflections.
+		vec3 reflight = reflect(lightnorm.xyz, norm.xyz);
+		float reflit = max(dot(refn, reflight.xyz), 0.0);
 		// apply sun color to guess-point, dampen according to inappropriateness of guess
-		vec3 refprod = (vary_SunlitColor*reflit) * refcol.rgb * refapprop;
+		float refmod = min(refapprop, reflit);
+		vec3 refprod = vary_SunlitColor * refcol.rgb * refmod;
 		vec3 ssshiny = (refprod * spec.a);
 
 		// add the two types of shiny together
diff --git a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
index 922a07c306..dbccb7fb8b 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/softenLightF.glsl
@@ -281,12 +281,13 @@ void main()
 	{
 		// the old infinite-sky shiny reflection
 		//
-		vec3 refnorm = normalize(reflect(pos.xyz, norm.xyz));
-		float sa = dot(refnorm, vary_light.xyz);
+		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+		float sa = dot(refnormpersp, vary_light.xyz);
 		vec3 dumbshiny = vary_SunlitColor*scol_ambocc.r*texture2D(lightFunc, vec2(sa, spec.a)).a;
 
 		// screen-space cheap fakey reflection map
 		//
+		vec3 refnorm = normalize(reflect(vec3(0,0,-1), norm.xyz));
 		depth -= 0.5; // unbias depth
 		// first figure out where we'll make our 2D guess from
 		vec2 ref2d = (0.25 * screen_res.y) * (refnorm.xy) * abs(refnorm.z) / depth;
@@ -297,12 +298,19 @@ void main()
 		// The goal of the blur is to soften reflections in surfaces
 		// with low shinyness, and also to disguise our lameness.
 		float checkerboard = floor(mod(tc.x+tc.y, 2.0)); // 0.0, 1.0
-		ref2d += normalize(ref2d)*14.0*(1.0-spec.a)*(checkerboard-0.5);
+		vec2 checkoffset = normalize(ref2d)*5.0*(1.0-spec.a)*(checkerboard-0.5);
+		ref2d += checkoffset;
 		ref2d += tc.xy; // use as offset from destination
-		// get attributes from the 2D guess point
+		// Get attributes from the 2D guess point.
+		// We average two samples of diffuse (not of anything else) per
+		// pixel to try to reduce aliasing some more.
+		// ---------------------
+		//     ^   ^ ^ ^   ^
+		//     a . b o c . d    check=0:avg(a,b) check=1:avg(c,d)
+		vec3 refcol = 0.5 * (texture2DRect(diffuseRect, ref2d).rgb +
+				     texture2DRect(diffuseRect, ref2d + checkoffset*2.0).rgb);
 		float refdepth = texture2DRect(depthMap, ref2d).a;
 		vec3 refpos = getPosition_d(ref2d, refdepth).xyz;
-		vec3 refcol = texture2DRect(diffuseRect, ref2d).rgb;
 		float refshad = texture2DRect(lightMap, ref2d).r;
 		vec3 refn = normalize(texture2DRect(normalMap, ref2d).rgb * 2.0 - 1.0);
 		// figure out how appropriate our guess actually was
@@ -311,9 +319,13 @@ void main()
 		//refapprop *= step(dot(refnorm, refn), 0.0);
 		refapprop = min(refapprop, max(0.0, -dot(refnorm, refn))); // more conservative variant
 		// get appropriate light strength for guess-point
-		float reflit = min(max(dot(refn, lightnorm.xyz), 0.0), refshad);
+		// reflect light direction to increase the illusion that
+		// these are reflections.
+		vec3 reflight = reflect(lightnorm.xyz, norm.xyz);
+		float reflit = min(max(dot(refn, reflight.xyz), 0.0), refshad);
 		// apply sun color to guess-point, dampen according to inappropriateness of guess
-		vec3 refprod = (vary_SunlitColor*reflit) * refcol.rgb * refapprop;
+		float refmod = min(refapprop, reflit);
+		vec3 refprod = vary_SunlitColor * refcol.rgb * refmod;
 		vec3 ssshiny = (refprod * spec.a);
 
 		// add the two types of shiny together
diff --git a/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl b/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
index 04c9a4d19a..46db3c990c 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/sunLightF.glsl
@@ -41,6 +41,9 @@ uniform vec2 proj_shadow_res;
 uniform float shadow_bias;
 uniform float shadow_offset;
 
+uniform float spot_shadow_bias;
+uniform float spot_shadow_offset;
+
 vec4 getPosition(vec2 pos_screen)
 {
 	float depth = texture2DRect(depthMap, pos_screen.xy).a;
@@ -75,7 +78,7 @@ float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
 {
 	stc.xyz /= stc.w;
-	stc.z += shadow_bias*scl;
+	stc.z += spot_shadow_bias*scl;
 	
 	float cs = shadow2D(shadowMap, stc.xyz).x;
 	float shadow = cs;
@@ -86,8 +89,7 @@ float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
 	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(off.x, -off.y, 0.0)).x, cs);
 	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, off.y, 0.0)).x, cs);
 	shadow += max(shadow2D(shadowMap, stc.xyz+vec3(-off.x, -off.y, 0.0)).x, cs);
-	
-			
+				
 	return shadow/5.0;
 	
 	//return shadow;
@@ -114,7 +116,10 @@ void main()
 	float shadow = 1.0;
 	float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
 
-	vec4 spos = vec4(pos.xyz + displace*norm + vary_light.xyz * (1.0-dp_directional_light)*shadow_offset, 1.0);
+	vec3 shadow_pos = pos.xyz + displace*norm;
+	vec3 offset = vary_light.xyz * (1.0-dp_directional_light);
+	
+	vec4 spos = vec4(shadow_pos+offset*shadow_offset, 1.0);
 	
 	if (spos.z > -shadow_clip.w)
 	{	
@@ -176,13 +181,15 @@ void main()
 	gl_FragColor[0] = shadow;
 	gl_FragColor[1] = 1.0;
 	
+	spos.xyz = shadow_pos+offset*spot_shadow_offset;
+	
 	//spotlight shadow 1
 	vec4 lpos = shadow_matrix[4]*spos;
-	gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.8).x; 
+	gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.8); 
 	
 	//spotlight shadow 2
 	lpos = shadow_matrix[5]*spos;
-	gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.8).x; 
+	gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.8); 
 
 	//gl_FragColor.rgb = pos.xyz;
 	//gl_FragColor.b = shadow;
diff --git a/indra/newview/app_settings/shaders/class2/deferred/sunLightSSAOF.glsl b/indra/newview/app_settings/shaders/class2/deferred/sunLightSSAOF.glsl
index d77d17942a..a0dfc96f14 100644
--- a/indra/newview/app_settings/shaders/class2/deferred/sunLightSSAOF.glsl
+++ b/indra/newview/app_settings/shaders/class2/deferred/sunLightSSAOF.glsl
@@ -40,6 +40,9 @@ uniform vec2 proj_shadow_res;
 uniform float shadow_bias;
 uniform float shadow_offset;
 
+uniform float spot_shadow_bias;
+uniform float spot_shadow_offset;
+
 vec4 getPosition(vec2 pos_screen)
 {
 	float depth = texture2DRect(depthMap, pos_screen.xy).a;
@@ -134,7 +137,7 @@ float pcfShadow(sampler2DRectShadow shadowMap, vec4 stc, float scl)
 float pcfShadow(sampler2DShadow shadowMap, vec4 stc, float scl)
 {
 	stc.xyz /= stc.w;
-	stc.z += shadow_bias*scl;
+	stc.z += spot_shadow_bias*scl;
 	
 	float cs = shadow2D(shadowMap, stc.xyz).x;
 	float shadow = cs;
@@ -173,7 +176,10 @@ void main()
 	float shadow = 1.0;
 	float dp_directional_light = max(0.0, dot(norm, vary_light.xyz));
 
-	vec4 spos = vec4(pos.xyz + displace*norm + vary_light.xyz * (1.0-dp_directional_light)*shadow_offset, 1.0);
+	vec3 shadow_pos = pos.xyz + displace*norm;
+	vec3 offset = vary_light.xyz * (1.0-dp_directional_light);
+	
+	vec4 spos = vec4(shadow_pos+offset*shadow_offset, 1.0);
 	
 	if (spos.z > -shadow_clip.w)
 	{	
@@ -235,13 +241,15 @@ void main()
 	gl_FragColor[0] = shadow;
 	gl_FragColor[1] = calcAmbientOcclusion(pos, norm);
 	
+	spos.xyz = shadow_pos+offset*spot_shadow_offset;
+	
 	//spotlight shadow 1
 	vec4 lpos = shadow_matrix[4]*spos;
-	gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.8).x; 
+	gl_FragColor[2] = pcfShadow(shadowMap4, lpos, 0.8); 
 	
 	//spotlight shadow 2
 	lpos = shadow_matrix[5]*spos;
-	gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.8).x; 
+	gl_FragColor[3] = pcfShadow(shadowMap5, lpos, 0.8); 
 
 	//gl_FragColor.rgb = pos.xyz;
 	//gl_FragColor.b = shadow;
diff --git a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
index ddd69befc3..ef81ed1308 100644
--- a/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
+++ b/indra/newview/app_settings/shaders/class3/deferred/softenLightF.glsl
@@ -284,12 +284,13 @@ void main()
 	{
 		// the old infinite-sky shiny reflection
 		//
-		vec3 refnorm = normalize(reflect(pos.xyz, norm.xyz));
-		float sa = dot(refnorm, vary_light.xyz);
+		vec3 refnormpersp = normalize(reflect(pos.xyz, norm.xyz));
+		float sa = dot(refnormpersp, vary_light.xyz);
 		vec3 dumbshiny = vary_SunlitColor*scol*texture2D(lightFunc, vec2(sa, spec.a)).a;
 
 		// screen-space cheap fakey reflection map
 		//
+		vec3 refnorm = normalize(reflect(vec3(0,0,-1), norm.xyz));
 		depth -= 0.5; // unbias depth
 		// first figure out where we'll make our 2D guess from
 		vec2 ref2d = (0.25 * screen_res.y) * (refnorm.xy) * abs(refnorm.z) / depth;
@@ -300,12 +301,19 @@ void main()
 		// The goal of the blur is to soften reflections in surfaces
 		// with low shinyness, and also to disguise our lameness.
 		float checkerboard = floor(mod(tc.x+tc.y, 2.0)); // 0.0, 1.0
-		ref2d += normalize(ref2d)*14.0*(1.0-spec.a)*(checkerboard-0.5);
+		vec2 checkoffset = normalize(ref2d)*5.0*(1.0-spec.a)*(checkerboard-0.5);
+		ref2d += checkoffset;
 		ref2d += tc.xy; // use as offset from destination
-		// get attributes from the 2D guess point
+		// Get attributes from the 2D guess point.
+		// We average two samples of diffuse (not of anything else) per
+		// pixel to try to reduce aliasing some more.
+		// ---------------------
+		//     ^   ^ ^ ^   ^
+		//     a . b o c . d    check=0:avg(a,b) check=1:avg(c,d)
+		vec3 refcol = 0.5 * (texture2DRect(diffuseRect, ref2d).rgb +
+				     texture2DRect(diffuseRect, ref2d + checkoffset*2.0).rgb);
 		float refdepth = texture2DRect(depthMap, ref2d).a;
 		vec3 refpos = getPosition_d(ref2d, refdepth).xyz;
-		vec3 refcol = texture2DRect(diffuseRect, ref2d).rgb;
 		float refshad = texture2DRect(lightMap, ref2d).r;
 		vec3 refn = normalize(texture2DRect(normalMap, ref2d).rgb * 2.0 - 1.0);
 		// figure out how appropriate our guess actually was
@@ -313,10 +321,14 @@ void main()
 		// darken reflections from points which face away from the reflected ray - our guess was a back-face
 		//refapprop *= step(dot(refnorm, refn), 0.0);
 		refapprop = min(refapprop, max(0.0, -dot(refnorm, refn))); // more conservative variant
-		// get appropriate light strength for guess-point
-		float reflit = min(max(dot(refn, lightnorm.xyz), 0.0), refshad);
+		// get appropriate light strength for guess-point.
+		// reflect light direction to increase the illusion that
+		// these are reflections.
+		vec3 reflight = reflect(lightnorm.xyz, norm.xyz);
+		float reflit = min(max(dot(refn, reflight.xyz), 0.0), refshad);
 		// apply sun color to guess-point, dampen according to inappropriateness of guess
-		vec3 refprod = (vary_SunlitColor*reflit) * refcol.rgb * refapprop;
+		float refmod = min(refapprop, reflit);
+		vec3 refprod = vary_SunlitColor * refcol.rgb * refmod;
 		vec3 ssshiny = (refprod * spec.a);
 
 		// add the two types of shiny together