*Switched to higher quality PCF filter for softer shadows

*Fixed some artifacts which occured when blending between shadow map cascades
*Added some more shader utility functions (namely, PCF filters)

Author: iftodebogdan

GITechDemo/Code/AppMain/GITechDemo/GITechDemo.cpp

@@ -40,10 +40,10 @@ Matrix44f worldViewProjMat;
 const bool GBUFFER_Z_PREPASS = false;
 
 #define MAX_NUM_CASCADES (9)
-#define PCF_BLUR_SIZE (4)
+#define PCF_BLUR_SIZE (16)
 const bool DEBUG_CASCADES = false;
 const unsigned int NUM_CASCADES = 4;
-const float CASCADE_SPLIT_FACTOR = 0.75f;
+const float CASCADE_SPLIT_FACTOR = 0.7f;
 const float CASCADE_MAX_VIEW_DEPTH = 3000.f;
 const float CASCADE_BLEND_SIZE = 50.f;
 

GITechDemo/Data/shaders/DeferredLightDir.hlsl

@@ -51,6 +51,9 @@ static const int	nCascadeCount = 4; // number of cascades
 static const int	nCascadesPerRow = 2; // number of cascades per row, i.e. ceil(sqrt(nCascadeCount))
 static const float	fCascadeNormSize = 0.5f; // normalized size of a cascade, i.e. 1.f / nCascadesPerRow
 
+// PCF method
+#define PCF_SAMPLE	PCF4x4Poisson
+
 struct PSOut
 {
 	float4 colorOut	:	SV_TARGET;
@@ -110,7 +113,7 @@ void psmain(VSOut input, out PSOut output)
 		float2(fCascadeNormSize * fmod(nValidCascade, nCascadesPerRow), fCascadeNormSize * floor(nValidCascade / nCascadesPerRow));
 
 	// PCF Poisson disc shadow sampling
-	float fPercentLit = PCF4x4Poisson(texShadowMap, f2OneOverShadowMapSize, f3CascadeTexCoord.xy, f3CascadeTexCoord.z - fShadowDepthBias);
+	float fPercentLit = PCF_SAMPLE(texShadowMap, f2OneOverShadowMapSize, f3CascadeTexCoord.xy, f3CascadeTexCoord.z - fShadowDepthBias);
 	//float fPercentLit = tex2D(texShadowMap, f3CascadeTexCoord.xy).r > f3CascadeTexCoord.z - fShadowDepthBias;
 
 	// if required, blend between cascade seams
@@ -119,29 +122,56 @@ void psmain(VSOut input, out PSOut output)
 		if (nValidCascade != nCascadeCount - 1)
 		{
 			// the blend amount depends on the position of the point inside the blend band of the current cascade
-			float fBlendAmount = (f2CascadeBoundsMin[nValidCascade].x + fCascadeBlendSize) - f4LightViewPos.x;
-			fBlendAmount = max(fBlendAmount, (f2CascadeBoundsMin[nValidCascade].y + fCascadeBlendSize) - f4LightViewPos.y);
-			fBlendAmount = max(fBlendAmount, f4LightViewPos.x - (f2CascadeBoundsMax[nValidCascade].x - fCascadeBlendSize));
-			fBlendAmount = max(fBlendAmount, f4LightViewPos.y - (f2CascadeBoundsMax[nValidCascade].y - fCascadeBlendSize));
+			float fScaledBlendSize = fCascadeBlendSize * (nValidCascade * nValidCascade + 1);
+			float fBlendAmount = 0.f;
+			
+			// partition the cascade into 4 parts and only allow blending in the parts furthest from the camera
+			// (i.e. the part that is closest to the camera is not adjacent to any valid cascade, because they
+			// fit very tightly around the view frustum, so blending in that zone would result in artifacts)
+			// Disclaimer: there probably exists an easier way to do this, but I'm just lazy
+			float2 NE = float2(0.707107f, 0.707107f); //normalize(float2(0.5f, 0.5f));
+			float2 SE = float2(0.707107f, -0.707107f); //normalize(float2(0.5f, -0.5f));
+			float2 SW = float2(-0.707107f, -0.707107f); //normalize(float2(-0.5f, -0.5f));
+			float2 NW = float2(-0.707107f, 0.707107f); //normalize(float2(-0.5f, 0.5f));
+
+			float2 f2CascadeSpaceViewDir = normalize(mul(f44CascadeProjMat[0], f4LightViewPos).xy);
+			float4 f4LightSpaceCameraDir = mul(f44CascadeProjMat[0], mul(f44ScreenToLightViewMat, float4(0.f, 0.f, 1.f, 1.f)));
+			bool dotNE = dot(f2CascadeSpaceViewDir, NE) > 0.f;
+			bool dotSE = dot(f2CascadeSpaceViewDir, SE) > 0.f;
+			bool dotSW = dot(f2CascadeSpaceViewDir, SW) > 0.f;
+			bool dotNW = dot(f2CascadeSpaceViewDir, NW) > 0.f;
+			bool dotCamDirNE = dot(f4LightSpaceCameraDir.xy, NE) > 0.f;
+			bool dotCamDirSE = dot(f4LightSpaceCameraDir.xy, SE) > 0.f;
+			bool dotCamDirSW = dot(f4LightSpaceCameraDir.xy, SW) > 0.f;
+			bool dotCamDirNW = dot(f4LightSpaceCameraDir.xy, NW) > 0.f;
+
+			if (dotSW && dotNW && (dotCamDirSW || dotCamDirNW))
+				fBlendAmount = max(fBlendAmount, (f2CascadeBoundsMin[nValidCascade].x + fScaledBlendSize) - f4LightViewPos.x);
+			if (dotSW && dotSE && (dotCamDirSW || dotCamDirSE))
+				fBlendAmount = max(fBlendAmount, (f2CascadeBoundsMin[nValidCascade].y + fScaledBlendSize) - f4LightViewPos.y);
+			if (dotSE && dotNE && (dotCamDirSE || dotCamDirNE))
+				fBlendAmount = max(fBlendAmount, f4LightViewPos.x - (f2CascadeBoundsMax[nValidCascade].x - fScaledBlendSize));
+			if (dotNW && dotNE && (dotCamDirNW || dotCamDirNE))
+				fBlendAmount = max(fBlendAmount, f4LightViewPos.y - (f2CascadeBoundsMax[nValidCascade].y - fScaledBlendSize));
+			
+			fBlendAmount /= fScaledBlendSize;
 
 			// if our point is inside the blend band, we can continue with blending
 			if (fBlendAmount > 0.f)
 			{
 				// calculate texture coordinates for sampling from the cascade one order
 				// higher than the cascade from which we sampled earlier
 				float3 f3LQCascadeTexCoord = mul(f44CascadeProjMat[nValidCascade + 1], f4LightViewPos).xyz;
-				if (f3LQCascadeTexCoord.x > 0.f && f3LQCascadeTexCoord.x < 1.f && f3LQCascadeTexCoord.y > 0.f && f3LQCascadeTexCoord.y < 1.f)
-				{
-					fBlendAmount /= fCascadeBlendSize;
-					f3LQCascadeTexCoord.xy =
-						(f3LQCascadeTexCoord.xy * float2(0.5f, -0.5f) + float2(0.5f, 0.5f)) *
-						fCascadeNormSize +
-						float2(fCascadeNormSize * fmod(nValidCascade + 1, nCascadesPerRow), fCascadeNormSize * floor((nValidCascade + 1) / nCascadesPerRow));
-
-					// sample from the lower quality cascade and blend between samples appropriately
-					float fPercentLitLQ = PCF4x4Poisson(texShadowMap, f2OneOverShadowMapSize, f3LQCascadeTexCoord.xy, f3LQCascadeTexCoord.z - fShadowDepthBias);
-					fPercentLit = fPercentLit * (1.f - fBlendAmount) + fPercentLitLQ * fBlendAmount;
-				}
+				f3LQCascadeTexCoord.xy =
+					(f3LQCascadeTexCoord.xy * float2(0.5f, -0.5f) + float2(0.5f, 0.5f)) *
+					fCascadeNormSize +
+					float2(fCascadeNormSize * fmod(nValidCascade + 1, nCascadesPerRow), fCascadeNormSize * floor((nValidCascade + 1) / nCascadesPerRow));
+
+				// sample from the lower quality cascade and blend between samples appropriately
+				float fPercentLitLQ = PCF_SAMPLE(texShadowMap, f2OneOverShadowMapSize, f3LQCascadeTexCoord.xy, f3LQCascadeTexCoord.z - fShadowDepthBias);
+				//float fPercentLitLQ = tex2D(texShadowMap, f3LQCascadeTexCoord.xy).r > f3LQCascadeTexCoord.z - fShadowDepthBias;
+				if (fPercentLitLQ > 0.f && fPercentLitLQ < 1.f) // only blend at shadow edges
+					fPercentLit = lerp(fPercentLit, fPercentLitLQ, fBlendAmount);
 			}
 		}
 	}

GITechDemo/Data/shaders/Utils.hlsl

@@ -29,73 +29,197 @@ float3 DecodeNormal(float4 enc)
 // Percentage Closer Filtering variations	//
 //////////////////////////////////////////////
 
-float PCF3x3(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+float PCF2x2Poisson(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+{
+	float2 poissonDisk[4] =
+	{
+		float2(-0.94201624, -0.39906216),
+		float2(0.94558609, -0.76890725),
+		float2(-0.094184101, -0.92938870),
+		float2(0.34495938, 0.29387760)
+	};
+	float percentLit = 0.f;
+
+	for (int i = 0; i < 4; i++)
+	{
+		bool isLit =
+			tex2D(
+			shadowMap,
+			texCoord +
+			poissonDisk[i] * oneOverShadowMapSize
+			).r > depthCompare;
+		percentLit += isLit * 0.25f;
+	}
+
+	return percentLit;
+}
+
+float PCF3x3Poisson(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+{
+	float2 poissonDisk[9] =
+	{
+		float2(0.4677864f, 1.0492188f),
+		float2(0.8965628f, -0.3094058f),
+		float2(-0.3828112f, 1.6226606f),
+		float2(-0.214711f, -0.7530054f),
+		float2(-0.6589904f, 0.4324332f),
+		float2(1.480888f, 1.2347982f),
+		float2(1.9457676f, -0.13916496f),
+		float2(1.1015856f, -1.5681816f),
+		float2(0.06198422f, -1.7864658f)
+	};
+	float percentLit = 0.f;
+
+	for (int i = 0; i < 9; i++)
+	{
+		bool isLit =
+			tex2D(
+			shadowMap,
+			texCoord +
+			poissonDisk[i] * oneOverShadowMapSize
+			).r > depthCompare;
+		percentLit += isLit * 0.1111111f;
+	}
+
+	return percentLit;
+}
+
+float PCF12TapPoisson(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
 {
+	float2 poissonDisk[12] =
+	{
+		float2(-0.5946302f, 0.6008242f),
+		float2(-1.762928f, 0.5199542f),
+		float2(-1.56506f, -0.8692048f),
+		float2(0.14760224f, 1.7710094f),
+		float2(0.7065646f, 0.04265878f),
+		float2(-0.5888886f, -0.429245f),
+		float2(1.024129f, 1.1201256f),
+		float2(-1.118836f, 1.6018892f),
+		float2(-0.9557046f, -1.7215218f),
+		float2(0.02812326f, -1.4003752f),
+		float2(1.6575236f, -0.287287f),
+		float2(1.3867802f, -1.375697f)
+	};
 	float percentLit = 0.f;
+
+	for (int i = 0; i < 12; i++)
+	{
+		bool isLit =
+			tex2D(
+			shadowMap,
+			texCoord +
+			poissonDisk[i] * oneOverShadowMapSize
+			).r > depthCompare;
+		percentLit += isLit * 0.0833333f;
+	}
+
+	return percentLit;
+}
+
+float PCF4x4Poisson(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+{
+	float2 poissonDisk[16] =
+	{
+		float2(2.688109f, 0.686785f),
+		float2(3.0212565f, -1.1432755f),
+		float2(1.9640215f, 1.5282315f),
+		float2(3.293479f, 1.5044285f),
+		float2(3.7991725f, 0.47122805f),
+		float2(1.211579f, 0.587791f),
+		float2(1.8459345f, -0.8353495f),
+		float2(4.1637455f, -0.639698f),
+		float2(2.3383775f, 2.6021615f),
+		float2(4.58543f, 1.3013345f),
+		float2(3.9300595f, 2.3949865f),
+		float2(3.537996f, 3.44172f),
+		float2(1.055484f, 2.1200395f),
+		float2(1.9478455f, 3.7591355f),
+		float2(1.0448675f, 3.2125375f),
+		float2(-0.25313345f, 2.309396f)
+	};
+	float percentLit = 0.f;
+
+	for (int i = 0; i < 16; i++)
+	{
+		bool isLit =
+			tex2D(
+			shadowMap,
+			texCoord +
+			poissonDisk[i] * oneOverShadowMapSize
+			).r > depthCompare;
+		percentLit += isLit * 0.0625f;
+	}
+
+	return percentLit;
+}
+
+float PCF3x3Dithered(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+{
+	// use modulo to vary the sample pattern
+	float2 offset = floor(texCoord.xy) % 3.0;
 
+	float percentLit = 0.f;
 	for(int x = -1; x <= 1; x++)
 		for(int y = -1; y <= 1; y++)
 		{
 			bool isLit =
 				tex2D(
 					shadowMap,
 					texCoord +
-					float2(x * oneOverShadowMapSize.x, y * oneOverShadowMapSize.y)
+					float2(x, y) * oneOverShadowMapSize +
+					offset
 				).r > depthCompare;
 			percentLit += isLit;
 		}
 
 	return percentLit * 0.111111f;
 }
 
-float PCF4x4Poisson(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+float PCF5x5Dithered(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
 {
-	float2 poissonDisk[4] =
-	{
-		float2( -0.94201624, -0.39906216 ),
-		float2( 0.94558609, -0.76890725 ),
-		float2( -0.094184101, -0.92938870 ),
-		float2( 0.34495938, 0.29387760 )
-	};
-	float percentLit = 0.f;
+	// use modulo to vary the sample pattern
+	float2 offset = floor(texCoord.xy) % 5.0;
 
-	for(int i = 0; i < 4; i++)
-	{
-		bool isLit =
-			tex2D(
-				shadowMap,
-				texCoord +
-				poissonDisk[i] * oneOverShadowMapSize
-			).r > depthCompare;
-		percentLit += isLit * 0.2f;
-	}
+	float percentLit = 0.f;
+	for(int x = -2; x <= 2; x++)
+		for(int y = -2; y <= 2; y++)
+		{
+			bool isLit =
+				tex2D(
+					shadowMap,
+					texCoord +
+					float2(x, y) * oneOverShadowMapSize +
+					offset
+				).r > depthCompare;
+			percentLit += isLit;
+		}
 
-	return percentLit;
+	return percentLit * 0.04f;
 }
 
-float PCF4x4Dithered(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+float PCF8x8Dithered(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
 {
 	// use modulo to vary the sample pattern
-	float2 offset = floor(texCoord.xy) % 2.0;
+	float2 offset = floor(texCoord.xy) % 8.0;
 
-	float percentLit = 0.f;
-	percentLit += tex2D(shadowMap, texCoord + (float2(-1.5, 1.5) + offset) * oneOverShadowMapSize).r > depthCompare;
-	percentLit += tex2D(shadowMap, texCoord + (float2(0.5, 1.5) + offset) * oneOverShadowMapSize).r > depthCompare;
-	percentLit += tex2D(shadowMap, texCoord + (float2(-1.5, -0.5) + offset) * oneOverShadowMapSize).r > depthCompare;
-	percentLit += tex2D(shadowMap, texCoord + (float2(0.5, -0.5) + offset) * oneOverShadowMapSize).r > depthCompare;
-	
-	return percentLit * 0.25 ;
+	float x, y, percentLit = 0.f;
+	for (y = -3.5f; y <= 3.5f; y += 1.0f)
+		for (x = -3.5f; x <= 3.5f; x += 1.0f)
+			percentLit += tex2D(shadowMap, texCoord + float2(x, y) * oneOverShadowMapSize + offset).r > depthCompare;
+
+	return percentLit * 0.015625f;
 }
 
 float PCF5x5Gaussian(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
 {
 	const float GaussianKernel[5][5] =
 	{
-		0.00296901674395065, 0.013306209891014005, 0.02193823127971504, 0.013306209891014005, 0.00296901674395065, 
-		0.013306209891014005, 0.05963429543618023, 0.09832033134884507, 0.05963429543618023, 0.013306209891014005, 
-		0.02193823127971504, 0.09832033134884507, 0.16210282163712417, 0.09832033134884507, 0.02193823127971504, 
-		0.013306209891014005, 0.05963429543618023, 0.09832033134884507, 0.05963429543618023, 0.013306209891014005, 
-		0.00296901674395065, 0.013306209891014005, 0.02193823127971504, 0.013306209891014005, 0.00296901674395065
+		0.00296901674395065f, 0.013306209891014005f, 0.02193823127971504f, 0.013306209891014005f, 0.00296901674395065f, 
+		0.013306209891014005f, 0.05963429543618023f, 0.09832033134884507f, 0.05963429543618023f, 0.013306209891014005f,
+		0.02193823127971504f, 0.09832033134884507f, 0.16210282163712417f, 0.09832033134884507f, 0.02193823127971504f,
+		0.013306209891014005f, 0.05963429543618023f, 0.09832033134884507f, 0.05963429543618023f, 0.013306209891014005f,
+		0.00296901674395065f, 0.013306209891014005f, 0.02193823127971504f, 0.013306209891014005f, 0.00296901674395065f
 	};
 	float percentLit = 0.f;
 
@@ -106,21 +230,40 @@ float PCF5x5Gaussian(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 te
 				tex2D(
 					shadowMap,
 					texCoord +
-					float2(x * oneOverShadowMapSize.x, y * oneOverShadowMapSize.y)
+					float2(x, y) * oneOverShadowMapSize
 				).r > depthCompare;
 			percentLit += isLit * GaussianKernel[x+2][y+2];
 		}
 
 	return percentLit;
 }
 
+float PCF3x3(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
+{
+	float percentLit = 0.f;
+
+	for (int x = -1; x <= 1; x++)
+		for (int y = -1; y <= 1; y++)
+		{
+			bool isLit =
+				tex2D(
+				shadowMap,
+				texCoord +
+				float2(x, y) * oneOverShadowMapSize
+				).r > depthCompare;
+			percentLit += isLit;
+		}
+
+	return percentLit * 0.111111f;
+}
+
 float PCF8x8(sampler2D shadowMap, float2 oneOverShadowMapSize, float2 texCoord, float depthCompare)
 {
-	float x, y, percentLit = 0.f;
-	for (y = -3.5 ; y <=3.5 ; y+=1.0)
-		for (x = -3.5 ; x <=3.5 ; x+=1.0)
+	float percentLit = 0.f;
+	for (float y = -3.5f ; y <=3.5f ; y += 1.0f)
+		for (float x = -3.5f ; x <=3.5f ; x += 1.0f)
 			percentLit += tex2D(shadowMap, texCoord + float2(x, y) * oneOverShadowMapSize).r > depthCompare;
 
-	return percentLit / 64.0 ;
+	return percentLit * 0.015625f;
 }
 ////////////////////////////////////////////////////////////////