public static bool ExtractDirectionalLightMatrix(ref CullingResults cullResults, ref ShadowData shadowData, int shadowLightIndex, int cascadeIndex, int shadowmapWidth, int shadowmapHeight, int shadowResolution, float shadowNearPlane, out Vector4 cascadeSplitDistance, out ShadowSliceData shadowSliceData)
{
bool success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
cascadeIndex, shadowData.mainLightShadowCascadesCount, shadowData.mainLightShadowCascadesSplit, shadowResolution, shadowNearPlane, out shadowSliceData.viewMatrix, out shadowSliceData.projectionMatrix,
out shadowSliceData.splitData);
cascadeSplitDistance = shadowSliceData.splitData.cullingSphere;
shadowSliceData.offsetX = (cascadeIndex % 2) * shadowResolution;
shadowSliceData.offsetY = (cascadeIndex / 2) * shadowResolution;
shadowSliceData.resolution = shadowResolution;
shadowSliceData.shadowTransform = GetShadowTransform(shadowSliceData.projectionMatrix, shadowSliceData.viewMatrix);
// This used to be fixed to .6f, but is now configureable.
// It is the culling sphere radius multiplier for shadow cascade blending
shadowSliceData.splitData.shadowCascadeBlendCullingFactor = 0.6f;
// If we have shadow cascades baked into the atlas we bake cascade transform
// in each shadow matrix to save shader ALU and L/S
if (shadowData.mainLightShadowCascadesCount > 1)
{
ApplySliceTransform(ref shadowSliceData, shadowmapWidth, shadowmapHeight);
}
return(success);
}
public static bool ExtractDirectionalLightMatrix(ref CullingResults cullResults, ref ShadowData shadowData, int shadowLightIndex, int cascadeIndex, int shadowmapWidth, int shadowmapHeight, int shadowResolution, float shadowNearPlane, out Vector4 cascadeSplitDistance, out ShadowSliceData shadowSliceData, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix)
{
bool result = ExtractDirectionalLightMatrix(ref cullResults, ref shadowData, shadowLightIndex, cascadeIndex, shadowmapWidth, shadowmapHeight, shadowResolution, shadowNearPlane, out cascadeSplitDistance, out shadowSliceData);
viewMatrix = shadowSliceData.viewMatrix;
projMatrix = shadowSliceData.projectionMatrix;
return(result);
}
public static bool ExtractDirectionalLightMatrix(ref CullingResults cullResults, ref ShadowData shadowData, int shadowLightIndex, int cascadeIndex, int shadowmapWidth, int shadowmapHeight, int shadowResolution, float shadowNearPlane, out Vector4 cascadeSplitDistance, out ShadowSliceData shadowSliceData, out Matrix4x4 viewMatrix, out Matrix4x4 projMatrix)
{
ShadowSplitData splitData;
bool success = cullResults.ComputeDirectionalShadowMatricesAndCullingPrimitives(shadowLightIndex,
cascadeIndex, shadowData.mainLightShadowCascadesCount, shadowData.mainLightShadowCascadesSplit, shadowResolution, shadowNearPlane, out viewMatrix, out projMatrix,
out splitData);
cascadeSplitDistance = splitData.cullingSphere;
shadowSliceData.offsetX = (cascadeIndex % 2) * shadowResolution;
shadowSliceData.offsetY = (cascadeIndex / 2) * shadowResolution;
shadowSliceData.resolution = shadowResolution;
shadowSliceData.viewMatrix = viewMatrix;
shadowSliceData.projectionMatrix = projMatrix;
shadowSliceData.shadowTransform = GetShadowTransform(projMatrix, viewMatrix);
// If we have shadow cascades baked into the atlas we bake cascade transform
// in each shadow matrix to save shader ALU and L/S
if (shadowData.mainLightShadowCascadesCount > 1)
{
ApplySliceTransform(ref shadowSliceData, shadowmapWidth, shadowmapHeight);
}
return(success);
}
public static Vector4 GetShadowBias(ref VisibleLight shadowLight, int shadowLightIndex, ref ShadowData shadowData, Matrix4x4 lightProjectionMatrix, float shadowResolution)
{
if (shadowLightIndex < 0 || shadowLightIndex >= shadowData.bias.Count)
{
Debug.LogWarning(string.Format("{0} is not a valid light index.", shadowLightIndex));
return(Vector4.zero);
}
float frustumSize;
if (shadowLight.lightType == LightType.Directional)
{
// Frustum size is guaranteed to be a cube as we wrap shadow frustum around a sphere
frustumSize = 2.0f / lightProjectionMatrix.m00;
}
else if (shadowLight.lightType == LightType.Spot)
{
// For perspective projections, shadow texel size varies with depth
// It will only work well if done in receiver side in the pixel shader. Currently UniversalRP
// do bias on caster side in vertex shader. When we add shader quality tiers we can properly
// handle this. For now, as a poor approximation we do a constant bias and compute the size of
// the frustum as if it was orthogonal considering the size at mid point between near and far planes.
// Depending on how big the light range is, it will be good enough with some tweaks in bias
frustumSize = Mathf.Tan(shadowLight.spotAngle * 0.5f * Mathf.Deg2Rad) * shadowLight.range; // half-width (in world-space units) of shadow frustum's "far plane"
}
else if (shadowLight.lightType == LightType.Point)
{
// [Copied from above case:]
// "For perspective projections, shadow texel size varies with depth
// It will only work well if done in receiver side in the pixel shader. Currently UniversalRP
// do bias on caster side in vertex shader. When we add shader quality tiers we can properly
// handle this. For now, as a poor approximation we do a constant bias and compute the size of
// the frustum as if it was orthogonal considering the size at mid point between near and far planes.
// Depending on how big the light range is, it will be good enough with some tweaks in bias"
// Note: HDRP uses normalBias both in HDShadowUtils.CalcGuardAnglePerspective and HDShadowAlgorithms/EvalShadow_NormalBias (receiver bias)
float fovBias = Internal.AdditionalLightsShadowCasterPass.GetPointLightShadowFrustumFovBiasInDegrees((int)shadowResolution, (shadowLight.light.shadows == LightShadows.Soft));
// Note: the same fovBias was also used to compute ShadowUtils.ExtractPointLightMatrix
float cubeFaceAngle = 90 + fovBias;
frustumSize = Mathf.Tan(cubeFaceAngle * 0.5f * Mathf.Deg2Rad) * shadowLight.range; // half-width (in world-space units) of shadow frustum's "far plane"
}
else
{
Debug.LogWarning("Only point, spot and directional shadow casters are supported in universal pipeline");
frustumSize = 0.0f;
}
// depth and normal bias scale is in shadowmap texel size in world space
float texelSize = frustumSize / shadowResolution;
float depthBias = -shadowData.bias[shadowLightIndex].x * texelSize;
float normalBias = -shadowData.bias[shadowLightIndex].y * texelSize;
// The current implementation of NormalBias in Universal RP is the same as in Unity Built-In RP (i.e moving shadow caster vertices along normals when projecting them to the shadow map).
// This does not work well with Point Lights, which is why NormalBias value is hard-coded to 0.0 in Built-In RP (see value of unity_LightShadowBias.z in FrameDebugger, and native code that sets it: https://github.cds.internal.unity3d.com/unity/unity/blob/a9c916ba27984da43724ba18e70f51469e0c34f5/Runtime/Camera/Shadows.cpp#L1686 )
// We follow the same convention in Universal RP:
if (shadowLight.lightType == LightType.Point)
{
normalBias = 0.0f;
}
if (shadowData.supportsSoftShadows && shadowLight.light.shadows == LightShadows.Soft)
{
// TODO: depth and normal bias assume sample is no more than 1 texel away from shadowmap
// This is not true with PCF. Ideally we need to do either
// cone base bias (based on distance to center sample)
// or receiver place bias based on derivatives.
// For now we scale it by the PCF kernel size of non-mobile platforms (5x5)
const float kernelRadius = 2.5f;
depthBias *= kernelRadius;
normalBias *= kernelRadius;
}
return(new Vector4(depthBias, normalBias, 0.0f, 0.0f));
}
public static Vector4 GetShadowBias(ref VisibleLight shadowLight, int shadowLightIndex, ref ShadowData shadowData, Matrix4x4 lightProjectionMatrix, float shadowResolution)
{
if (shadowLightIndex < 0 || shadowLightIndex >= shadowData.bias.Count)
{
Debug.LogWarning(string.Format("{0} is not a valid light index.", shadowLightIndex));
return(Vector4.zero);
}
float frustumSize;
if (shadowLight.lightType == LightType.Directional)
{
// Frustum size is guaranteed to be a cube as we wrap shadow frustum around a sphere
frustumSize = 2.0f / lightProjectionMatrix.m00;
}
else if (shadowLight.lightType == LightType.Spot)
{
// For perspective projections, shadow texel size varies with depth
// It will only work well if done in receiver side in the pixel shader. Currently UniversalRP
// do bias on caster side in vertex shader. When we add shader quality tiers we can properly
// handle this. For now, as a poor approximation we do a constant bias and compute the size of
// the frustum as if it was orthogonal considering the size at mid point between near and far planes.
// Depending on how big the light range is, it will be good enough with some tweaks in bias
frustumSize = Mathf.Tan(shadowLight.spotAngle * 0.5f * Mathf.Deg2Rad) * shadowLight.range;
}
else
{
Debug.LogWarning("Only spot and directional shadow casters are supported in universal pipeline");
frustumSize = 0.0f;
}
// depth and normal bias scale is in shadowmap texel size in world space
float texelSize = frustumSize / shadowResolution;
float depthBias = -shadowData.bias[shadowLightIndex].x * texelSize;
float normalBias = -shadowData.bias[shadowLightIndex].y * texelSize;
if (shadowData.supportsSoftShadows)
{
// TODO: depth and normal bias assume sample is no more than 1 texel away from shadowmap
// This is not true with PCF. Ideally we need to do either
// cone base bias (based on distance to center sample)
// or receiver place bias based on derivatives.
// For now we scale it by the PCF kernel size (5x5)
const float kernelRadius = 2.5f;
depthBias *= kernelRadius;
normalBias *= kernelRadius;
}
return(new Vector4(depthBias, normalBias, 0.0f, 0.0f));
}
