OpenGL2: Add fourth cascade for sun shadows, and adjust sun shadow cvar defaults.

1 files changed, 51 insertions, 40 deletions

diff --git a/src/renderergl2/glsl/shadowmask_fp.glsl b/src/renderergl2/glsl/shadowmask_fp.glsl
index b489fef5..8a5597a9 100644
--- a/src/renderergl2/glsl/shadowmask_fp.glsl
+++ b/src/renderergl2/glsl/shadowmask_fp.glsl
@@ -1,15 +1,17 @@
 uniform sampler2D u_ScreenDepthMap;
 
-uniform sampler2D u_ShadowMap;
+uniform sampler2DShadow u_ShadowMap;
 #if defined(USE_SHADOW_CASCADE)
-uniform sampler2D u_ShadowMap2;
-uniform sampler2D u_ShadowMap3;
+uniform sampler2DShadow u_ShadowMap2;
+uniform sampler2DShadow u_ShadowMap3;
+uniform sampler2DShadow u_ShadowMap4;
 #endif
 
 uniform mat4      u_ShadowMvp;
 #if defined(USE_SHADOW_CASCADE)
 uniform mat4      u_ShadowMvp2;
 uniform mat4      u_ShadowMvp3;
+uniform mat4      u_ShadowMvp4;
 #endif
 
 uniform vec3   u_ViewOrigin;
@@ -39,94 +41,103 @@ float random( const vec2 p )
   return mod( 123456789., 1e-7 + 256. * dot(p,r) );  
 }
 
-float PCF(const sampler2D shadowmap, const vec2 st, const float dist)
+float PCF(const sampler2DShadow shadowmap, const vec2 st, const float dist)
 {
 	float mult;
 	float scale = 2.0 / r_shadowMapSize;
 
+#if 0
+	// from http://http.developer.nvidia.com/GPUGems/gpugems_ch11.html
+	vec2 offset = vec2(greaterThan(fract(var_DepthTex.xy * r_FBufScale * 0.5), vec2(0.25)));
+	offset.y += offset.x;
+	if (offset.y > 1.1) offset.y = 0.0;
+	
+	mult = shadow2D(shadowmap, vec3(st + (offset + vec2(-1.5,  0.5)) * scale, dist)).r
+	     + shadow2D(shadowmap, vec3(st + (offset + vec2( 0.5,  0.5)) * scale, dist)).r
+	     + shadow2D(shadowmap, vec3(st + (offset + vec2(-1.5, -1.5)) * scale, dist)).r
+	     + shadow2D(shadowmap, vec3(st + (offset + vec2( 0.5, -1.5)) * scale, dist)).r;
+	 
+	mult *= 0.25;
+#endif
+
 #if defined(USE_SHADOW_FILTER)
 	float r = random(var_DepthTex.xy);
 	float sinr = sin(r) * scale;
 	float cosr = cos(r) * scale;
 	mat2 rmat = mat2(cosr, sinr, -sinr, cosr);
 
-	mult =  step(dist, texture2D(shadowmap, st + rmat * vec2(-0.7055767, 0.196515)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(0.3524343, -0.7791386)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(0.2391056, 0.9189604)).r);
+	mult =  shadow2D(shadowmap, vec3(st + rmat * vec2(-0.7055767, 0.196515), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(0.3524343, -0.7791386), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(0.2391056, 0.9189604), dist)).r;
   #if defined(USE_SHADOW_FILTER2)
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(-0.07580382, -0.09224417)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(0.5784913, -0.002528916)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(0.192888, 0.4064181)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(-0.6335801, -0.5247476)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(-0.5579782, 0.7491854)).r);
-	mult += step(dist, texture2D(shadowmap, st + rmat * vec2(0.7320465, 0.6317794)).r);
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(-0.07580382, -0.09224417), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(0.5784913, -0.002528916), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(0.192888, 0.4064181), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(-0.6335801, -0.5247476), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(-0.5579782, 0.7491854), dist)).r;
+	mult += shadow2D(shadowmap, vec3(st + rmat * vec2(0.7320465, 0.6317794), dist)).r;
 
 	mult *= 0.11111;
   #else
     mult *= 0.33333;
   #endif
 #else
-	mult = step(dist, texture2D(shadowmap, st).r);
+	mult = shadow2D(shadowmap, vec3(st, dist));
 #endif
-		
+
 	return mult;
 }
 
 float getLinearDepth(sampler2D depthMap, vec2 tex, float zFarDivZNear)
 {
-		float sampleZDivW = texture2D(depthMap, tex).r;
-		sampleZDivW -= DEPTH_MAX_ERROR;
-		return 1.0 / mix(zFarDivZNear, 1.0, sampleZDivW);
+	float sampleZDivW = texture2D(depthMap, tex).r - DEPTH_MAX_ERROR;
+	return 1.0 / mix(zFarDivZNear, 1.0, sampleZDivW);
 }
 
 void main()
 {
 	float result;
-	
-	float depth = getLinearDepth(u_ScreenDepthMap, var_DepthTex, u_ViewInfo.x);
-	float sampleZ = u_ViewInfo.y * depth;
 
+	float depth = getLinearDepth(u_ScreenDepthMap, var_DepthTex, u_ViewInfo.x);
 	vec4 biasPos = vec4(u_ViewOrigin + var_ViewDir * (depth - 0.5 / u_ViewInfo.x), 1.0);
-	
+
 	vec4 shadowpos = u_ShadowMvp * biasPos;
-	
-#if defined(USE_SHADOW_CASCADE)
-	const float fadeTo = 1.0;
-	result = fadeTo;
-#else
-	result = 0.0;
-#endif
 
-	if (all(lessThanEqual(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
+#if defined(USE_SHADOW_CASCADE)
+	if (all(lessThan(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
 	{
-		shadowpos.xyz = shadowpos.xyz / shadowpos.w * 0.5 + 0.5;
+#endif
+		shadowpos.xyz = shadowpos.xyz * (0.5 / shadowpos.w) + vec3(0.5);
 		result = PCF(u_ShadowMap, shadowpos.xy, shadowpos.z);
-	}
 #if defined(USE_SHADOW_CASCADE)
+	}
 	else
 	{
 		shadowpos = u_ShadowMvp2 * biasPos;
 
-		if (all(lessThanEqual(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
+		if (all(lessThan(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
 		{
-			shadowpos.xyz = shadowpos.xyz / shadowpos.w * 0.5 + 0.5;
+			shadowpos.xyz = shadowpos.xyz * (0.5 / shadowpos.w) + vec3(0.5);
 			result = PCF(u_ShadowMap2, shadowpos.xy, shadowpos.z);
 		}
 		else
 		{
 			shadowpos = u_ShadowMvp3 * biasPos;
 
-			if (all(lessThanEqual(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
+			if (all(lessThan(abs(shadowpos.xyz), vec3(abs(shadowpos.w)))))
 			{
-				shadowpos.xyz = shadowpos.xyz / shadowpos.w * 0.5 + 0.5;
+				shadowpos.xyz = shadowpos.xyz * (0.5 / shadowpos.w) + vec3(0.5);
 				result = PCF(u_ShadowMap3, shadowpos.xy, shadowpos.z);
-
-				float fade = clamp(sampleZ / r_shadowCascadeZFar * 10.0 - 9.0, 0.0, 1.0);
-				result = mix(result, fadeTo, fade);
+			}
+			else
+			{
+				shadowpos = u_ShadowMvp4 * biasPos;
+				shadowpos.xyz = shadowpos.xyz * (0.5 / shadowpos.w) + vec3(0.5);
+				result = PCF(u_ShadowMap4, shadowpos.xy, shadowpos.z);
 			}
 		}
 	}
 #endif
-		
+
 	gl_FragColor = vec4(vec3(result), 1.0);
 }