124 lines
6.6 KiB
HLSL
124 lines
6.6 KiB
HLSL
#ifndef UTS_SHADOW_EVALUATION
|
|
#define UTS_SHADOW_EVALUATION
|
|
|
|
float3 UtsGetShadowNormal(UtsBSDFData bsdfData)
|
|
{
|
|
#if _MATERIAL_TYPE_FACE
|
|
return normalize(mul(UNITY_MATRIX_M, float4(0.0, 0.0, 1.0, 0.0))).xyz;
|
|
#else
|
|
return bsdfData.geomNormalWS * (1.0 + _ShadowNormalBias);
|
|
#endif
|
|
}
|
|
|
|
float3 SampleSDFTexture(float3 L, float2 uv, out float angle)
|
|
{
|
|
float2 right_uv = float2(1 - uv.x, uv.y);
|
|
float3 left_SDFTex = SAMPLE_TEXTURE2D(_SDFShadingMap, sampler_SDFShadingMap, uv).rgb;
|
|
float3 right_SDFTex = SAMPLE_TEXTURE2D(_SDFShadingMap, sampler_SDFShadingMap, right_uv).rgb;
|
|
|
|
float2 leftVector = normalize(mul(UNITY_MATRIX_M, float4(1.0, 0.0, 0.0, 0.0)).xz);
|
|
float2 forwardVector = normalize(mul(UNITY_MATRIX_M, float4(0.0, 0.0, 1.0, 0.0)).xz);
|
|
|
|
float2 lightDirection = normalize(L.xz);
|
|
angle = saturate(dot(forwardVector, lightDirection) * -1.0 + _SDFShadowLevel);
|
|
bool isRightSide = dot(lightDirection, leftVector) > 0;
|
|
|
|
return isRightSide ? right_SDFTex : left_SDFTex;
|
|
}
|
|
|
|
float GetHairShadow(PositionInputs posInput, float3 L)
|
|
{
|
|
float shadow = 1.0;
|
|
|
|
// Push the face fragment view space position towards the light for a little bit
|
|
float hairShadowOpacity = saturate(Remap(length(posInput.positionWS), float2(_HairShadowFadeOutDistance, _HairShadowFadeInDistance), float2(0, 1)));
|
|
|
|
if (hairShadowOpacity > 0.0)
|
|
{
|
|
float3 viewLightDir = TransformWorldToViewDir(L); // / posInput.deviceDepth; when linearDepth grows large, the movement amount should be lower since we are getting further from the face.
|
|
float3 cameraDirOS = normalize(TransformWorldToObject(GetCameraPositionWS()));
|
|
float shadowLengthY = _HairShadowDistance * 5.0 * max(0.5, posInput.linearDepth * _HairShadowDistanceScaleFactor) / posInput.linearDepth;
|
|
float2 shadowLength = float2(shadowLengthY * 2.0f, shadowLengthY);
|
|
|
|
float3 camDirOS = normalize(TransformWorldToObject(GetCameraPositionWS()));
|
|
float camDirFactor = 1 - smoothstep(0.1, 0.9, camDirOS.y);
|
|
shadowLength.y *= camDirFactor;
|
|
|
|
float2 samplingPoint = (posInput.positionSS + shadowLength * viewLightDir.xy * (_ScreenSize.xy / float2(1920.0f, 1080.0f))) * _ScreenSize.zw; // Use 1080p as the reference resolution to achieve consistent shadow lengths across various screen resolutions.
|
|
|
|
// Then sample the hair buffer, to see if the fragment lands in shadow.
|
|
float2 scaledUVs = samplingPoint * _HairShadowRTHandleScale.xy; // We have to including the scaling factor for our shadow map since we are not going to allocate new texture if the rendering resolution changed.
|
|
float hairDepth = SAMPLE_TEXTURE2D(_HairShadowTex, s_linear_clamp_sampler, scaledUVs).r;
|
|
float shadowMask = posInput.deviceDepth <= hairDepth + _HairShadowDepthBias ? 1 : 0; // Hair < Face means Hair are closer to camera
|
|
// Note that we have LinearEyeDepth in the buffer. A comparison of depth is needed so that we don't project the shadow of hair behind the face.
|
|
shadow = lerp(1, 1.0 - hairShadowOpacity, shadowMask);
|
|
}
|
|
|
|
return shadow;
|
|
}
|
|
|
|
// distances = {d, d^2, 1/d, d_proj}, where d_proj = dot(lightToSample, light.forward).
|
|
SHADOW_TYPE UtsEvaluateShadow_Punctual(LightLoopContext lightLoopContext, PositionInputs posInput, LightData light, BuiltinData builtinData, float3 N, float3 L, float4 distances)
|
|
{
|
|
#ifndef LIGHT_EVALUATION_NO_SHADOWS
|
|
float shadow = 1.0;
|
|
float shadowMask = 1.0;
|
|
float NdotL = dot(N, L); // Disable contact shadow and shadow mask when facing away from light (i.e transmission)
|
|
|
|
#ifdef SHADOWS_SHADOWMASK
|
|
// shadowMaskSelector.x is -1 if there is no shadow mask
|
|
// Note that we override shadow value (in case we don't have any dynamic shadow)
|
|
shadow = shadowMask = (light.shadowMaskSelector.x >= 0.0 && NdotL > 0.0) ? dot(BUILTIN_DATA_SHADOW_MASK, light.shadowMaskSelector) : 1.0;
|
|
#endif
|
|
|
|
#if defined(SCREEN_SPACE_SHADOWS_ON) && !defined(_SURFACE_TYPE_TRANSPARENT) && defined(_RECEIVE_SCREEN_SPACE_SHADOW_ON)
|
|
if ((light.screenSpaceShadowIndex & SCREEN_SPACE_SHADOW_INDEX_MASK) != INVALID_SCREEN_SPACE_SHADOW)
|
|
{
|
|
shadow = GetScreenSpaceShadow(posInput, light.screenSpaceShadowIndex);
|
|
shadow = lerp(shadowMask, shadow, light.shadowDimmer);
|
|
}
|
|
else
|
|
#endif
|
|
if ((light.shadowIndex >= 0) && (light.shadowDimmer > 0))
|
|
{
|
|
shadow = GetPunctualShadowAttenuation(lightLoopContext.shadowContext, posInput.positionSS, posInput.positionWS + L * _ShadowDistanceBias, N, light.shadowIndex, L, distances.x, light.lightType == GPULIGHTTYPE_POINT, light.lightType != GPULIGHTTYPE_PROJECTOR_BOX);
|
|
|
|
#ifdef SHADOWS_SHADOWMASK
|
|
// Note: Legacy Unity have two shadow mask mode. ShadowMask (ShadowMask contain static objects shadow and ShadowMap contain only dynamic objects shadow, final result is the minimun of both value)
|
|
// and ShadowMask_Distance (ShadowMask contain static objects shadow and ShadowMap contain everything and is blend with ShadowMask based on distance (Global distance setup in QualitySettigns)).
|
|
// HDRenderPipeline change this behavior. Only ShadowMask mode is supported but we support both blend with distance AND minimun of both value. Distance is control by light.
|
|
// The following code do this.
|
|
// The min handle the case of having only dynamic objects in the ShadowMap
|
|
// The second case for blend with distance is handled with ShadowDimmer. ShadowDimmer is define manually and by shadowDistance by light.
|
|
// With distance, ShadowDimmer become one and only the ShadowMask appear, we get the blend with distance behavior.
|
|
shadow = light.nonLightMappedOnly ? min(shadowMask, shadow) : shadow;
|
|
#endif
|
|
|
|
shadow = lerp(shadowMask, shadow, light.shadowDimmer);
|
|
}
|
|
|
|
// Transparents have no contact shadow information
|
|
#if !defined(_SURFACE_TYPE_TRANSPARENT) && !defined(LIGHT_EVALUATION_NO_CONTACT_SHADOWS)
|
|
{
|
|
// In certain cases (like hair) we allow to force the contact shadow sample.
|
|
#ifdef LIGHT_EVALUATION_CONTACT_SHADOW_DISABLE_NDOTL
|
|
const bool allowContactShadow = true;
|
|
#else
|
|
const bool allowContactShadow = NdotL > 0.0;
|
|
#endif
|
|
|
|
shadow = min(shadow, allowContactShadow ? GetContactShadow(lightLoopContext, light.contactShadowMask, light.isRayTracedContactShadow) : 1.0);
|
|
}
|
|
#endif
|
|
|
|
#ifdef DEBUG_DISPLAY
|
|
if (_DebugShadowMapMode == SHADOWMAPDEBUGMODE_SINGLE_SHADOW && light.shadowIndex == _DebugSingleShadowIndex)
|
|
g_DebugShadowAttenuation = shadow;
|
|
#endif
|
|
return shadow;
|
|
#else // LIGHT_EVALUATION_NO_SHADOWS
|
|
return 1.0;
|
|
#endif
|
|
}
|
|
|
|
#endif |